PageRenderTime 56ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 0ms

/Languages/IronPython/Tests/test_function.py

http://github.com/IronLanguages/main
Python | 1409 lines | 1353 code | 37 blank | 19 comment | 27 complexity | 8d1da236f8b1091452a8e609dbcbc6b9 MD5 | raw file
Possible License(s): CPL-1.0, BSD-3-Clause, ISC, GPL-2.0, MPL-2.0-no-copyleft-exception 
    

  1. ######################################################################################
    2. 

  2. #
    3. 

  3. #  Copyright (c) Microsoft Corporation. All rights reserved.
    4. 

  4. #
    5. 

  5. # This source code is subject to terms and conditions of the Apache License, Version 2.0. A 
    6. 

  6. # copy of the license can be found in the License.html file at the root of this distribution. If 
    7. 

  7. # you cannot locate the  Apache License, Version 2.0, please send an email to 
    8. 

  8. # ironpy@microsoft.com. By using this source code in any fashion, you are agreeing to be bound 
    9. 

  9. # by the terms of the Apache License, Version 2.0.
    10. 

  10. #
    11. 

  11. # You must not remove this notice, or any other, from this software.
    12. 

  12. #
    13. 

  13. #
    14. 

  14. #####################################################################################
    15. 

  15. 

  16. from iptest.assert_util import *
    17. 

  17. 

  18. from types import FunctionType
    19. 

  19. 

  20. def x(a,b,c):
    21. 

  21.     z = 8
    22. 

  22.     if a < b:
    23. 

  23.         return c
    24. 

  24.     elif c < 5 :
    25. 

  25.         return a + b
    26. 

  26.     else:
    27. 

  27.         return z
    28. 

  28. 

  29. 

  30. Assert(x(1,2,10) == 10)
    31. 

  31. Assert(x(2,1,4) == 3)
    32. 

  32. Assert(x(1,1,10) == 8)
    33. 

  33. 

  34. def f():
    35. 

  35.     pass
    36. 

  36. 

  37. f.a = 10
    38. 

  38. 

  39. Assert(f.a == 10)
    40. 

  40. AreEqual(f.__module__, __name__)
    41. 

  41. 

  42. def g():
    43. 

  43.     g.a = 20
    44. 

  44. 

  45. g()
    46. 

  46. 

  47. Assert(g.a == 20)
    48. 

  48. 

  49. 

  50. def foo(): pass
    51. 

  51. 

  52. AreEqual(foo.func_code.co_filename.lower().endswith('test_function.py'), True)
    53. 

  53. AreEqual(foo.func_code.co_firstlineno, 50)  # if you added lines to the top of this file you need to update this number.
    54. 

  54. 

  55. 

  56. # Cannot inherit from a function
    57. 

  57. def CreateSubType(t):
    58. 

  58.     class SubType(t): pass
    59. 

  59.     return SubType
    60. 

  60.     
    61. 

  61. if not is_silverlight:
    62. 

  62.     AssertErrorWithMatch(TypeError, ".*\n?.* is not an acceptable base type", CreateSubType, type(foo))
    63. 

  63. else:
    64. 

  64.     try:
    65. 

  65.         CreateSubType(type(foo))
    66. 

  66.     except TypeError, e:
    67. 

  67.         Assert(e.message.find("is not an acceptable base type") != -1)
    68. 

  68. 

  69. def a(*args): return args
    70. 

  70. def b(*args): return a(*args)
    71. 

  71. AreEqual(b(1,2,3), (1,2,3))
    72. 

  72. 

  73. # some coverage for Function3 code
    74. 

  74. def xwd(a=0,b=1,c=3):
    75. 

  75.     z = 8
    76. 

  76.     if a < b:
    77. 

  77.         return c
    78. 

  78.     elif c < 5 :
    79. 

  79.         return a + b
    80. 

  80.     else:
    81. 

  81.         return z
    82. 

  82.         
    83. 

  83. AreEqual(x,x)
    84. 

  84. AreEqual(xwd(), 3)
    85. 

  85. AssertError(TypeError, (lambda:x()))
    86. 

  86. AreEqual(xwd(2), 3)
    87. 

  87. AssertError(TypeError, (lambda:x(1)))
    88. 

  88. AreEqual(xwd(0,5), 3)
    89. 

  89. AssertError(TypeError, (lambda:x(0,5)))
    90. 

  90. AreEqual( (x == "not-a-Function3"), False)
    91. 

  91. 

  92. def y(a,b,c,d):
    93. 

  93. 	return a+b+c+d
    94. 

  94. 

  95. def ywd(a=0, b=1, c=2, d=3):
    96. 

  96. 	return a+b+c+d
    97. 

  97. 

  98. AreEqual(y, y)
    99. 

  99. AreEqual(ywd(), 6)
    100. 

  100. AssertError(TypeError, y)
    101. 

  101. AreEqual(ywd(4), 10)
    102. 

  102. AssertError(TypeError, y, 4)
    103. 

  103. AreEqual(ywd(4,5), 14)
    104. 

  104. AssertError(TypeError, y, 4, 5)
    105. 

  105. AreEqual(ywd(4,5,6), 18)
    106. 

  106. AssertError(TypeError, y, 4,5,6)
    107. 

  107. AreEqual( (y == "not-a-Function4"), False)
    108. 

  108. 

  109. def foo(): "hello world"
    110. 

  110. AreEqual(foo.__doc__, 'hello world')
    111. 

  111. 

  112. ############# coverage ############# 
    113. 

  113. 

  114. # function5
    115. 

  115. def f1(a=1, b=2, c=3, d=4, e=5):    return a * b * c * d * e
    116. 

  116. def f2(a, b=2, c=3, d=4, e=5):    return a * b * c * d * e
    117. 

  117. def f3(a, b, c=3, d=4, e=5):    return a * b * c * d * e
    118. 

  118. def f4(a, b, c, d=4, e=5):    return a * b * c * d * e
    119. 

  119. def f5(a, b, c, d, e=5):    return a * b * c * d * e
    120. 

  120. def f6(a, b, c, d, e):    return a * b * c * d * e
    121. 

  121. 

  122. for f in (f1, f2, f3, f4, f5, f6):
    123. 

  123.     AssertError(TypeError, f, 1, 1, 1, 1, 1, 1)             # 6 args
    124. 

  124.     AreEqual(f(10,11,12,13,14), 10 * 11 * 12 * 13 * 14)     # 5 args
    125. 

  125. 

  126. for f in (f1, f2, f3, f4, f5):
    127. 

  127.     AreEqual(f(10,11,12,13), 10 * 11 * 12 * 13 * 5)         # 4 args
    128. 

  128. for f in (f6,):    
    129. 

  129.     AssertError(TypeError, f, 1, 1, 1, 1)
    130. 

  130. 

  131. for f in (f1, f2, f3, f4):
    132. 

  132.     AreEqual(f(10,11,12), 10 * 11 * 12 * 4 * 5)             # 3 args
    133. 

  133. for f in (f5, f6):    
    134. 

  134.     AssertError(TypeError, f, 1, 1, 1)
    135. 

  135. 

  136. for f in (f1, f2, f3):
    137. 

  137.     AreEqual(f(10,11), 10 * 11 * 3 * 4 * 5)                 # 2 args
    138. 

  138. for f in (f4, f5, f6):    
    139. 

  139.     AssertError(TypeError, f, 1, 1)
    140. 

  140. 

  141. for f in (f1, f2):
    142. 

  142.     AreEqual(f(10), 10 * 2 * 3 * 4 * 5)                     # 1 args
    143. 

  143. for f in (f3, f4, f5, f6):    
    144. 

  144.     AssertError(TypeError, f, 1)
    145. 

  145. 

  146. for f in (f1,):
    147. 

  147.     AreEqual(f(), 1 * 2 * 3 * 4 * 5)                        # no args
    148. 

  148. for f in (f2, f3, f4, f5, f6):    
    149. 

  149.     AssertError(TypeError, f)
    150. 

  150. 

  151. 

  152. # method
    153. 

  153. class C1:
    154. 

  154.     def f0(self): return 0
    155. 

  155.     def f1(self, a): return 1
    156. 

  156.     def f2(self, a, b): return 2
    157. 

  157.     def f3(self, a, b, c): return 3
    158. 

  158.     def f4(self, a, b, c, d): return 4
    159. 

  159.     def f5(self, a, b, c, d, e): return 5
    160. 

  160.     def f6(self, a, b, c, d, e, f): return 6
    161. 

  161.     def f7(self, a, b, c, d, e, f, g): return 7
    162. 

  162. 

  163. class C2: pass
    164. 

  164. 

  165. c1, c2 = C1(), C2()
    166. 

  166. 

  167. line = ""
    168. 

  168. for i in range(8):
    169. 

  169.     args = ",".join(['1'] * i)
    170. 

  170.     line += "AreEqual(c1.f%d(%s), %d)\n" % (i, args, i)
    171. 

  171.     line +=  "AreEqual(C1.f%d(c1,%s), %d)\n" % (i, args, i)
    172. 

  172.     #line +=  "try: C1.f%d(%s) \nexcept TypeError: pass \nelse: raise AssertionError\n" % (i, args)
    173. 

  173.     #line +=  "try: C1.f%d(c2, %s) \nexcept TypeError: pass \nelse: raise AssertionError\n" % (i, args)
    174. 

  174. 

  175. #print line
    176. 

  176. exec line    
    177. 

  177. 

  178. def SetAttrOfInstanceMethod():
    179. 

  179.     C1.f0.attr = 1
    180. 

  180. AssertError(AttributeError, SetAttrOfInstanceMethod)
    181. 

  181. 

  182. C1.f0.im_func.attr = 1
    183. 

  183. AreEqual(C1.f0.attr, 1)
    184. 

  184. AreEqual(dir(C1.f0).__contains__("attr"), True)
    185. 

  185. 

  186. AreEqual(C1.f0.__module__, __name__)
    187. 

  187. 

  188. ######################################################################################
    189. 

  189. 

  190. from iptest.assert_util import *
    191. 

  191. 

  192. def f(x=0, y=10, z=20, *args, **kws):
    193. 

  193.     return (x, y, z), args, kws
    194. 

  194. 

  195. Assert(f(10, l=20) == ((10, 10, 20), (), {'l': 20}))
    196. 

  196. 

  197. Assert(f(1, *(2,), **{'z':20}) == ((1, 2, 20), (), {}))
    198. 

  198. 

  199. Assert(f(*[1,2,3]) == ((1, 2, 3), (), {}))
    200. 

  200. 

  201. def a(*args, **kws): return args, kws
    202. 

  202. 

  203. def b(*args, **kws):
    204. 

  204.     return a(*args, **kws)
    205. 

  205. 

  206. Assert(b(1,2,3, x=10, y=20) == ((1, 2, 3), {'y': 20, 'x': 10}))
    207. 

  207. 

  208. def b(*args, **kws):
    209. 

  209.     return a(**kws)
    210. 

  210. 

  211. Assert(b(1,2,3, x=10, y=20) == ((), {'y': 20, 'x': 10}))
    212. 

  212. 

  213. try:
    214. 

  214.     b(**[])
    215. 

  215.     Assert(False)
    216. 

  216. except TypeError:
    217. 

  217.     pass
    218. 

  218. 

  219. def f(x, *args):
    220. 

  220.     return (x, args)
    221. 

  221. 

  222. AreEqual(f(1, *[2]), (1, (2,)))
    223. 

  223. AreEqual(f(7, *(i for i in range(3))), (7, (0, 1, 2,)))
    224. 

  224. AreEqual(f(9, *range(11, 13)), (9, (11, 12)))
    225. 

  225. 

  226. #verify we can call sorted w/ keyword args
    227. 

  227. 

  228. import operator
    229. 

  229. inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)]
    230. 

  230. getcount = operator.itemgetter(1)
    231. 

  231. 

  232. sorted_inventory = sorted(inventory, key=getcount)
    233. 

  233. 

  234. 

  235. # verify proper handling of keyword args for python functions
    236. 

  236. def kwfunc(a,b,c):  pass
    237. 

  237. 

  238. try:
    239. 

  239.     kwfunc(10, 20, b=30)
    240. 

  240.     Assert(False)
    241. 

  241. except TypeError:
    242. 

  242.     pass
    243. 

  243. 

  244. try:
    245. 

  245.     kwfunc(10, None, b=30)
    246. 

  246.     Assert(False)
    247. 

  247. except TypeError:
    248. 

  248.     pass
    249. 

  249. 

  250. 

  251. try:
    252. 

  252.     kwfunc(10, None, 40, b=30)
    253. 

  253.     Assert(False)
    254. 

  254. except TypeError:
    255. 

  255.     pass
    256. 

  256. 

  257. if is_cli or is_silverlight:
    258. 

  258.     import System    
    259. 

  259.     
    260. 

  260.     # Test Hashtable and Dictionary on desktop, and just Dictionary in Silverlight
    261. 

  261.     # (Hashtable is not available)
    262. 

  262.     htlist = [System.Collections.Generic.Dictionary[System.Object, System.Object]()]
    263. 

  263.     if not is_silverlight:
    264. 

  264.         if is_netstandard:
    265. 

  265.             import clr
    266. 

  266.             clr.AddReference("System.Collections.NonGeneric")
    267. 

  267.         htlist += [System.Collections.Hashtable()]
    268. 

  268. 

  269.     for ht in htlist:
    270. 

  270.         def foo(**kwargs):
    271. 

  271.             return kwargs['key']
    272. 

  272.             
    273. 

  273.         ht['key'] = 'xyz'
    274. 

  274.         
    275. 

  275.         AreEqual(foo(**ht), 'xyz')
    276. 

  276. 

  277. def foo(a,b):
    278. 

  278.     return a-b
    279. 

  279.     
    280. 

  280. AreEqual(foo(b=1, *(2,)), 1)
    281. 

  281. 

  282. # kw-args passed to init through method instance
    283. 

  283. 

  284. class foo:
    285. 

  285.     def __init__(self, group=None, target=None):
    286. 

  286.             AreEqual(group, None)
    287. 

  287.             AreEqual(target,'baz')
    288. 

  288. 

  289. a = foo(target='baz')
    290. 

  290. 

  291. foo.__init__(a, target='baz')
    292. 

  292. 

  293. 

  294. # call a params method w/ no params
    295. 

  295. 

  296. if is_cli or is_silverlight:
    297. 

  297.     import clr
    298. 

  298.     AreEqual('abc\ndef'.Split()[0], 'abc') 
    299. 

  299.     AreEqual('abc\ndef'.Split()[1], 'def')
    300. 

  300.     x = 'a bc   def'.Split()
    301. 

  301.     AreEqual(x[0], 'a')
    302. 

  302.     AreEqual(x[1], 'bc')
    303. 

  303.     AreEqual(x[2], '')
    304. 

  304.     AreEqual(x[3], '')
    305. 

  305.     AreEqual(x[4], 'def')
    306. 

  306.     
    307. 

  307.     # calling Double.ToString(...) should work - Double is
    308. 

  308.     # an OpsExtensibleType and doesn't define __str__ on this
    309. 

  309.     # overload
    310. 

  310.     
    311. 

  311.     AreEqual(System.Double.ToString(1.0, 'f'), '1.00')
    312. 

  312. 

  313. ######################################################################################
    314. 

  314. # Incorrect number of arguments
    315. 

  315. 

  316. def f(a): pass
    317. 

  317. 

  318. AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (0 given)", f)
    319. 

  319. AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (3 given)", f, 1, 2, 3)
    320. 

  320. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=2)
    321. 

  321. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=2)
    322. 

  322. #AssertError calls f(*args), which generates a different AST than f(1,2,3)
    323. 

  323. AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (0 given)", lambda:f())
    324. 

  324. AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (3 given)", lambda:f(1, 2, 3))
    325. 

  325. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(dummy=2))
    326. 

  326. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(1, dummy=2))
    327. 

  327. 

  328. def f(a,b,c,d,e,f,g,h,i,j): pass
    329. 

  329. 

  330. AssertErrorWithMessage(TypeError, "f() takes exactly 10 arguments (0 given)", f)
    331. 

  331. AssertErrorWithMessage(TypeError, "f() takes exactly 10 arguments (3 given)", f, 1, 2, 3)
    332. 

  332. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=2)
    333. 

  333. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=2)
    334. 

  334. AssertErrorWithMessage(TypeError, "f() takes exactly 10 arguments (0 given)", lambda:f())
    335. 

  335. AssertErrorWithMessage(TypeError, "f() takes exactly 10 arguments (3 given)", lambda:f(1, 2, 3))
    336. 

  336. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(dummy=2))
    337. 

  337. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(1, dummy=2))
    338. 

  338. 

  339. def f(a, b=2): pass
    340. 

  340. 

  341. AssertErrorWithMessage(TypeError, "f() takes at least 1 argument (0 given)", f)
    342. 

  342. AssertErrorWithMessage(TypeError, "f() takes at most 2 arguments (3 given)", f, 1, 2, 3)
    343. 

  343. if is_cpython: #CPython bug 9326
    344. 

  344.     AssertErrorWithMessage(TypeError, "f() takes at least 1 argument (1 given)", f, b=2)
    345. 

  345. else:
    346. 

  346.     AssertErrorWithMessage(TypeError, "f() takes at least 1 non-keyword argument (0 given)", f, b=2)
    347. 

  347. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=3)
    348. 

  348. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, b=2, dummy=3)
    349. 

  349. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, 1, dummy=3)
    350. 

  350. AssertErrorWithMessage(TypeError, "f() takes at least 1 argument (0 given)", lambda:f())
    351. 

  351. AssertErrorWithMessage(TypeError, "f() takes at most 2 arguments (3 given)", lambda:f(1, 2, 3))
    352. 

  352. if is_cpython: #CPython bug 9326
    353. 

  353.     AssertErrorWithMessage(TypeError, "f() takes at least 1 argument (1 given)", lambda:f(b=2))
    354. 

  354. else:
    355. 

  355.     AssertErrorWithMessage(TypeError, "f() takes at least 1 non-keyword argument (0 given)", lambda:f(b=2))
    356. 

  356. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(dummy=3))
    357. 

  357. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(b=2, dummy=3))
    358. 

  358. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(1, dummy=3))
    359. 

  359. 

  360. def f(a, *argList): pass
    361. 

  361. 

  362. AssertErrorWithMessage(TypeError, "f() takes at least 1 argument (0 given)", f)
    363. 

  363. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=2)
    364. 

  364. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, 1, dummy=2)
    365. 

  365. AssertErrorWithMessage(TypeError, "f() takes at least 1 argument (0 given)", lambda:f())
    366. 

  366. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(dummy=2))
    367. 

  367. AssertErrorWithMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(1, dummy=2))
    368. 

  368. 

  369. def f(a, **keywordDict): pass
    370. 

  370. 

  371. AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (0 given)", f)
    372. 

  372. AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (3 given)", f, 1, 2, 3)
    373. 

  373. if is_cpython: #CPython bug 9326
    374. 

  374.     AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (0 given)", f, dummy=2)
    375. 

  375.     AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (0 given)", f, dummy=2, dummy2=3)
    376. 

  376. else:
    377. 

  377.     AssertErrorWithMessage(TypeError, "f() takes exactly 1 non-keyword argument (0 given)", f, dummy=2)
    378. 

  378.     AssertErrorWithMessage(TypeError, "f() takes exactly 1 non-keyword argument (0 given)", f, dummy=2, dummy2=3)
    379. 

  379. AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (0 given)", lambda:f())
    380. 

  380. AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (3 given)", lambda:f(1, 2, 3))
    381. 

  381. if is_cpython: #CPython bug 9326
    382. 

  382.     AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (0 given)", lambda:f(dummy=2))
    383. 

  383.     AssertErrorWithMessage(TypeError, "f() takes exactly 1 argument (0 given)", lambda:f(dummy=2, dummy2=3))
    384. 

  384. else:
    385. 

  385.     AssertErrorWithMessage(TypeError, "f() takes exactly 1 non-keyword argument (0 given)", lambda:f(dummy=2))
    386. 

  386.     AssertErrorWithMessage(TypeError, "f() takes exactly 1 non-keyword argument (0 given)", lambda:f(dummy=2, dummy2=3))
    387. 

  387. 

  388. AssertErrorWithMessages(TypeError, "abs() takes exactly 1 argument (0 given)",
    389. 

  389.                                    "abs() takes exactly one argument (0 given)",   abs)
    390. 

  390. AssertErrorWithMessages(TypeError, "abs() takes exactly 1 argument (3 given)",
    391. 

  391.                                    "abs() takes exactly one argument (3 given)",   abs, 1, 2, 3)
    392. 

  392. AssertErrorWithMessages(TypeError, "abs() got an unexpected keyword argument 'dummy'",
    393. 

  393.                                    "abs() takes no keyword arguments",             abs, dummy=2)
    394. 

  394. AssertErrorWithMessages(TypeError, "abs() takes exactly 1 argument (2 given)",
    395. 

  395.                                    "abs() takes no keyword arguments",             abs, 1, dummy=2)
    396. 

  396. AssertErrorWithMessages(TypeError, "abs() takes exactly 1 argument (0 given)",
    397. 

  397.                                    "abs() takes exactly one argument (0 given)",   lambda:abs())
    398. 

  398. AssertErrorWithMessages(TypeError, "abs() takes exactly 1 argument (3 given)",
    399. 

  399.                                    "abs() takes exactly one argument (3 given)",   lambda:abs(1, 2, 3))
    400. 

  400. AssertErrorWithMessages(TypeError, "abs() got an unexpected keyword argument 'dummy'",
    401. 

  401.                                    "abs() takes no keyword arguments",             lambda:abs(dummy=2))
    402. 

  402. AssertErrorWithMessages(TypeError, "abs() takes exactly 1 argument (2 given)",
    403. 

  403.                                    "abs() takes no keyword arguments",             lambda:abs(1, dummy=2))
    404. 

  404. 

  405. # list([m]) has one default argument (built-in type)
    406. 

  406. #AssertErrorWithMessage(TypeError, "list() takes at most 1 argument (2 given)", list, 1, 2)
    407. 

  407. #AssertErrorWithMessage(TypeError, "'dummy' is an invalid keyword argument for this function", apply, list, [], dict({"dummy":2}))
    408. 

  408. 

  409. #======== BUG 697 ===========
    410. 

  410. #AssertErrorWithMessage(TypeError, "'dummy' is an invalid keyword argument for this function", apply, list, [1], dict({"dummy":2}))
    411. 

  411. 

  412. # complex([x,y]) has two default argument (OpsReflectedType type)
    413. 

  413. #AssertErrorWithMessage(TypeError, "complex() takes at most 2 arguments (3 given)", complex, 1, 2, 3)
    414. 

  414. #AssertErrorWithMessage(TypeError, "'dummy' is an invalid keyword argument for this function", apply, complex, [], dict({"dummy":2}))
    415. 

  415. #AssertErrorWithMessage(TypeError, "'dummy' is an invalid keyword argument for this function", apply, complex, [1], dict({"dummy":2}))
    416. 

  416. 

  417. # bool([x]) has one default argument (OpsReflectedType and valuetype type)
    418. 

  418. #AssertErrorWithMessage(TypeError, "bool() takes at most 1 argument (2 given)", bool, 1, 2)
    419. 

  419. #AssertErrorWithMessage(TypeError, "'dummy' is an invalid keyword argument for this function", apply, bool, [], dict({"dummy":2}))
    420. 

  420. #AssertErrorWithMessage(TypeError, "'dummy' is an invalid keyword argument for this function", apply, bool, [1], dict({"dummy":2}))
    421. 

  421. 

  422. class UserClass(object): pass
    423. 

  423. AssertErrorWithMessage(TypeError, "object.__new__() takes no parameters", UserClass, 1)
    424. 

  424. AssertErrorWithMessage(TypeError, "object.__new__() takes no parameters", apply, UserClass, [], dict({"dummy":2}))
    425. 

  425.     
    426. 

  426. class OldStyleClass: pass
    427. 

  427. AssertErrorWithMessage(TypeError, "this constructor takes no arguments", OldStyleClass, 1)
    428. 

  428. AssertErrorWithMessage(TypeError, "this constructor takes no arguments", apply, OldStyleClass, [], dict({"dummy":2}))
    429. 

  429. 

  430. ###############################################################################################
    431. 

  431. # accepts / returns runtype type checking tests
    432. 

  432. 

  433. if is_cli or is_silverlight:
    434. 

  434.     import clr
    435. 

  435.     
    436. 

  436.     @clr.accepts(object)
    437. 

  437.     def foo(x): 
    438. 

  438.         return x
    439. 

  439. 

  440.     AreEqual(foo('abc'), 'abc')
    441. 

  441.     AreEqual(foo(2), 2)
    442. 

  442.     AreEqual(foo(2L), 2L)
    443. 

  443.     AreEqual(foo(2.0), 2.0)
    444. 

  444.     AreEqual(foo(True), True)
    445. 

  445. 

  446. 

  447.     @clr.accepts(str)
    448. 

  448.     def foo(x):
    449. 

  449.         return x
    450. 

  450.         
    451. 

  451.     AreEqual(foo('abc'), 'abc')
    452. 

  452.     AssertError(AssertionError, foo, 2)
    453. 

  453.     AssertError(AssertionError, foo, 2L)
    454. 

  454.     AssertError(AssertionError, foo, 2.0)
    455. 

  455.     AssertError(AssertionError, foo, True)
    456. 

  456. 

  457.     @clr.accepts(str, bool)
    458. 

  458.     def foo(x, y):
    459. 

  459.         return x, y
    460. 

  460. 

  461.     AreEqual(foo('abc', True), ('abc', True))
    462. 

  462.     AssertError(AssertionError, foo, ('abc',2))
    463. 

  463.     AssertError(AssertionError, foo, ('abc',2L))
    464. 

  464.     AssertError(AssertionError, foo, ('abc',2.0))
    465. 

  465. 

  466. 

  467.     class bar:  
    468. 

  468.         @clr.accepts(clr.Self(), str)
    469. 

  469.         def foo(self, x):
    470. 

  470.             return x
    471. 

  471. 

  472. 

  473.     a = bar()
    474. 

  474.     AreEqual(a.foo('xyz'), 'xyz')
    475. 

  475.     AssertError(AssertionError, a.foo, 2)
    476. 

  476.     AssertError(AssertionError, a.foo, 2L)
    477. 

  477.     AssertError(AssertionError, a.foo, 2.0)
    478. 

  478.     AssertError(AssertionError, a.foo, True)
    479. 

  479. 

  480.     @clr.returns(str)
    481. 

  481.     def foo(x):
    482. 

  482.         return x
    483. 

  483. 

  484. 

  485.     AreEqual(foo('abc'), 'abc')
    486. 

  486.     AssertError(AssertionError, foo, 2)
    487. 

  487.     AssertError(AssertionError, foo, 2L)
    488. 

  488.     AssertError(AssertionError, foo, 2.0)
    489. 

  489.     AssertError(AssertionError, foo, True)
    490. 

  490. 

  491.     @clr.accepts(bool)
    492. 

  492.     @clr.returns(str)
    493. 

  493.     def foo(x):
    494. 

  494.         if x: return str(x)
    495. 

  495.         else: return 0
    496. 

  496.         
    497. 

  497.     AreEqual(foo(True), 'True')
    498. 

  498. 

  499.     AssertError(AssertionError, foo, 2)
    500. 

  500.     AssertError(AssertionError, foo, 2)
    501. 

  501.     AssertError(AssertionError, foo, False)
    502. 

  502. 

  503.     @clr.returns(None)
    504. 

  504.     def foo(): pass
    505. 

  505. 

  506.     AreEqual(foo(), None)
    507. 

  507. 

  508. try:
    509. 

  509.     buffer()
    510. 

  510. except TypeError, e:
    511. 

  511.     # make sure we get the right type name when calling w/ wrong # of args
    512. 

  512.     AreEqual(str(e)[:8], 'buffer()')
    513. 

  513.     
    514. 

  514. #try:
    515. 

  515. #    list(1,2,3)
    516. 

  516. #except TypeError, e:
    517. 

  517.     # make sure we get the right type name when calling w/ wrong # of args
    518. 

  518. #    AreEqual(str(e)[:6], 'list()')    
    519. 

  519. 

  520. # oldinstance
    521. 

  521. class foo:
    522. 

  522.     def bar(self): pass
    523. 

  523.     def bar1(self, xyz): pass
    524. 

  524.     
    525. 

  525. class foo2: pass
    526. 

  526. class foo3(object): pass
    527. 

  527. 

  528. AssertError(TypeError, foo.bar)
    529. 

  529. AssertError(TypeError, foo.bar1, None, None)
    530. 

  530. AssertError(TypeError, foo.bar1, None, 'abc')
    531. 

  531. AssertError(TypeError, foo.bar1, 'xyz', 'abc')
    532. 

  532. AssertError(TypeError, foo.bar, foo2())
    533. 

  533. AssertError(TypeError, foo.bar, foo3())
    534. 

  534. 

  535. # usertype
    536. 

  536. class foo(object):
    537. 

  537.     def bar(self): pass
    538. 

  538.     def bar1(self, xyz): pass
    539. 

  539. 

  540. AssertError(TypeError, foo.bar)
    541. 

  541. AssertError(TypeError, foo.bar1, None, None)
    542. 

  542. AssertError(TypeError, foo.bar1, None, 'abc')
    543. 

  543. AssertError(TypeError, foo.bar1, 'xyz', 'abc')
    544. 

  544. AssertError(TypeError, foo.bar, foo2())
    545. 

  545. AssertError(TypeError, foo.bar, foo3())
    546. 

  546. 

  547. # access a method w/ caller context w/ an args parameter.
    548. 

  548. def foo(*args):
    549. 

  549.     return hasattr(*args)
    550. 

  550.     
    551. 

  551. AreEqual(foo('', 'index'), True)
    552. 

  552. 

  553. # dispatch to a ReflectOptimized method
    554. 

  554. 

  555. if is_cli:
    556. 

  556.     from iptest.console_util import IronPythonInstance
    557. 

  557.     from System import Environment
    558. 

  558.     from sys import executable
    559. 

  559.     
    560. 

  560.     wkdir = testpath.public_testdir
    561. 

  561.     
    562. 

  562.     if "-X:LightweightScopes" in Environment.GetCommandLineArgs():
    563. 

  563.         ipi = IronPythonInstance(executable, wkdir, "-X:LightweightScopes", "-X:BasicConsole")
    564. 

  564.     else:
    565. 

  565.         ipi = IronPythonInstance(executable, wkdir, "-X:BasicConsole")
    566. 

  566. 

  567.     if (ipi.Start()):
    568. 

  568.         result = ipi.ExecuteLine("from iptest.assert_util import *")
    569. 

  569.         result = ipi.ExecuteLine("load_iron_python_test()")
    570. 

  570.         result = ipi.ExecuteLine("from IronPythonTest import DefaultParams")
    571. 

  571.         response = ipi.ExecuteLine("DefaultParams.FuncWithDefaults(1100, z=82)")
    572. 

  572.         AreEqual(response, '1184')
    573. 

  573.         ipi.End()
    574. 

  574. 

  575. p = ((1, 2),)
    576. 

  576. 

  577. AreEqual(zip(*(p * 10)), [(1, 1, 1, 1, 1, 1, 1, 1, 1, 1), (2, 2, 2, 2, 2, 2, 2, 2, 2, 2)])
    578. 

  578. AreEqual(zip(*(p * 10)), [(1, 1, 1, 1, 1, 1, 1, 1, 1, 1), (2, 2, 2, 2, 2, 2, 2, 2, 2, 2)])
    579. 

  579. 

  580. 

  581. 

  582. 

  583. class A(object): pass
    584. 

  584. 

  585. class B(A): pass
    586. 

  586. 

  587. #unbound super
    588. 

  588. for x in [super(B), super(B,None)]:
    589. 

  589.     AreEqual(x.__thisclass__, B)
    590. 

  590.     AreEqual(x.__self__, None)
    591. 

  591.     AreEqual(x.__self_class__, None)
    592. 

  592. 

  593. # super w/ both types
    594. 

  594. x = super(B,B)
    595. 

  595. 

  596. AreEqual(x.__thisclass__,B)
    597. 

  597. AreEqual(x.__self_class__, B)
    598. 

  598. AreEqual(x.__self__, B)
    599. 

  599. 

  600. # super w/ type and instance
    601. 

  601. b = B()
    602. 

  602. x = super(B, b)
    603. 

  603. 

  604. AreEqual(x.__thisclass__,B)
    605. 

  605. AreEqual(x.__self_class__, B)
    606. 

  606. AreEqual(x.__self__, b)
    607. 

  607. 

  608. # super w/ mixed types
    609. 

  609. x = super(A,B)
    610. 

  610. AreEqual(x.__thisclass__,A)
    611. 

  611. AreEqual(x.__self_class__, B)
    612. 

  612. AreEqual(x.__self__, B)
    613. 

  613. 

  614. # invalid super cases
    615. 

  615. try:
    616. 

  616.     x = super(B, 'abc')
    617. 

  617.     AssertUnreachable()
    618. 

  618. except TypeError:
    619. 

  619.     pass
    620. 

  620.     
    621. 

  621. try:
    622. 

  622.     super(B,A)
    623. 

  623.     AssertUnreachable()
    624. 

  624. except TypeError:
    625. 

  625.     pass
    626. 

  626.     
    627. 

  627. 

  628. class A(object):
    629. 

  629.     def __init__(self, name):
    630. 

  630.         self.__name__ = name
    631. 

  631.     def meth(self):
    632. 

  632.         return self.__name__
    633. 

  633.     classmeth = classmethod(meth)
    634. 

  634.     
    635. 

  635. class B(A): pass
    636. 

  636. 

  637. b = B('derived')
    638. 

  638. AreEqual(super(B,b).__thisclass__.__name__, 'B')
    639. 

  639. AreEqual(super(B,b).__self__.__name__, 'derived')
    640. 

  640. AreEqual(super(B,b).__self_class__.__name__, 'B')
    641. 

  641. 

  642. AreEqual(super(B,b).classmeth(), 'B')
    643. 

  643. 

  644. 

  645. # descriptor supper
    646. 

  646. class A(object):
    647. 

  647.     def meth(self): return 'A'
    648. 

  648.     
    649. 

  649. class B(A):
    650. 

  650.     def meth(self):    
    651. 

  651.         return 'B' + self.__super.meth()
    652. 

  652.         
    653. 

  653. B._B__super = super(B)
    654. 

  654. b = B()
    655. 

  655. AreEqual(b.meth(), 'BA')
    656. 

  656. 

  657. 

  658. #################################
    659. 

  659. # class method calls - class method should get
    660. 

  660. # correct meta class.
    661. 

  661. 

  662. class D(object):
    663. 

  663. 	@classmethod
    664. 

  664. 	def classmeth(cls): pass
    665. 

  665. 	
    666. 

  666. AreEqual(D.classmeth.im_class, type)
    667. 

  667. 

  668. class MetaType(type): pass
    669. 

  669. 

  670. class D(object):
    671. 

  671. 	__metaclass__ = MetaType
    672. 

  672. 	@classmethod
    673. 

  673. 	def classmeth(cls): pass
    674. 

  674. 	
    675. 

  675. AreEqual(D.classmeth.im_class, MetaType)
    676. 

  676. 

  677. #####################################################################################
    678. 

  678. 

  679. from iptest.assert_util import *
    680. 

  680. if is_cli or is_silverlight:
    681. 

  681.     from _collections import *
    682. 

  682. else:
    683. 

  683.     from collections import *
    684. 

  684. 

  685. global init
    686. 

  686. 

  687. def Assert(val):
    688. 

  688.     if val == False:
    689. 

  689.         raise TypeError, "assertion failed"
    690. 

  690. 

  691. def runTest(testCase):
    692. 

  692.     global typeMatch
    693. 

  693.     global init
    694. 

  694. 

  695.     class foo(testCase.subtype):
    696. 

  696.         def __new__(cls, param):
    697. 

  697.             ret = testCase.subtype.__new__(cls, param)
    698. 

  698.             Assert(ret == testCase.newEq)
    699. 

  699.             Assert((ret != testCase.newEq) != True)
    700. 

  700.             return ret
    701. 

  701.         def __init__(self, param):
    702. 

  702.             testCase.subtype.__init__(self, param)
    703. 

  703.             Assert(self == testCase.initEq)
    704. 

  704.             Assert((self != testCase.initEq) != True)
    705. 

  705. 

  706.     a = foo(testCase.param)
    707. 

  707.     Assert((type(a) == foo) == testCase.match)
    708. 

  708. 

  709. class TestCase(object):
    710. 

  710.     __slots__ = ['subtype', 'newEq', 'initEq', 'match', 'param']
    711. 

  711.     def __init__(self, subtype, newEq, initEq, match, param):
    712. 

  712.         self.match = match
    713. 

  713.         self.subtype = subtype
    714. 

  714.         self.newEq = newEq
    715. 

  715.         self.initEq = initEq
    716. 

  716.         self.param = param
    717. 

  717. 

  718. 

  719. cases = [TestCase(int, 2, 2, True, 2),
    720. 

  720.          TestCase(list, [], [2,3,4], True, (2,3,4)),
    721. 

  721.          TestCase(deque, deque(), deque((2,3,4)), True, (2,3,4)),
    722. 

  722.          TestCase(set, set(), set((2,3,4)), True, (2,3,4)),
    723. 

  723.          TestCase(frozenset, frozenset((2,3,4)), frozenset((2,3,4)), True, (2,3,4)),
    724. 

  724.          TestCase(tuple, (2,3,4), (2,3,4), True, (2,3,4)),
    725. 

  725.          TestCase(str, 'abc', 'abc', True, 'abc'),
    726. 

  726.          TestCase(float, 2.3, 2.3, True, 2.3),
    727. 

  727.          TestCase(type, type(object), type(object), False, object),
    728. 

  728.          TestCase(long, 10000000000L, 10000000000L, True, 10000000000L),
    729. 

  729.          #TestCase(complex, complex(2.0, 0), complex(2.0, 0), True, 2.0),        # complex is currently a struct w/ no extensibel, we fail here
    730. 

  730.         # TestCase(file, 'abc', True),      # ???
    731. 

  731.         ]
    732. 

  732. 

  733. 

  734. for case in cases:
    735. 

  735.     runTest(case)
    736. 

  736. 

  737. # verify we can call the base init directly
    738. 

  738. 

  739. if is_cli and not is_netstandard and not is_posix: # no System.Windows.Forms in netstandard
    740. 

  740.     import clr
    741. 

  741.     clr.AddReferenceByPartialName('System.Windows.Forms')
    742. 

  742.     from System.Windows.Forms import *
    743. 

  743. 

  744.     class MyForm(Form):
    745. 

  745.         def __init__(self, title):
    746. 

  746.             Form.__init__(self)
    747. 

  747.             self.Text = title
    748. 

  748. 

  749.     a = MyForm('abc')
    750. 

  750.     AreEqual(a.Text, 'abc')
    751. 

  751. 

  752. #TestCase(bool, True, True),                    # not an acceptable base type
    753. 

  753. 

  754. def test_func_flags():
    755. 

  755.     def foo0(): pass
    756. 

  756.     def foo1(*args): pass
    757. 

  757.     def foo2(**args): pass
    758. 

  758.     def foo3(*args, **kwargs): pass
    759. 

  759.     def foo4(a): pass
    760. 

  760.     def foo5(a, *args): pass
    761. 

  761.     def foo6(a, **args): pass
    762. 

  762.     def foo7(a, *args, **kwargs): pass
    763. 

  763.     def foo8(a,b,c,d,e,f): pass
    764. 

  764.     def foo9(a,b): pass
    765. 

  765.     
    766. 

  766.     AreEqual(foo0.func_code.co_flags & 12, 0)
    767. 

  767.     AreEqual(foo1.func_code.co_flags & 12, 4)
    768. 

  768.     AreEqual(foo2.func_code.co_flags & 12, 8)
    769. 

  769.     AreEqual(foo3.func_code.co_flags & 12, 12)
    770. 

  770.     AreEqual(foo4.func_code.co_flags & 12, 0)
    771. 

  771.     AreEqual(foo5.func_code.co_flags & 12, 4)
    772. 

  772.     AreEqual(foo6.func_code.co_flags & 12, 8)
    773. 

  773.     AreEqual(foo7.func_code.co_flags & 12, 12)
    774. 

  774.     AreEqual(foo8.func_code.co_flags & 12, 0)
    775. 

  775.     AreEqual(foo9.func_code.co_flags & 12, 0)
    776. 

  776.     
    777. 

  777.     AreEqual(foo0.func_code.co_argcount, 0)
    778. 

  778.     AreEqual(foo1.func_code.co_argcount, 0)
    779. 

  779.     AreEqual(foo2.func_code.co_argcount, 0)
    780. 

  780.     AreEqual(foo3.func_code.co_argcount, 0)
    781. 

  781.     AreEqual(foo4.func_code.co_argcount, 1)
    782. 

  782.     AreEqual(foo5.func_code.co_argcount, 1)
    783. 

  783.     AreEqual(foo6.func_code.co_argcount, 1)
    784. 

  784.     AreEqual(foo7.func_code.co_argcount, 1)
    785. 

  785.     AreEqual(foo8.func_code.co_argcount, 6)
    786. 

  786.     AreEqual(foo9.func_code.co_argcount, 2)
    787. 

  787. 

  788. def test_big_calls():
    789. 

  789.     # check various function call sizes and boundaries
    790. 

  790.     sizes = [3, 4, 5, 7, 8, 9, 13, 15, 16, 17, 23, 24, 25, 31, 32, 33, 47, 48, 49, 63, 64, 65, 127, 128, 129, 254, 255, 256, 257, 258, 511, 512, 513]
    791. 

  791. 

  792. 

  793.     # mono has a limitation of < 1023
    794. 

  794.     if not is_mono:
    795. 

  795.         sizes.extend([1023, 1024, 1025, 2047, 2048, 2049])
    796. 

  796. 

  797.     for size in sizes:
    798. 

  798.         # w/o defaults
    799. 

  799.         exec 'def f(' + ','.join(['a' + str(i) for i in range(size)]) + '): return ' + ','.join(['a' + str(i) for i in range(size)])
    800. 

  800.         # w/ defaults
    801. 

  801.         exec 'def g(' + ','.join(['a' + str(i) + '=' + str(i) for i in range(size)]) + '): return ' + ','.join(['a' + str(i) for i in range(size)])
    802. 

  802.         if (size <= 255 or is_cli) and not is_netstandard or size <= 13: # PlatformNotSupportedException when > 13
    803. 

  803.             # CPython allows function definitions > 255, but not calls w/ > 255 params.
    804. 

  804.             exec 'a = f(' + ', '.join([str(x) for x in xrange(size)]) + ')'
    805. 

  805.             AreEqual(a, tuple(xrange(size)))
    806. 

  806.             exec 'a = g()'
    807. 

  807.             AreEqual(a, tuple(xrange(size)))
    808. 

  808.             exec 'a = g(' + ', '.join([str(x) for x in xrange(size)]) + ')'
    809. 

  809.             AreEqual(a, tuple(xrange(size)))
    810. 

  810.         
    811. 

  811.         exec 'a = f(*(' + ', '.join([str(x) for x in xrange(size)]) + '))'
    812. 

  812.         AreEqual(a, tuple(xrange(size)))
    813. 

  813.     
    814. 

  814. def test_compile():
    815. 

  815.     x = compile("print 2/3", "<string>", "exec", 8192)
    816. 

  816.     Assert((x.co_flags & 8192) == 8192)
    817. 

  817.     
    818. 

  818.     x = compile("2/3", "<string>", "eval", 8192)
    819. 

  819.     AreEqual(eval(x), 2.0 / 3.0)
    820. 

  820. 

  821.     names = [   "", ".", "1", "\n", " ", "@", "%^",
    822. 

  822.                 "a", "A", "Abc", "aBC", "filename.py",
    823. 

  823.                 "longlonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglong",
    824. 

  824.                 """
    825. 

  825.                 stuff
    826. 

  826.                 more stuff
    827. 

  827.                 last stuff
    828. 

  828.                 """
    829. 

  829.                 ]
    830. 

  830.     for name in names:
    831. 

  831.         AreEqual(compile("print 2/3", name, "exec", 8192).co_filename,
    832. 

  832.                  name)
    833. 

  833. 

  834. def test_filename():
    835. 

  835.     c = compile("x = 2", "test", "exec")
    836. 

  836.     AreEqual(c.co_filename, 'test')
    837. 

  837.     
    838. 

  838. def test_name():
    839. 

  839.     def f(): pass
    840. 

  840.     
    841. 

  841.     f.__name__ = 'g'
    842. 

  842.     AreEqual(f.__name__, 'g')
    843. 

  843.     Assert(repr(f).startswith('<function g'))
    844. 

  844.     
    845. 

  845.     f.func_name = 'x'
    846. 

  846.     AreEqual(f.__name__, 'x')
    847. 

  847.     Assert(repr(f).startswith('<function x'))
    848. 

  848. 

  849. def test_argcount():
    850. 

  850.     def foo0(): pass
    851. 

  851.     def foo1(*args): pass
    852. 

  852.     def foo2(**args): pass
    853. 

  853.     def foo3(*args, **kwargs): pass
    854. 

  854.     def foo4(a): pass
    855. 

  855.     def foo5(a, *args): pass
    856. 

  856.     def foo6(a, **args): pass
    857. 

  857.     def foo7(a, *args, **kwargs): pass
    858. 

  858.     def foo8(a,b,c,d,e,f): pass
    859. 

  859.     def foo9(a,b): pass
    860. 

  860.     
    861. 

  861.     AreEqual(foo0.func_code.co_argcount, 0)
    862. 

  862.     AreEqual(foo1.func_code.co_argcount, 0)
    863. 

  863.     AreEqual(foo2.func_code.co_argcount, 0)
    864. 

  864.     AreEqual(foo3.func_code.co_argcount, 0)
    865. 

  865.     AreEqual(foo4.func_code.co_argcount, 1)
    866. 

  866.     AreEqual(foo5.func_code.co_argcount, 1)
    867. 

  867.     AreEqual(foo6.func_code.co_argcount, 1)
    868. 

  868.     AreEqual(foo7.func_code.co_argcount, 1)
    869. 

  869.     AreEqual(foo8.func_code.co_argcount, 6)
    870. 

  870.     AreEqual(foo9.func_code.co_argcount, 2)
    871. 

  871. 

  872. def test_defaults():
    873. 

  873.     defaults = [None, object, int, [], 3.14, [3.14], (None,), "a string"]
    874. 

  874.     for default in defaults:
    875. 

  875.         def helperFunc(): pass
    876. 

  876.         AreEqual(helperFunc.func_defaults, None)
    877. 

  877.         AreEqual(helperFunc.func_defaults, None)
    878. 

  878.     
    879. 

  879.         def helperFunc1(a): pass
    880. 

  880.         AreEqual(helperFunc1.func_defaults, None)
    881. 

  881.         AreEqual(helperFunc1.func_defaults, None)
    882. 

  882.         
    883. 

  883.         
    884. 

  884.         def helperFunc2(a=default): pass
    885. 

  885.         AreEqual(helperFunc2.func_defaults, (default,))
    886. 

  886.         helperFunc2(a=7)
    887. 

  887.         AreEqual(helperFunc2.func_defaults, (default,))
    888. 

  888.         
    889. 

  889.         
    890. 

  890.         def helperFunc3(a, b=default, c=[42]): c.append(b)
    891. 

  891.         AreEqual(helperFunc3.func_defaults, (default, [42]))
    892. 

  892.         helperFunc3("stuff")
    893. 

  893.         AreEqual(helperFunc3.func_defaults, (default, [42, default]))
    894. 

  894. 

  895. def test_splat_defaults():
    896. 

  896.     def g(a, b, x=None):
    897. 

  897.         return a, b, x
    898. 

  898.         
    899. 

  899.     def f(x, *args):        
    900. 

  900.         return g(x, *args)
    901. 

  901.         
    902. 

  902.     AreEqual(f(1, *(2,)), (1,2,None))
    903. 

  903. 

  904. def test_argument_eval_order():
    905. 

  905.     """Check order of evaluation of function arguments"""
    906. 

  906.     x = [1]
    907. 

  907.     def noop(a, b, c):
    908. 

  908.         pass
    909. 

  909.     noop(x.append(2), x.append(3), x.append(4))
    910. 

  910.     AreEqual(x, [1,2,3,4])
    911. 

  911. 

  912. def test_method_attr_access():
    913. 

  913.     class foo(object):
    914. 

  914.         def f(self): pass
    915. 

  915.         abc = 3
    916. 

  916.     
    917. 

  917.     method = type(foo.f)    
    918. 

  918.     
    919. 

  919.     AreEqual(method(foo, 'abc').abc, 3)
    920. 

  920. 

  921. @skip("interpreted")  # we don't have FuncEnv's in interpret modes so this always returns None
    922. 

  922. def test_function_closure_negative():
    923. 

  923.     def f(): pass
    924. 

  924.     
    925. 

  925.     for assignment_val in [None, 1, "a string"]:
    926. 

  926.         try:
    927. 

  927.             f.func_closure = assignment_val
    928. 

  928.             AssertUnreachable("func_closure is a read-only attribute of functions")
    929. 

  929.         except TypeError, e:
    930. 

  930.             pass
    931. 

  931. 

  932. def test_paramless_function_call_error():
    933. 

  933.     def f(): pass
    934. 

  934.     
    935. 

  935.     try:
    936. 

  936.         f(*(1, ))
    937. 

  937.         AssertUnreachable()
    938. 

  938.     except TypeError: pass
    939. 

  939.         
    940. 

  940.     try:
    941. 

  941.         f(**{'abc':'def'})
    942. 

  942.         AssertUnreachable()
    943. 

  943.     except TypeError: pass
    944. 

  944. 

  945. 

  946. def test_function_closure():
    947. 

  947.     def f(): pass
    948. 

  948.     
    949. 

  949.     AreEqual(f.func_closure, None)
    950. 

  950.     
    951. 

  951.     def f():    
    952. 

  952.         def g(): pass
    953. 

  953.         return g
    954. 

  954.         
    955. 

  955.     AreEqual(f().func_closure, None)
    956. 

  956. 

  957.     def f():
    958. 

  958.         x = 4
    959. 

  959.         def g(): return x
    960. 

  960.         return g
    961. 

  961.         
    962. 

  962.     AreEqual(sorted([x.cell_contents for x in f().func_closure]), [4])
    963. 

  963.     
    964. 

  964.     def f():
    965. 

  965.         x = 4
    966. 

  966.         def g():
    967. 

  967.             y = 5
    968. 

  968.             def h(): return x,y
    969. 

  969.             return h
    970. 

  970.         return g()
    971. 

  971. 

  972.     AreEqual(sorted([x.cell_contents for x in f().func_closure]), [4, 5])
    973. 

  973. 

  974.     # don't use z
    975. 

  975.     def f():
    976. 

  976.         x = 4
    977. 

  977.         def g():
    978. 

  978.             y = 5
    979. 

  979.             z = 7
    980. 

  980.             def h(): return x,y
    981. 

  981.             return h
    982. 

  982.         return g()
    983. 

  983.     
    984. 

  984.     AreEqual(sorted([x.cell_contents for x in f().func_closure]), [4, 5])
    985. 

  985.     
    986. 

  986.     def f():
    987. 

  987.         x = 4
    988. 

  988.         def g():
    989. 

  989.             y = 5
    990. 

  990.             z = 7
    991. 

  991.             def h(): return x,y,z
    992. 

  992.             return h
    993. 

  993.         return g()
    994. 

  994. 

  995.     AreEqual(sorted([x.cell_contents for x in f().func_closure]), [4, 5, 7])
    996. 

  996. 

  997.     def f():
    998. 

  998.         x = 4
    999. 

  999.         a = 9
    1000. 

  1000.         def g():
    1001. 

  1001.             y = 5
    1002. 

  1002.             z = 7
    1003. 

  1003.             def h(): return x,y
    1004. 

  1004.             return h
    1005. 

  1005.         return g()
    1006. 

  1006. 

  1007.     AreEqual(sorted([x.cell_contents for x in f().func_closure]), [4, 5])
    1008. 

  1008.     
    1009. 

  1009.     # closure cells are not recreated
    1010. 

  1010.     callRes = f()
    1011. 

  1011.     a = sorted([id(x) for x in callRes.func_closure])
    1012. 

  1012.     b = sorted([id(x) for x in callRes.func_closure])
    1013. 

  1013.     AreEqual(a, b)
    1014. 

  1014. 

  1015.     def f():
    1016. 

  1016.         x = 4
    1017. 

  1017.         a = 9
    1018. 

  1018.         def g():
    1019. 

  1019.             y = 5
    1020. 

  1020.             z = 7
    1021. 

  1021.             def h(): return x,y,a,z
    1022. 

  1022.             return h
    1023. 

  1023.         return g()
    1024. 

  1024. 

  1025.     AreEqual(sorted([x.cell_contents for x in f().func_closure]), [4, 5, 7, 9])
    1026. 

  1026. 

  1027.     AssertError(TypeError, hash, f().func_closure[0])
    1028. 

  1028.     
    1029. 

  1029.     def f():
    1030. 

  1030.         x = 5
    1031. 

  1031.         def g():
    1032. 

  1032.             return x
    1033. 

  1033.         return g
    1034. 

  1034.         
    1035. 

  1035.     def h():
    1036. 

  1036.         x = 5
    1037. 

  1037.         def g():
    1038. 

  1038.             return x
    1039. 

  1039.         return g
    1040. 

  1040. 

  1041.     def j():
    1042. 

  1042.         x = 6
    1043. 

  1043.         def g():
    1044. 

  1044.             return x
    1045. 

  1045.         return g
    1046. 

  1046. 

  1047.     AreEqual(f().func_closure[0], h().func_closure[0])
    1048. 

  1048.     Assert(f().func_closure[0] != j().func_closure[0])
    1049. 

  1049. 

  1050.     # <cell at 45: int object at 44>
    1051. 

  1051.     Assert(repr(f().func_closure[0]).startswith('<cell at '))
    1052. 

  1052.     Assert(repr(f().func_closure[0]).find(': int object at ') != -1)
    1053. 

  1053.     
    1054. 

  1054.     
    1055. 

  1055. def test_func_code():
    1056. 

  1056.     def foo(): pass
    1057. 

  1057.     def assign(): foo.func_code = None
    1058. 

  1058.     AssertError(TypeError, assign)
    1059. 

  1059.     
    1060. 

  1060. def def_func_doc():
    1061. 

  1061.     foo.func_doc = 'abc'
    1062. 

  1062.     AreEqual(foo.__doc__, 'abc')
    1063. 

  1063.     foo.__doc__ = 'def'
    1064. 

  1064.     AreEqual(foo.func_doc, 'def')
    1065. 

  1065.     foo.func_doc = None
    1066. 

  1066.     AreEqual(foo.__doc__, None)
    1067. 

  1067.     AreEqual(foo.func_doc, None)
    1068. 

  1068. 

  1069. def test_func_defaults():
    1070. 

  1070.     def f(a, b): return (a, b)
    1071. 

  1071. 

  1072.     f.func_defaults = (1,2)
    1073. 

  1073.     AreEqual(f(), (1,2))
    1074. 

  1074.     
    1075. 

  1075.     f.func_defaults = (1,2,3,4)
    1076. 

  1076.     AreEqual(f(), (3,4))
    1077. 

  1077. 

  1078.     f.func_defaults = None
    1079. 

  1079.     AssertError(TypeError, f)
    1080. 

  1080. 

  1081.     f.func_defaults = (1,2)
    1082. 

  1082.     AreEqual(f.func_defaults, (1,2))
    1083. 

  1083.     
    1084. 

  1084.     del f.func_defaults
    1085. 

  1085.     AreEqual(f.func_defaults, None)
    1086. 

  1086.     del f.func_defaults
    1087. 

  1087.     AreEqual(f.func_defaults, None)
    1088. 

  1088.     
    1089. 

  1089.     def func_with_many_args(one, two, three, four, five, six, seven, eight, nine, ten, eleven=None, twelve=None, thirteen=None, fourteen=None, fifteen=None, sixteen=None, seventeen=None, eighteen=None, nineteen=None):
    1090. 

  1090.         print 'hello'
    1091. 

  1091.         
    1092. 

  1092.     func_with_many_args(None, None, None, None, None, None, None, None, None, None)
    1093. 

  1093. 

  1094. 

  1095. def test_func_dict():
    1096. 

  1096.     def f(): pass
    1097. 

  1097.     
    1098. 

  1098.     f.abc = 123
    1099. 

  1099.     AreEqual(f.func_dict, {'abc': 123})
    1100. 

  1100.     f.func_dict = {'def': 'def'}
    1101. 

  1101.     AreEqual(hasattr(f, 'def'), True)
    1102. 

  1102.     AreEqual(getattr(f, 'def'), 'def')
    1103. 

  1103.     f.func_dict = {}
    1104. 

  1104.     AreEqual(hasattr(f, 'abc'), False)
    1105. 

  1105.     AreEqual(hasattr(f, 'def'), False)
    1106. 

  1106.         
    1107. 

  1107.     AssertError(TypeError, lambda : delattr(f, 'func_dict'))
    1108. 

  1108.     AssertError(TypeError, lambda : delattr(f, '__dict__'))
    1109. 

  1109.     
    1110. 

  1110. def test_method():
    1111. 

  1111.     class C:
    1112. 

  1112.         def method(self): pass
    1113. 

  1113.     
    1114. 

  1114.     method = type(C.method)(id, None, 'abc')
    1115. 

  1115.     AreEqual(method.im_class, 'abc')
    1116. 

  1116.     
    1117. 

  1117.     class myobj:
    1118. 

  1118.         def __init__(self, val):            
    1119. 

  1119.             self.val = val
    1120. 

  1120.             self.called = []
    1121. 

  1121.         def __hash__(self):
    1122. 

  1122.             self.called.append('hash')
    1123. 

  1123.             return hash(self.val)        
    1124. 

  1124.         def __eq__(self, other): 
    1125. 

  1125.             self.called.append('eq')
    1126. 

  1126.             return self.val == other.val
    1127. 

  1127.         def __call__(*args): pass
    1128. 

  1128.     
    1129. 

  1129.     func1, func2 = myobj(2), myobj(2)
    1130. 

  1130.     inst1, inst2 = myobj(3), myobj(3)
    1131. 

  1131.     
    1132. 

  1132.     method = type(C().method)
    1133. 

  1133.     m1 = method(func1, inst1)
    1134. 

  1134.     m2 = method(func2, inst2)
    1135. 

  1135.     AreEqual(m1, m2)
    1136. 

  1136.     
    1137. 

  1137.     Assert('eq' in func1.called)
    1138. 

  1138.     Assert('eq' in inst1.called)
    1139. 

  1139. 

  1140.     hash(m1)   
    1141. 

  1141.     Assert('hash' in func1.called)
    1142. 

  1142.     Assert('hash' in inst1.called)
    1143. 

  1143.     
    1144. 

  1144. def test_function_type():
    1145. 

  1145.     def f1(): pass
    1146. 

  1146.     def f2(a): pass
    1147. 

  1147.     def f3(a, b, c): pass
    1148. 

  1148.     def f4(*a, **b): pass
    1149. 

  1149.     
    1150. 

  1150.     def decorator(f): return f
    1151. 

  1151.     @decorator
    1152. 

  1152.     def f5(a): pass
    1153. 

  1153.     
    1154. 

  1154.     for x in [ f2, f3, f4, f5]:
    1155. 

  1155.         AreEqual(type(f1), type(x))
    1156. 

  1156. 

  1157. def test_name_mangled_params():
    1158. 

  1158.     def f1(__a): pass
    1159. 

  1159.     def f2(__a): return __a
    1160. 

  1160.     def f3(a, __a): return __a
    1161. 

  1161.     def f4(_a, __a): return _a + __a
    1162. 

  1162.     
    1163. 

  1163.     f1("12")
    1164. 

  1164.     AreEqual(f2("hello"), "hello")
    1165. 

  1165.     AreEqual(f3("a","b"), "b")
    1166. 

  1166.     AreEqual(f4("a","b"), "ab")
    1167. 

  1167. 

  1168. def test_splat_none():
    1169. 

  1169.     def f(*args): pass
    1170. 

  1170.     def g(**kwargs): pass
    1171. 

  1171.     def h(*args, **kwargs): pass
    1172. 

  1172.     
    1173. 

  1173.     #CodePlex 20250
    1174. 

  1174.     AssertErrorWithMessage(TypeError, "f() argument after * must be a sequence, not NoneType", 
    1175. 

  1175.                            lambda : f(*None))
    1176. 

  1176.     AssertErrorWithMessage(TypeError, "g() argument after ** must be a mapping, not NoneType", 
    1177. 

  1177.                            lambda : g(**None))
    1178. 

  1178.     AssertErrorWithMessage(TypeError, "h() argument after ** must be a mapping, not NoneType",
    1179. 

  1179.                            lambda : h(*None, **None))
    1180. 

  1180. 

  1181. def test_exec_funccode():
    1182. 

  1182.     # can't exec a func code w/ parameters
    1183. 

  1183.     def f(a, b, c): print a, b, c
    1184. 

  1184.     
    1185. 

  1185.     AssertError(TypeError, lambda : eval(f.func_code))
    1186. 

  1186.     
    1187. 

  1187.     # can exec *args/**args
    1188. 

  1188.     def f(*args): pass
    1189. 

  1189.     exec f.func_code in {}, {}
    1190. 

  1190.     
    1191. 

  1191.     def f(*args, **kwargs): pass
    1192. 

  1192.     exec f.func_code in {}, {}
    1193. 

    1194. 

  1194.     # can't exec function which closes over vars
    1195. 

  1195.     def f():
    1196. 

  1196.         x = 2
    1197. 

  1197.         def g():
    1198. 

  1198.                 print x
    1199. 

  1199.         return g.func_code
    1200. 

  1200.     
    1201. 

  1201.     AssertError(TypeError, lambda : eval(f()))
    1202. 

  1202.     
    1203. 

  1203. def test_exec_funccode_filename():
    1204. 

  1204.     import sys
    1205. 

  1205.     mod = type(sys)('fake_mod_name')
    1206. 

  1206.     mod.__file__ = 'some file'
    1207. 

  1207.     exec "def x(): pass" in mod.__dict__
    1208. 

  1208.     AreEqual(mod.x.func_code.co_filename, '<string>')
    1209. 

    1210. 

    1211. 

  1211. # defined globally because unqualified exec isn't allowed in
    1212. 

  1212. # a nested function.
    1213. 

  1213. def unqualified_exec():
    1214. 

  1214.     print x
    1215. 

  1215.     exec ""
    1216. 

    1217. 

  1217. def test_func_code_variables():
    1218. 

  1218.     def CompareCodeVars(code, varnames, names, freevars, cellvars):
    1219. 

  1219.         AreEqual(code.co_varnames, varnames)
    1220. 

  1220.         AreEqual(code.co_names, names)
    1221. 

  1221.         AreEqual(code.co_freevars, freevars)
    1222. 

  1222.         AreEqual(code.co_cellvars, cellvars)
    1223. 

  1223.     
    1224. 

  1224.     # simple local
    1225. 

  1225.     def f():
    1226. 

  1226.         a = 2
    1227. 

  1227.     
    1228. 

  1228.     CompareCodeVars(f.func_code, ('a', ), (), (), ())    
    1229. 

  1229.     
    1230. 

  1230.     # closed over var
    1231. 

  1231.     def f():
    1232. 

  1232.         a = 2
    1233. 

  1233.         def g():
    1234. 

  1234.             print a
    1235. 

  1235.         return g
    1236. 

  1236.         
    1237. 

  1237.     CompareCodeVars(f.func_code, ('g', ), (), (), ('a', ))
    1238. 

  1238.     CompareCodeVars(f().func_code, (), (), ('a', ), ())
    1239. 

    1240. 

  1240.     # tuple parameters
    1241. 

  1241.     def f((a, b)): pass
    1242. 

  1242.     
    1243. 

  1243.     CompareCodeVars(f.func_code, ('.0', 'a', 'b'), (), (), ())
    1244. 

  1244.     
    1245. 

  1245.     def f((a, b), (c, d)): pass
    1246. 

  1246.     
    1247. 

  1247.     CompareCodeVars(f.func_code, ('.0', '.1', 'a', 'b', 'c', 'd'), (), (), ())
    1248. 

  1248.     
    1249. 

  1249.     # explicitly marked global
    1250. 

  1250.     def f():
    1251. 

  1251.         global a
    1252. 

  1252.         a = 2
    1253. 

  1253.         
    1254. 

  1254.     CompareCodeVars(f.func_code, (), ('a', ), (), ())
    1255. 

  1255.     
    1256. 

  1256.     # implicit global
    1257. 

  1257.     def f():
    1258. 

  1258.         print some_global
    1259. 

  1259.         
    1260. 

  1260.     CompareCodeVars(f.func_code, (), ('some_global', ), (), ())
    1261. 

    1262. 

  1262.     # global that's been "closed over"
    1263. 

  1263.     def f():
    1264. 

  1264.         global a
    1265. 

  1265.         a = 2
    1266. 

  1266.         def g():
    1267. 

  1267.             print a
    1268. 

  1268.         return g
    1269. 

  1269.         
    1270. 

  1270.     CompareCodeVars(f.func_code, ('g', ), ('a', ), (), ())
    1271. 

  1271.     CompareCodeVars(f().func_code, (), ('a', ), (), ())
    1272. 

    1273. 

  1273.     # multi-depth closure
    1274. 

  1274.     def f():
    1275. 

  1275.         a = 2
    1276. 

  1276.         def g():
    1277. 

  1277.             x = a
    1278. 

  1278.             def h():
    1279. 

  1279.                 y = a
    1280. 

  1280.             return h
    1281. 

  1281.         return g
    1282. 

  1282.                 
    1283. 

  1283.     CompareCodeVars(f.func_code, ('g', ), (), (), ('a', ))
    1284. 

  1284.     CompareCodeVars(f().func_code, ('x', 'h'), (), ('a', ), ())
    1285. 

  1285.     CompareCodeVars(f()().func_code, ('y', ), (), ('a', ), ())
    1286. 

    1287. 

  1287.     # multi-depth closure 2
    1288. 

  1288.     def f():
    1289. 

  1289.         a = 2
    1290. 

  1290.         def g():
    1291. 

  1291.             def h():
    1292. 

  1292.                 y = a
    1293. 

  1293.             return h
    1294. 

  1294.         return g
    1295. 

  1295.                 
    1296. 

  1296.     CompareCodeVars(f.func_code, ('g', ), (), (), ('a', ))
    1297. 

  1297.     CompareCodeVars(f().func_code, ('h', ), (), ('a', ), ())
    1298. 

  1298.     CompareCodeVars(f()().func_code, ('y', ), (), ('a', ), ())
    1299. 

  1299.     
    1300. 

  1300.     # closed over parameter
    1301. 

  1301.     def f(a):
    1302. 

  1302.         def g():
    1303. 

  1303.             return a
    1304. 

  1304.         return g
    1305. 

  1305.     
    1306. 

  1306.     CompareCodeVars(f.func_code, ('a', 'g'), (), (), ('a', ))    
    1307. 

  1307.     CompareCodeVars(f(42).func_code, (), (), ('a', ), ())
    1308. 

  1308.         
    1309. 

  1309.     AreEqual(unqualified_exec.func_code.co_names, ('x', ))
    1310. 

    1311. 

  1311. def test_delattr():
    1312. 

  1312.     def f(): pass
    1313. 

  1313.     f.abc = 42
    1314. 

  1314.     del f.abc
    1315. 

  1315.     def g(): f.abc
    1316. 

  1316.     AssertError(AttributeError, g)
    1317. 

    1318. 

    1319. 

  1319. def copyfunc(f, name):
    1320. 

  1320.     return FunctionType(f.func_code, f.func_globals, name, f.func_defaults, f.func_closure)
    1321. 

    1322. 

  1322. def test_cp35180():
    1323. 

  1323.     def foo():
    1324. 

  1324.         return 13
    1325. 

  1325.     def bar():
    1326. 

  1326.         return 42
    1327. 

  1327.     dpf = copyfunc(foo, "dpf")
    1328. 

  1328.     AreEqual(dpf(), 13)
    1329. 

  1329.     foo.func_code = bar.func_code
    1330. 

  1330.     AreEqual(foo(), 42)
    1331. 

  1331.     AreEqual(dpf(), 13)
    1332. 

  1332.     AreEqual(foo.__module__, '__main__')
    1333. 

  1333.     AreEqual(dpf.__module__, '__main__')
    1334. 

    1335. 

    1336. 

  1336. def substitute_globals(f, name, globals):
    1337. 

  1337.     return FunctionType(f.func_code, globals, name, f.func_defaults, f.func_closure)
    1338. 

    1339. 

  1339. global_variable = 13
    1340. 

    1341. 

  1341. def test_cp34932():
    1342. 

  1342.     def get_global_variable():
    1343. 

  1343.         return global_variable
    1344. 

  1344.     def set_global_variable(v):
    1345. 

  1345.         global global_variable
    1346. 

  1346.         global_variable = v
    1347. 

    1348. 

  1348.     alt_globals = {'global_variable' : 66 }
    1349. 

  1349.     get_global_variable_x = substitute_globals(get_global_variable, "get_global_variable_x", alt_globals)
    1350. 

  1350.     set_global_variable_x = substitute_globals(set_global_variable, "set_global_variable_x", alt_globals)
    1351. 

  1351.     AreEqual(get_global_variable(), 13)
    1352. 

  1352.     AreEqual(get_global_variable_x(), 66)
    1353. 

  1353.     AreEqual(get_global_variable(), 13)
    1354. 

  1354.     set_global_variable_x(7)
    1355. 

  1355.     AreEqual(get_global_variable_x(), 7)
    1356. 

  1356.     AreEqual(get_global_variable(), 13)
    1357. 

    1358. 

  1358.     AreEqual(get_global_variable_x.__module__, None)
    1359. 

  1359.     AreEqual(set_global_variable_x.__module__, None)
    1360. 

    1361. 

  1361.     get_global_variable_y = substitute_globals(get_global_variable, "get_global_variable_x", globals())
    1362. 

  1362.     AreEqual(get_global_variable_y(), 13)
    1363. 

  1363.     AreEqual(get_global_variable_y.__module__, '__main__')
    1364. 

    1365. 

  1365. def test_issue1351():
    1366. 

  1366.     class X(object):
    1367. 

  1367.         def __init__(self, res):
    1368. 

  1368.             self.called = []
    1369. 

  1369.             self.res = res
    1370. 

  1370.         def __eq__(self, other):
    1371. 

  1371.             self.called.append('eq')
    1372. 

  1372.             return self.res
    1373. 

  1373.         def foo(self):
    1374. 

  1374.             pass
    1375. 

    1376. 

  1376.     a = X(True)
    1377. 

  1377.     b = X(False)
    1378. 

    1379. 

  1379.     AreEqual(a.foo, a.foo)
    1380. 

  1380.     AssertDoesNotContain(a.called, 'eq')
    1381. 

  1381.     AreEqual(a.foo, b.foo)
    1382. 

  1382.     AssertContains(a.called, 'eq')
    1383. 

    1384. 

  1384.     AreEqual(b.foo, b.foo)
    1385. 

  1385.     AssertDoesNotContain(b.called, 'eq')
    1386. 

  1386.     AreNotEqual(b.foo, a.foo)
    1387. 

  1387.     AssertContains(b.called, 'eq')
    1388. 

    1389. 

  1389. def create_fn_with_closure():
    1390. 

  1390.     x=13
    1391. 

  1391.     def f():
    1392. 

  1392.         return x
    1393. 

  1393.     return f
    1394. 

    1395. 

  1395. def test_function_type():
    1396. 

  1396.     fn_with_closure = create_fn_with_closure()
    1397. 

  1397.     def fn_no_closure():
    1398. 

  1398.         pass
    1399. 

  1399.     AssertError(NotImplementedError, copyfunc, fn_with_closure, "new_fn_name")
    1400. 

  1400.     AssertError(NotImplementedError, FunctionType, fn_with_closure.func_code,
    1401. 

  1401.             fn_with_closure.func_globals, "name", fn_with_closure.func_defaults)
    1402. 

  1402.     AssertError(NotImplementedError, FunctionType, fn_with_closure.func_code,
    1403. 

  1403.             fn_with_closure.func_globals, "name", fn_with_closure.func_defaults,
    1404. 

  1404.             fn_with_closure.func_closure)
    1405. 

  1405.     AssertError(NotImplementedError, FunctionType, fn_no_closure.func_code,
    1406. 

  1406.             fn_no_closure.func_globals, "name", fn_no_closure.func_defaults,
    1407. 

  1407.             fn_with_closure.func_closure)
    1408. 

  1408.    
    1409. 

  1409. run_test(__name__)
    1410. 

    1411.