PageRenderTime 96ms CodeModel.GetById 20ms RepoModel.GetById 1ms app.codeStats 0ms

/Languages/IronPython/Tests/test_methodbinder1.py

http://github.com/IronLanguages/main
Python | 1154 lines | 1132 code | 5 blank | 17 comment | 3 complexity | f9b9cc9a6aa627abf1cb754aac149f9e MD5 | raw file
Possible License(s): CPL-1.0, BSD-3-Clause, ISC, GPL-2.0, MPL-2.0-no-copyleft-exception

Large files files are truncated, but you can click here to view the full file

    

  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. #
    17. 

  17. # PART 1. how IronPython choose the CLI method, treat parameters WHEN NO OVERLOADS PRESENT
    18. 

  18. #
    19. 

  19. 

  20. from iptest.assert_util import *
    21. 

  21. from iptest.type_util import *
    22. 

  22. skiptest("win32")
    23. 

  23. 

  24. load_iron_python_test()
    25. 

  25. from IronPythonTest.BinderTest import *
    26. 

  26. 

  27. myint1,     myint2      = myint(20),    myint(-20)
    28. 

  28. mylong1,    mylong2     = mylong(3),    mylong(-4)
    29. 

  29. myfloat1,   myfloat2    = myfloat(4.5), myfloat(-4.5)
    30. 

  30. mycomplex1              = mycomplex(3)
    31. 

  31. 

  32. funcs = '''
    33. 

  33. M100   M201   M202   M203   M204   M205   M301   M302   M303   M304
    34. 

  34. M310   M311   M312   M313   M320   M321   M400   M401   M402   M403
    35. 

  35. M404   M410   M411   M450   M451
    36. 

  36. M500   M510   M600   M610   M611   M620   M630
    37. 

  37. M650   M651   M652   M653
    38. 

  38. M680   M700   M701
    39. 

  39. M710   M715
    40. 

  40. '''.split()
    41. 

    42. 

  42. args  = '''
    43. 

  43. NoArg  Int32  Double BigInt Bool   String SByte  Int16  Int64  Single
    44. 

  44. Byte   UInt16 UInt32 UInt64 Char   Decml  Object I      C1     C2
    45. 

  45. S1     A      C6     E1     E2
    46. 

  46. ArrInt32  ArrI   ParamArrInt32  ParamArrI       ParamArrS   Int32ParamArrInt32  IParamArrI
    47. 

  47. IListInt  Array  IEnumerableInt IEnumeratorInt
    48. 

  48. NullableInt RefInt32  OutInt32
    49. 

  49. DefValInt32 Int32DefValInt32
    50. 

  50. '''.split()
    51. 

    52. 

  52. arg2func = dict(zip(args, funcs))
    53. 

  53. func2arg = dict(zip(funcs, args))
    54. 

  54. 

  55. TypeE = TypeError
    56. 

  56. OverF = OverflowError
    57. 

  57. 

  58. def _get_funcs(args): return [arg2func[x] for x in args.split()]
    59. 

  59. def _self_defined_method(name): return len(name) == 4 and name[0] == "M"
    60. 

  60. 

  61. def _my_call(func, arg):
    62. 

  62.     if isinstance(arg, tuple):
    63. 

  63.         l = len(arg)
    64. 

  64.         # by purpose
    65. 

  65.         if l == 0: func()
    66. 

  66.         elif l == 1: func(arg[0])
    67. 

  67.         elif l == 2: func(arg[0], arg[1])
    68. 

  68.         elif l == 3: func(arg[0], arg[1], arg[2])
    69. 

  69.         elif l == 4: func(arg[0], arg[1], arg[2], arg[3])
    70. 

  70.         elif l == 5: func(arg[0], arg[1], arg[2], arg[3], arg[4])
    71. 

  71.         elif l == 6: func(arg[0], arg[1], arg[2], arg[3], arg[4], arg[5])
    72. 

  72.         else: func(*arg)
    73. 

  73.     else:
    74. 

  74.         func(arg)
    75. 

  75.     
    76. 

  76. def _helper(func, positiveArgs, flagValue, negativeArgs, exceptType):
    77. 

  77.     for arg in positiveArgs:
    78. 

  78.         try:
    79. 

  79.             _my_call(func, arg)
    80. 

  80.         except Exception, e:
    81. 

  81.             Fail("unexpected exception %s when calling %s with %s\n%s" % (e, func, arg, func.__doc__))
    82. 

  82.         else:
    83. 

  83.             AreEqual(Flag.Value, flagValue)
    84. 

  84.             Flag.Value = -188
    85. 

  85.     
    86. 

  86.     for arg in negativeArgs:
    87. 

  87.         try:
    88. 

  88.             _my_call(func, arg)
    89. 

  89.         except Exception, e:
    90. 

  90.             if not isinstance(e, exceptType):
    91. 

  91.                 Fail("expected '%s', but got '%s' when calling %s with %s\n%s" % (exceptType, e, func, arg, func.__doc__))
    92. 

  92.         else:
    93. 

  93.             Fail("expected exception (but didn't get one) when calling func %s on args %s\n%s" % (func, arg, func.__doc__))
    94. 

  94. 

  95. def test_this_matrix():
    96. 

  96.     '''
    97. 

  97.     This will test the full matrix.
    98. 

  98.     To print the matrix, enable the following flag
    99. 

  99.     '''
    100. 

  100.     print_the_matrix = False
    101. 

  101. 

  102. 

  103.     funcnames =     "M201   M680   M202   M203   M204   M205   M301   M302   M303   M304   M310   M311   M312   M313   M320   M321   M400".split()
    104. 

  104.     matrix = (
    105. 

  105. ####                 M201   M680   M202   M203   M204   M205   M301   M302   M303   M304   M310   M311   M312   M313   M320   M321   M400
    106. 

  106. ####                 int    int?   double bigint bool   str    sbyte  i16    i64    single byte   ui16   ui32   ui64   char   decm   obj
    107. 

  107. (        "SByteMax", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    108. 

  108. (         "ByteMax", True,  True,  True,  True,  True,  TypeE, OverF, True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    109. 

  109. (        "Int16Max", True,  True,  True,  True,  True,  TypeE, OverF, True,  True,  True,  OverF, True,  True,  True,  TypeE, True,  True,  ),
    110. 

  110. (       "UInt16Max", True,  True,  True,  True,  True,  TypeE, OverF, OverF, True,  True,  OverF, True,  True,  True,  TypeE, True,  True,  ),
    111. 

  111. (          "intMax", True,  True,  True,  True,  True,  TypeE, OverF, OverF, True,  True,  OverF, OverF, True,  True,  TypeE, True,  True,  ),
    112. 

  112. (       "UInt32Max", OverF, OverF, True,  True,  True,  TypeE, OverF, OverF, True,  True,  OverF, OverF, True,  True,  TypeE, True,  True,  ),
    113. 

  113. (        "Int64Max", OverF, OverF, True,  True,  True,  TypeE, OverF, OverF, True,  True,  OverF, OverF, OverF, True,  TypeE, True,  True,  ),
    114. 

  114. (       "UInt64Max", OverF, OverF, True,  True,  True,  TypeE, OverF, OverF, OverF, True,  OverF, OverF, OverF, True,  TypeE, True,  True,  ),
    115. 

  115. (      "DecimalMax", OverF, OverF, True,  True,  True,  TypeE, OverF, OverF, OverF, True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    116. 

  116. (       "SingleMax", OverF, OverF, True,  True,  True,  TypeE, OverF, OverF, OverF, True,  OverF, OverF, OverF, OverF, TypeE, OverF, True,  ),
    117. 

  117. (        "floatMax", OverF, OverF, True,  True,  True,  TypeE, OverF, OverF, OverF, True,  OverF, OverF, OverF, OverF, TypeE, OverF, True,  ),
    118. 

  118. ####                 M201   M680   M202   M203   M204   M205   M301   M302   M303   M304   M310   M311   M312   M313   M320   M321   M400
    119. 

  119. ####                 int    int?   double bigint bool   str    sbyte  i16    i64    single byte   ui16   ui32   ui64   char   decm   obj
    120. 

  120. (        "SByteMin", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    121. 

  121. (         "ByteMin", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    122. 

  122. (        "Int16Min", True,  True,  True,  True,  True,  TypeE, OverF, True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    123. 

  123. (       "UInt16Min", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    124. 

  124. (          "intMin", True,  True,  True,  True,  True,  TypeE, OverF, OverF, True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    125. 

  125. (       "UInt32Min", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    126. 

  126. (        "Int64Min", OverF, OverF, True,  True,  True,  TypeE, OverF, OverF, True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    127. 

  127. (       "UInt64Min", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    128. 

  128. (      "DecimalMin", OverF, OverF, True , True,  True,  TypeE, OverF, OverF, OverF, True,  OverF, OverF, OverF, OverF, TypeE, True , True,  ),
    129. 

  129. (       "SingleMin", OverF, OverF, True,  True,  True,  TypeE, OverF, OverF, OverF, True,  OverF, OverF, OverF, OverF, TypeE, OverF, True,  ),
    130. 

  130. (        "floatMin", OverF, OverF, True,  True,  True,  TypeE, OverF, OverF, OverF, True,  OverF, OverF, OverF, OverF, TypeE, OverF, True,  ),
    131. 

  131. ####                 M201   M680   M202   M203   M204   M205   M301   M302   M303   M304   M310   M311   M312   M313   M320   M321   M400
    132. 

  132. ####                 int    int?   double bigint bool   str    sbyte  i16    i64    single byte   ui16   ui32   ui64   char   decm   obj
    133. 

  133. (    "SBytePlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    134. 

  134. (     "BytePlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    135. 

  135. (    "Int16PlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    136. 

  136. (   "UInt16PlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    137. 

  137. (      "intPlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    138. 

  138. (            myint1, True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    139. 

  139. (   "UInt32PlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    140. 

  140. (    "Int64PlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    141. 

  141. (   "UInt64PlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    142. 

  142. (  "DecimalPlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE,  True,  True,  ),
    143. 

  143. (   "SinglePlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    144. 

  144. (    "floatPlusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    145. 

  145. (          myfloat1, True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    146. 

  146. ####                 M201   M680   M202   M203   M204   M205   M301   M302   M303   M304   M310   M311   M312   M313   M320   M321   M400
    147. 

  147. ####                 int    int?   double bigint bool   str    sbyte  i16    i64    single byte   ui16   ui32   ui64   char   decm   obj
    148. 

  148. (   "SByteMinusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    149. 

  149. (   "Int16MinusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    150. 

  150. (     "intMinusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    151. 

  151. (            myint2, True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    152. 

  152. (   "Int64MinusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    153. 

  153. ( "DecimalMinusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    154. 

  154. (  "SingleMinusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    155. 

  155. (   "floatMinusOne", True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    156. 

  156. (          myfloat2, True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    157. 

  157. ##################################################   pass in bool   #########################################################
    158. 

  158. ####                 M201   M680   M202   M203   M204   M205   M301   M302   M303   M304   M310   M311   M312   M313   M320   M321   M400
    159. 

  159. ####                 int    int?   double bigint bool   str    sbyte  i16    i64    single byte   ui16   ui32   ui64   char   decm   obj
    160. 

  160. (              True, True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    161. 

  161. (             False, True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    162. 

  162. ##################################################  pass in BigInt #########################################################
    163. 

  163. ####                 int    int?   double bigint bool   str    sbyte  i16    i64    single byte   ui16   ui32   ui64   char   decm   obj
    164. 

  164. ####                 M201   M680   M202   M203   M204   M205   M301   M302   M303   M304   M310   M311   M312   M313   M320   M321   M400
    165. 

  165. (               10L, True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    166. 

  166. (              -10L, True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    167. 

  167. ( 1234567890123456L, OverF, OverF, True , True,  True,  TypeE, OverF, OverF, True,  True,  OverF, OverF, OverF, True,  TypeE, True,  True,  ),
    168. 

  168. (           mylong1, True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  True,  True,  True,  True,  TypeE, True,  True,  ),
    169. 

  169. (           mylong2, True,  True,  True,  True,  True,  TypeE, True,  True,  True,  True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ),
    170. 

  170. ##################################################  pass in Complex #########################################################
    171. 

  171. ####                 M201   M680   M202   M203   M204   M205   M301   M302   M303   M304   M310   M311   M312   M313   M320   M321   M400
    172. 

  172. ####                 int    int?   double bigint bool   str    sbyte  i16    i64    single byte   ui16   ui32   ui64   char   decm   obj
    173. 

  173. (            (3+0j), TypeE, TypeE, TypeE, TypeE, True,  TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, True,  ),
    174. 

  174. (            (3+1j), TypeE, TypeE, TypeE, TypeE, True,  TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, True,  ),
    175. 

  175. (        mycomplex1, TypeE, TypeE, TypeE, TypeE, True,  TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, True,  )
    176. 

  176.     )
    177. 

  177. 

  178.     
    179. 

  179.     if is_silverlight==False:
    180. 

  180.         InvariantCulture = System.Globalization.CultureInfo.InvariantCulture
    181. 

  181.         matrix = list(matrix)
    182. 

  182.         ##################################################  pass in char    #########################################################
    183. 

  183.         ####                                     M201   M680   M202   M203   M204   M205   M301   M302   M303   M304   M310   M311   M312   M313   M320   M321   M400
    184. 

  184.         ####                                     int    int?   double bigint bool   str    sbyte  i16    i64    single byte   ui16   ui32   ui64   char   decm   obj
    185. 

  185.         matrix.append((System.Char.Parse('A'), TypeE, TypeE, TypeE, TypeE, True,  True,  TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, TypeE, True,  True, True,  ))
    186. 

  186.         
    187. 

  187.         ##################################################  pass in float   #########################################################
    188. 

  188.         ####    single/double becomes Int32, but this does not apply to other primitive types
    189. 

  189.         ####                                                           int    int?  double  bigint bool   str    sbyte i16   i64   single byte   ui16   ui32   ui64   char   decm   obj
    190. 

  190.         matrix.append((System.Single.Parse("8.01", InvariantCulture), True,  True, True,  True,  True,  TypeE, True, True, True, True,  True,  True,  True,  True,  TypeE, True,  True,  ))
    191. 

  191.         matrix.append((System.Double.Parse("10.2", InvariantCulture), True,  True, True,  True,  True,  TypeE, True, True, True, True,  True,  True,  True,  True,  TypeE, True,  True,  ))
    192. 

  192.         matrix.append((System.Single.Parse("-8.1", InvariantCulture), True,  True, True,  True,  True,  TypeE, True, True, True, True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ))
    193. 

  193.         matrix.append((System.Double.Parse("-1.8", InvariantCulture), True,  True, True,  True,  True,  TypeE, True, True, True, True,  OverF, OverF, OverF, OverF, TypeE, True,  True,  ))
    194. 

  194.         matrix = tuple(matrix)
    195. 

  195.     
    196. 

  196.     for scenario in matrix:
    197. 

  197.         if isinstance(scenario[0], str):
    198. 

  198.             value = clr_numbers[scenario[0]]
    199. 

  199.             if print_the_matrix: print '(%18s,' % ('"'+ scenario[0] +'"'),
    200. 

  200.         else:
    201. 

  201.             value = scenario[0]
    202. 

  202.             if print_the_matrix: print '(%18s,' % value ,
    203. 

  203.         
    204. 

  204.         for i in range(len(funcnames)):
    205. 

  205.             funcname = funcnames[i]
    206. 

  206.             func = getattr(target, funcname)
    207. 

  207.             
    208. 

  208.             if print_the_matrix:
    209. 

  209.                 try:
    210. 

  210.                     func(value)
    211. 

  211.                     print "True, ",
    212. 

  212.                 except TypeError:
    213. 

  213.                     print "TypeE,",
    214. 

  214.                 except OverflowError:
    215. 

  215.                     print "OverF,",
    216. 

  216.                 print "),"
    217. 

  217.             else:
    218. 

  218.                 try:
    219. 

  219.                     func(value)
    220. 

  220.                 except Exception,e:
    221. 

  221.                     if scenario[i+1] not in [TypeE, OverF]:
    222. 

  222.                         Fail("unexpected exception %s, when func %s on arg %s (%s)\n%s" % (e, funcname, scenario[0], type(value), func.__doc__))
    223. 

  223.                     if isinstance(e, scenario[i+1]): pass
    224. 

  224.                     else: Fail("expect %s, but got %s when func %s on arg %s (%s)\n%s" % (scenario[i+1], e, funcname, scenario[0], type(value), func.__doc__))
    225. 

  225.                 else:
    226. 

  226.                     if scenario[i+1] in [TypeE, OverF]:
    227. 

  227.                         Fail("expect %s, but got none when func %s on arg %s (%s)\n%s" % (scenario[i+1], funcname, scenario[0], type(value), func.__doc__))
    228. 

  228. 

  229.                     left = Flag.Value ; Flag.Value = -99           # reset
    230. 

  230. 

  231.                     right = int(funcname[1:])
    232. 

  232.                     if left != right:
    233. 

  233.                         Fail("left %s != right %s when func %s on arg %s (%s)\n%s" % (left, right, funcname, scenario[0], type(value), func.__doc__))
    234. 

  234. 

  235.     # these funcs should behavior same as M201(Int32)
    236. 

  236.     # should have NullableInt too ?
    237. 

  237.     for funcname in _get_funcs('RefInt32   ParamArrInt32   Int32ParamArrInt32'):
    238. 

  238.         for scenario in matrix:
    239. 

  239.             if isinstance(scenario[0], str): value = clr_numbers[scenario[0]]
    240. 

  240.             else: value = scenario[0]
    241. 

  241. 

  242.             func = getattr(target, funcname)
    243. 

  243.             if scenario[1] not in [TypeE, OverF]:
    244. 

  244.                 func(value)
    245. 

  245.                 left = Flag.Value
    246. 

  246.                 right = int(funcname[1:])
    247. 

  247.                 if left != right:
    248. 

  248.                     Fail("left %s != right %s when func %s on arg %s" % (left, right, funcname, scenario[0]))
    249. 

  249.                 Flag.Value = -99           # reset
    250. 

  250.             else:
    251. 

  251.                 try:   func(value)
    252. 

  252.                 except scenario[1]: pass   # 1 is M201
    253. 

  253.                 else:  Fail("expect %s, but got none when func %s on arg %s" % (scenario[1], funcname, scenario[0]))
    254. 

  254. 

  255. def test_char_string_asked():
    256. 

  256.     # char asked
    257. 

  257.     _helper(target.M320, ['a', System.Char.MaxValue, System.Char.MinValue, 'abc'[2]], 320, ['abc', ('a  b')], TypeError)
    258. 

  258.     # string asked
    259. 

  259.     _helper(target.M205, ['a', System.Char.MaxValue, System.Char.MinValue, 'abc'[2], 'abc', 'a b' ], 205, [('a', 'b'), 23, ], TypeError)
    260. 

  260.     
    261. 

  261. def test_pass_extensible_types():
    262. 

  262.     # number covered by that matrix
    263. 

  263.     # string or char
    264. 

  264.     mystr1, mystr2 = mystr('a'), mystr('abc')
    265. 

  265.     _helper(target.M205, [mystr1, mystr2, ], 205, [], TypeError)  # String
    266. 

  266.     _helper(target.M320, [mystr1, ], 320, [mystr2, ], TypeError)  # Char
    267. 

  267. 

  268. # check the bool conversion result
    269. 

  269. def test_bool_asked():
    270. 

  270.     for arg in ['a', 3, object(), True]:
    271. 

  271.         target.M204(arg)
    272. 

  272.         Assert(Flag.BValue, "argument is %s" % arg)
    273. 

  273.         Flag.BValue = False
    274. 

  274.         
    275. 

  275.     if is_silverlight==False:
    276. 

  276.         for arg in [0, System.Byte.Parse('0'), System.UInt64.Parse('0'), 0.0, 0L, False, None, tuple(), list()]:
    277. 

  277.             target.M204(arg)
    278. 

  278.             Assert(not Flag.BValue, "argument is %s" % (arg,))
    279. 

  279.             Flag.BValue = True
    280. 

  280. 

  281. def test_user_defined_conversion():
    282. 

  282.     class CP1:
    283. 

  283.         def __int__(self): return 100
    284. 

  284.     
    285. 

  285.     class CP2(object):
    286. 

  286.         def __int__(self): return 99
    287. 

  287.     
    288. 

  288.     class CP3: pass
    289. 

  289.     cp1, cp2, cp3 = CP1(), CP2(), CP3()
    290. 

  290. 

  291.     ### 1. not work for Nullable<Int32> required (?)
    292. 

  292.     ### 2. (out int): should pass in nothing
    293. 

  293.     ###      int  params int int?          ref int   defVal  int+defVal
    294. 

  294.     works = 'M201 M600       M680     M620   M700      M710    M715'
    295. 

  295.     for fn in works.split():
    296. 

  296.         _helper(getattr(target, fn), [cp1, cp2, ], int(fn[1:]), [cp3, ], TypeError)
    297. 

  297.     
    298. 

  298.     for fn in dir(target):
    299. 

  299.     ###                                                     bool  obj
    300. 

  300.         if _self_defined_method(fn) and fn not in (works + 'M204  M400 '):
    301. 

  301.             _helper(getattr(target, fn), [], 0, [cp1, cp2, cp3, ], TypeError)
    302. 

  302. 

  303. def test_pass_in_derived_python_types():
    304. 

  304.     class CP1(I): pass
    305. 

  305.     class CP2(C1): pass
    306. 

  306.     class CP3(C2): pass
    307. 

  307.     class CP4(C6, I): pass
    308. 

  308.     cp1, cp2, cp3, cp4 = CP1(), CP2(), CP3(), CP4()
    309. 

  309. 

  310.     # I asked
    311. 

  311.     _helper(target.M401, [C1(), C2(), S1(), cp1, cp2, cp3, cp4,], 401,[C3(), object()], TypeError)
    312. 

  312.     # C2 asked
    313. 

  313.     _helper(target.M403, [C2(), cp3, ], 403, [C3(), object(), C1(), cp1, cp2, cp4, ], TypeError)
    314. 

  314.     
    315. 

  315.     class CP1(A): pass
    316. 

  316.     class CP2(C6): pass
    317. 

  317.     cp1, cp2 = CP1(), CP2()
    318. 

  318.     
    319. 

  319.     # A asked
    320. 

  320.     _helper(target.M410, [C6(), cp1, cp2, cp4,], 410, [C3(), object(), C1(), cp3, ], TypeError)
    321. 

  321.     # C6 asked
    322. 

  322.     _helper(target.M411, [C6(), cp2, cp4, ], 411, [C3(), object(), C1(), cp1, cp3,], TypeError)
    323. 

  323.     
    324. 

  324. def test_nullable_int():
    325. 

  325.     _helper(target.M680, [None, 100, 100L, System.Byte.MaxValue, System.UInt32.MinValue, myint1, mylong2, 3.6, ], 680, [(), 3+1j], TypeError)
    326. 

  326.     
    327. 

  327. def test_out_int():
    328. 

  328.     if is_silverlight==False:
    329. 

  329.         _helper(target.M701, [], 701, [1, 10L, None, System.Byte.Parse('3')], TypeError)    # not allow to pass in anything
    330. 

  330.     
    331. 

  331. def test_collections():
    332. 

  332.     arrayInt = array_int((10, 20))
    333. 

  333.     tupleInt = ((10, 20), )
    334. 

  334.     listInt  = ([10, 20], )
    335. 

  335.     tupleBool = ((True, False, True, True, False), )
    336. 

  336.     tupleLong1, tupleLong2  = ((10L, 20L), ), ((System.Int64.MaxValue, System.Int32.MaxValue * 2),)
    337. 

  337.     arrayByte = array_byte((10, 20))
    338. 

  338.     arrayObj = array_object(['str', 10])
    339. 

  339.     
    340. 

  340.     # IList<int>
    341. 

  341.     _helper(target.M650, [arrayInt, tupleInt, listInt, arrayObj, tupleLong1, tupleLong2, ], 650, [arrayByte, ], TypeError)
    342. 

  342.     # arrayObj, tupleLong1, tupleLong2 : conversion happens late
    343. 

  343. 

  344.     # Array
    345. 

  345.     _helper(target.M651, [arrayInt, arrayObj, arrayByte, ], 651, [listInt, tupleInt, tupleLong1, tupleLong2, ], TypeError)
    346. 

  346.     
    347. 

  347.     # IEnumerable[int]
    348. 

  348.     _helper(target.M652, [arrayInt, arrayObj, arrayByte, listInt, tupleInt, tupleLong1, tupleLong2, ], 652, [], TypeError)
    349. 

  349.     
    350. 

  350.     # IEnumerator[int]
    351. 

  351.     _helper(target.M653, [], 653, [arrayInt, arrayObj, arrayByte, listInt, tupleInt, tupleLong1, tupleLong2, ], TypeError)
    352. 

  352.     
    353. 

  353.     # Int32[]
    354. 

  354.     _helper(target.M500, [arrayInt, tupleInt, tupleLong1, tupleBool, ], 500, [listInt, arrayByte, arrayObj, ], TypeError)
    355. 

  355.     _helper(target.M500, [], 500, [tupleLong2, ], OverflowError)
    356. 

  356.     # params Int32[]
    357. 

  357.     _helper(target.M600, [arrayInt, tupleInt, tupleLong1, tupleBool, ], 600, [listInt, arrayByte, arrayObj, ], TypeError)
    358. 

  358.     _helper(target.M600, [], 600, [tupleLong2, ], OverflowError)
    359. 

  359.     
    360. 

  360.     # Int32, params Int32[]
    361. 

  361.     _helper(target.M620, [(10, 10), (10L, 10), (10L, 10L), (10, 10L), (10, arrayInt), (10, (10, 20)), ], 620, [(10, [10, 20]), ], TypeError)
    362. 

  362.     _helper(target.M620, [], 620, [(10, 123456789101234L), ], OverflowError)
    363. 

  363.     
    364. 

  364.     arrayI1 = System.Array[I]( (C1(), C2()) )
    365. 

  365.     arrayI2 = System.Array[I]( () )
    366. 

  366.     arrayObj3 = System.Array[object]( (C1(), C2()) )
    367. 

  367.     tupleI = ((C1(), C2()),)
    368. 

  368.     listI =  ([C1(), C2()],)
    369. 

  369.     _helper(target.M510, [arrayI1, arrayI2, tupleI, ], 510, [arrayObj3, listI, ], TypeError)     # I[]
    370. 

  370.     _helper(target.M610, [arrayI1, arrayI2, tupleI, ], 610, [arrayObj3, listI, ], TypeError)     # params I[]
    371. 

  371. 

  372. def test_no_arg_asked():
    373. 

  373.     # no args asked
    374. 

  374.     _helper(target.M100, [()], 100, [2, None, (2, None)], TypeError)
    375. 

  375. 

  376. def test_enum():
    377. 

  377.     # E1 asked
    378. 

  378.     _helper(target.M450, [E1.A, ], 450, [10, E2.A], TypeError)
    379. 

  379.     # E2: ushort asked
    380. 

  380.     if is_silverlight==False:
    381. 

  381.         _helper(target.M451, [E2.A, ], 451, [10, E1.A, System.UInt16.Parse("3")], TypeError)
    382. 

  382. 

  383. def _repeat_with_one_arg(goodStr, getArg):
    384. 

  384.     passSet = _get_funcs(goodStr)
    385. 

  385.     skipSet = []
    386. 

  386. 

  387.     for fn in passSet:
    388. 

  388.         if fn in skipSet: continue
    389. 

  389.         
    390. 

  390.         arg = getArg()
    391. 

  391.         getattr(target, fn)(arg)
    392. 

  392.         left = Flag.Value
    393. 

  393.         right = int(fn[1:])
    394. 

  394.         if left != right:
    395. 

  395.             Fail("left %s != right %s when func %s on arg %s" % (left, right, fn, arg))
    396. 

  396.     
    397. 

  397.     for fn in dir(target):
    398. 

  398.         if _self_defined_method(fn) and (fn not in passSet) and (fn not in skipSet):
    399. 

  399.             arg = getArg()
    400. 

  400.             try:   getattr(target, fn)(arg)
    401. 

  401.             except TypeError : pass
    402. 

  402.             else:  Fail("expect TypeError, but got none when func %s on arg %s" % (fn, arg))
    403. 

  403. 

  404. def test_pass_in_none():
    405. 

  405.     test_str = '''
    406. 

  406. Bool String Object I C1 C2 A C6
    407. 

  407. ArrInt32 ArrI ParamArrInt32 ParamArrI ParamArrS IParamArrI
    408. 

  408. IListInt Array IEnumerableInt IEnumeratorInt NullableInt
    409. 

  409. '''
    410. 

  410.     # Big integers are only nullable in CLR 2
    411. 

  411.     if not is_net40:
    412. 

  412.         test_str = "BigInt " + test_str
    413. 

  413.     
    414. 

  414.     _repeat_with_one_arg(test_str, lambda : None)
    415. 

  415. 

  416. def test_pass_in_clrReference():
    417. 

  417.     import clr
    418. 

  418.     _repeat_with_one_arg('Object RefInt32  OutInt32', lambda : clr.Reference[int](0))
    419. 

  419.     _repeat_with_one_arg('Object', lambda : clr.Reference[object](None))
    420. 

  420.     _repeat_with_one_arg('Object RefInt32  OutInt32', lambda : clr.Reference[int](10))
    421. 

  421.     _repeat_with_one_arg('Object ', lambda : clr.Reference[float](123.123))
    422. 

  422.     _repeat_with_one_arg('Object', lambda : clr.Reference[type](str)) # ref.Value = (type)
    423. 

  423. 

  424. def test_pass_in_nothing():
    425. 

  425.     passSet = _get_funcs('NoArg ParamArrInt32 ParamArrS ParamArrI OutInt32 DefValInt32')
    426. 

  426.     skipSet = [ ]  # be empty before release
    427. 

  427.     
    428. 

  428.     for fn in passSet:
    429. 

  429.         if fn in skipSet: continue
    430. 

  430.         
    431. 

  431.         getattr(target, fn)()
    432. 

  432.         left = Flag.Value
    433. 

  433.         right = int(fn[1:])
    434. 

  434.         if left != right:
    435. 

  435.             Fail("left %s != right %s when func %s on arg Nothing" % (left, right, fn))
    436. 

  436.     
    437. 

  437.     for fn in dir(target):
    438. 

  438.         if _self_defined_method(fn) and (fn not in passSet) and (fn not in skipSet):
    439. 

  439.             try:   getattr(target, fn)()
    440. 

  440.             except TypeError : pass
    441. 

  441.             else:  Fail("expect TypeError, but got none when func %s on arg Nothing" % fn)
    442. 

  442.     
    443. 

  443. def test_other_concern():
    444. 

  444.     target = COtherConcern()
    445. 

  445.     
    446. 

  446.     # static void M100()
    447. 

  447.     target.M100()
    448. 

  448.     AreEqual(Flag.Value, 100); Flag.Value = 99
    449. 

  449.     COtherConcern.M100()
    450. 

  450.     AreEqual(Flag.Value, 100); Flag.Value = 99
    451. 

  451.     AssertError(TypeError, target.M100, target)
    452. 

  452.     AssertError(TypeError, COtherConcern.M100, target)
    453. 

  453.     
    454. 

  454.     # static void M101(COtherConcern arg)
    455. 

  455.     target.M101(target)
    456. 

  456.     AreEqual(Flag.Value, 101); Flag.Value = 99
    457. 

  457.     COtherConcern.M101(target)
    458. 

  458.     AreEqual(Flag.Value, 101); Flag.Value = 99
    459. 

  459.     AssertError(TypeError, target.M101)
    460. 

  460.     AssertError(TypeError, COtherConcern.M101)
    461. 

  461.     
    462. 

  462.     # void M102(COtherConcern arg)
    463. 

  463.     target.M102(target)
    464. 

  464.     AreEqual(Flag.Value, 102); Flag.Value = 99
    465. 

  465.     COtherConcern.M102(target, target)
    466. 

  466.     AreEqual(Flag.Value, 102); Flag.Value = 99
    467. 

  467.     AssertError(TypeError, target.M102)
    468. 

  468.     AssertError(TypeError, COtherConcern.M102, target)
    469. 

  469.     
    470. 

  470.     # generic method
    471. 

  471.     target.M200[int](100)
    472. 

  472.     AreEqual(Flag.Value, 200); Flag.Value = 99
    473. 

  473.     target.M200[int](100.1234)
    474. 

  474.     AreEqual(Flag.Value, 200); Flag.Value = 99
    475. 

  475.     target.M200[long](100)
    476. 

  476.     AreEqual(Flag.Value, 200); Flag.Value = 99
    477. 

  477.     AssertError(OverflowError, target.M200[System.Byte], 300)
    478. 

  478.     AssertError(OverflowError, target.M200[int], 12345678901234)
    479. 

  479.     
    480. 

  480.     # We should ignore Out attribute on non-byref.
    481. 

  481.     # It's used in native interop scenarios to designate a buffer (StringBUilder, arrays, etc.) 
    482. 

  482.     # the caller allocates, passes to the method and expects the callee to populate it with data.
    483. 

  483.     AssertError(TypeError, target.M222)
    484. 

  484.     AreEqual(target.M222(0), None)
    485. 

  485.     AreEqual(Flag.Value, 222)
    486. 

  486.     
    487. 

  487.     # what does means when passing in None
    488. 

  488.     target.M300(None)
    489. 

  489.     AreEqual(Flag.Value, 300); Flag.Value = 99
    490. 

  490.     AreEqual(Flag.BValue, True)
    491. 

  491.     target.M300(C1())
    492. 

  492.     AreEqual(Flag.BValue, False)
    493. 

  493.     
    494. 

  494.     # void M400(ref Int32 arg1, out Int32 arg2, Int32 arg3) etc...
    495. 

  495.     AreEqual(target.M400(1, 100), (100, 100))
    496. 

  496.     AreEqual(target.M401(1, 100), (100, 100))
    497. 

  497.     AreEqual(target.M402(100, 1), (100, 100))
    498. 

  498.     
    499. 

  499.     # default Value
    500. 

  500.     target.M450()
    501. 

  501.     AreEqual(Flag.Value, 80); Flag.Value = 99
    502. 

  502.     
    503. 

  503.     # 8 args
    504. 

  504.     target.M500(1,2,3,4,5,6,7,8)
    505. 

  505.     AreEqual(Flag.Value, 500)
    506. 

  506.     AssertError(TypeError, target.M500)
    507. 

  507.     AssertError(TypeError, target.M500, 1)
    508. 

  508.     AssertError(TypeError, target.M500, 1,2,3,4,5,6,7,8,9)
    509. 

  509.     
    510. 

  510.     # IDictionary
    511. 

  511.     for x in [ {1:1}, {"str": 3} ]:
    512. 

  512.         target.M550(x)
    513. 

  513.         AreEqual(Flag.Value, 550); Flag.Value = 99
    514. 

  514.     AssertError(TypeError, target.M550, [1, 2])
    515. 

  515.     
    516. 

  516.     # not supported
    517. 

  517.     for fn in (target.M600, target.M601, target.M602):
    518. 

  518.         for l in ( {1:'a'}, [1,2], (1,2) ):
    519. 

  519.             AssertError(TypeError, fn, l)
    520. 

  520.             
    521. 

  521.     # delegate
    522. 

  522.     def f(x): return x * x
    523. 

  523.     AssertError(TypeError, target.M700, f)
    524. 

  524. 

  525.     from IronPythonTest import IntIntDelegate
    526. 

  526.     for x in (lambda x: x, lambda x: x*2, f):
    527. 

  527.         target.M700(IntIntDelegate(x))
    528. 

  528.         AreEqual(Flag.Value, x(10)); Flag.Value = 99
    529. 

  529.     
    530. 

  530.     target.M701(lambda x: x*2)
    531. 

  531.     AreEqual(Flag.Value, 20); Flag.Value = 99
    532. 

  532.     AssertError(TypeError, target.M701, lambda : 10)
    533. 

  533.     
    534. 

  534.     # keywords
    535. 

  535.     x = target.M800(arg1 = 100, arg2 = 200L, arg3 = 'this'); AreEqual(x, 'THIS')
    536. 

  536.     x = target.M800(arg3 = 'Python', arg1 = 100, arg2 = 200L); AreEqual(x, 'PYTHON')
    537. 

  537.     x = target.M800(100, arg3 = 'iron', arg2 = C1()); AreEqual(x, 'IRON')
    538. 

  538.     
    539. 

  539.     try: target.M800(100, 'Yes', arg2 = C1())
    540. 

  540.     except TypeError: pass
    541. 

  541.     else: Fail("expect: got multiple values for keyword argument arg2")
    542. 

  542.     
    543. 

  543.     # more ref/out sanity check
    544. 

  544.     import clr
    545. 

  545.     def f1(): return clr.Reference[object](None)
    546. 

  546.     def f2(): return clr.Reference[int](10)
    547. 

  547.     def f3(): return clr.Reference[S1](S1())
    548. 

  548.     def f4(): return clr.Reference[C1](C2()) # C2 inherits C1
    549. 

  549. 

  550.     for (f, a, b, c, d) in [
    551. 

  551.         ('M850', False, False, True, False),
    552. 

  552.         ('M851', False, False, False, True),
    553. 

  553.         ('M852', False, False, True, False),
    554. 

  554.         ('M853', False, False, False, True),
    555. 

  555.     ]:
    556. 

  556.         expect = (f in 'M850 M852') and S1 or C1
    557. 

  557.         func = getattr(target, f)
    558. 

  558.         
    559. 

  559.         for i in range(4):
    560. 

  560.             ref = (f1, f2, f3, f4)[i]()
    561. 

  561.             if (a,b,c,d)[i]:
    562. 

  562.                 func(ref); AreEqual(type(ref.Value), expect)
    563. 

  563.             else:
    564. 

  564.                 AssertError(TypeError, func, ref)
    565. 

  565. 

  566.     # call 854
    567. 

  567.     AssertError(TypeError, target.M854, clr.Reference[object](None))
    568. 

  568.     AssertError(TypeError, target.M854, clr.Reference[int](10))
    569. 

  569.     
    570. 

  570.     # call 855
    571. 

  571.     AssertError(TypeError, target.M855, clr.Reference[object](None))
    572. 

  572.     AssertError(TypeError, target.M855, clr.Reference[int](10))
    573. 

  573.     
    574. 

  574.     # call 854 and 855 with Reference[bool]
    575. 

  575.     target.M854(clr.Reference[bool](True)); AreEqual(Flag.Value, 854)
    576. 

  576.     target.M855(clr.Reference[bool](True)); AreEqual(Flag.Value, 855)
    577. 

  577.     
    578. 

  578.     # practical
    579. 

  579.     ref = clr.Reference[int](0)
    580. 

  580.     ref2 = clr.Reference[int](0)
    581. 

  581.     ref.Value = 300
    582. 

  582.     ref2.Value = 100
    583. 

  583.     ## M860(ref arg1, arg2, out arg3): arg3 = arg1 + arg2; arg1 = 100;
    584. 

  584.     x = target.M860(ref, 200, ref2)
    585. 

  585.     AreEqual(x, None)
    586. 

  586.     AreEqual(ref.Value, 100)
    587. 

  587.     AreEqual(ref2.Value, 500)
    588. 

  588.     
    589. 

  589.     # pass one clr.Reference(), and leave the other one open
    590. 

  590.     ref.Value = 300
    591. 

  591.     AssertError(TypeError, target.M860, ref, 200)
    592. 

  592.     
    593. 

  593.     # the other way
    594. 

  594.     x = target.M860(300, 200)
    595. 

  595.     AreEqual(x, (100, 500))
    596. 

  596.     
    597. 

  597.     # GOtherConcern<T>
    598. 

  598.     target = GOtherConcern[int]()
    599. 

  599.     for x in [100, 200L, 4.56, myint1]:
    600. 

  600.         target.M100(x)
    601. 

  601.         AreEqual(Flag.Value, 100); Flag.Value = 99
    602. 

  602.     
    603. 

  603.     GOtherConcern[int].M100(target, 200)
    604. 

  604.     AreEqual(Flag.Value, 100); Flag.Value = 99
    605. 

  605.     AssertError(TypeError, target.M100, 'abc')
    606. 

  606.     AssertError(OverflowError, target.M100, 12345678901234)
    607. 

  607.     
    608. 

  608. def test_iterator_sequence():
    609. 

  609.     class C:
    610. 

  610.         def __init__(self):  self.x = 0
    611. 

  611.         def __iter__(self):  return self
    612. 

  612.         def next(self):
    613. 

  613.             if self.x < 10:
    614. 

  614.                 y = self.x
    615. 

  615.                 self.x += 1
    616. 

  616.                 return y
    617. 

  617.             else:
    618. 

  618.                 self.x = 0
    619. 

  619.                 raise StopIteration
    620. 

  620.         def __len__(self): return 10
    621. 

  621.         
    622. 

  622.     # different size
    623. 

  623.     c = C()
    624. 

  624.     list1 = [1, 2, 3]
    625. 

  625.     tuple1 = [4, 5, 6, 7]
    626. 

  626.     str1 = "890123"
    627. 

  627.     all = (list1, tuple1, str1, c)
    628. 

  628.     
    629. 

  629.     target = COtherConcern()
    630. 

  630.     
    631. 

  631.     for x in all:
    632. 

  632.         # IEnumerable / IEnumerator
    633. 

  633.         target.M620(x)
    634. 

  634.         AreEqual(Flag.Value, len(x)); Flag.Value = 0
    635. 

  635.         
    636. 

  636.         # built in types are not IEnumerator, they are enumerable
    637. 

  637.         if not isinstance(x, C):
    638. 

  638.             AssertError(TypeError, target.M621, x)
    639. 

  639.         else:
    640. 

  640.             target.M621(x)
    641. 

  641.             AreEqual(Flag.Value, len(x))
    642. 

  642. 

  643.         # IEnumerable<char> / IEnumerator<char>
    644. 

  644.         target.M630(x)
    645. 

  645.         AreEqual(Flag.Value, len(x)); Flag.Value = 0
    646. 

  646.         AssertError(TypeError, target.M631, x)
    647. 

  647. 

  648.         # IEnumerable<int> / IEnumerator<int>
    649. 

  649.         target.M640(x)
    650. 

  650.         AreEqual(Flag.Value, len(x)); Flag.Value = 0
    651. 

  651.         AssertError(TypeError, target.M641, x)
    652. 

  652. 

  653.     # IList / IList<char> / IList<int>
    654. 

  654.     for x in (list1, tuple1):
    655. 

  655.         target.M622(x)
    656. 

  656.         AreEqual(Flag.Value, len(x))
    657. 

  657. 

  658.         target.M632(x)
    659. 

  659.         AreEqual(Flag.Value, len(x))
    660. 

  660. 

  661.         target.M642(x)
    662. 

  662.         AreEqual(Flag.Value, len(x))
    663. 

  663. 

  664.     for x in (str1, c):
    665. 

  665.         AssertError(TypeError, target.M622, x)
    666. 

  666.         AssertError(TypeError, target.M632, x)
    667. 

  667.         AssertError(TypeError, target.M642, x)
    668. 

  668.        
    669. 

  669. def test_explicit_inheritance():
    670. 

  670.     target = CInheritMany1()
    671. 

  671.     Assert(hasattr(target, "M"))
    672. 

  672.     target.M()
    673. 

  673.     AreEqual(Flag.Value, 100)
    674. 

  674.     I1.M(target); AreEqual(Flag.Value, 100); Flag.Value = 0
    675. 

  675.     
    676. 

  676.     target = CInheritMany2()
    677. 

  677.     target.M(); AreEqual(Flag.Value, 201)
    678. 

  678.     I1.M(target); AreEqual(Flag.Value, 200)
    679. 

  679.     
    680. 

  680.     target = CInheritMany3()
    681. 

  681.     Assert(not hasattr(target, "M"))
    682. 

  682.     try: target.M()
    683. 

  683.     except AttributeError: pass
    684. 

  684.     else: Fail("Expected AttributeError, got none")
    685. 

  685.     I1.M(target); AreEqual(Flag.Value, 300)
    686. 

  686.     I2.M(target); AreEqual(Flag.Value, 301)
    687. 

  687.     
    688. 

  688.     target = CInheritMany4()
    689. 

  689.     target.M(); AreEqual(Flag.Value, 401)
    690. 

  690.     I3[object].M(target); AreEqual(Flag.Value, 400)
    691. 

  691.     AssertError(TypeError, I3[int].M, target)
    692. 

  692.     
    693. 

  693.     target = CInheritMany5()
    694. 

  694.     I1.M(target); AreEqual(Flag.Value, 500)
    695. 

  695.     I2.M(target); AreEqual(Flag.Value, 501)
    696. 

  696.     I3[object].M(target); AreEqual(Flag.Value, 502)
    697. 

  697.     target.M(); AreEqual(Flag.Value, 503)
    698. 

  698.     
    699. 

  699.     target = CInheritMany6[int]()
    700. 

  700.     target.M(); AreEqual(Flag.Value, 601)
    701. 

  701.     I3[int].M(target); AreEqual(Flag.Value, 600)
    702. 

  702.     AssertError(TypeError, I3[object].M, target)
    703. 

  703. 

  704.     target = CInheritMany7[int]()
    705. 

  705.     Assert(hasattr(target, "M"))
    706. 

  706.     target.M(); AreEqual(Flag.Value, 700)
    707. 

  707.     I3[int].M(target); AreEqual(Flag.Value, 700)
    708. 

  708.     
    709. 

  709.     target = CInheritMany8()
    710. 

  710.     Assert(not hasattr(target, "M"))
    711. 

  711.     try: target.M()
    712. 

  712.     except AttributeError: pass
    713. 

  713.     else: Fail("Expected AttributeError, got none")
    714. 

  714.     I1.M(target); AreEqual(Flag.Value, 800); Flag.Value = 0
    715. 

  715.     I4.M(target, 100); AreEqual(Flag.Value, 801)
    716. 

  716.     # target.M(100) ????
    717. 

  717.     
    718. 

  718.     # original repro
    719. 

  719.     from System.Collections.Generic import Dictionary
    720. 

  720.     d = Dictionary[object,object]()
    721. 

  721.     d.GetEnumerator() # not throw
    722. 

  722. 

  723. def test_nullable_property_double():
    724. 

  724.     from IronPythonTest import NullableTest
    725. 

  725.     nt = NullableTest()
    726. 

  726.     nt.DProperty = 1
    727. 

  727.     AreEqual(nt.DProperty, 1.0)
    728. 

  728.     nt.DProperty = 2.0
    729. 

  729.     AreEqual(nt.DProperty, 2.0)
    730. 

  730.     nt.DProperty = None
    731. 

  731.     AreEqual(nt.DProperty, None)
    732. 

  732.     
    733. 

  733. @disabled("Merlin 309716")
    734. 

  734. def test_nullable_property_long():
    735. 

  735.     from IronPythonTest import NullableTest
    736. 

  736.     nt = NullableTest()
    737. 

  737.     nt.LProperty = 1
    738. 

  738.     AreEqual(nt.LProperty, 1L)
    739. 

  739.     nt.LProperty = 2L
    740. 

  740.     AreEqual(nt.LProperty, 2L)
    741. 

  741.     nt.LProperty = None
    742. 

  742.     AreEqual(nt.LProperty, None)
    743. 

  743. 

  744. def test_nullable_property_bool():
    745. 

  745.     from IronPythonTest import NullableTest
    746. 

  746.     nt = NullableTest()
    747. 

  747.     nt.BProperty = 1.0
    748. 

  748.     AreEqual(nt.BProperty, True)
    749. 

  749.     nt.BProperty = 0.0
    750. 

  750.     AreEqual(nt.BProperty, False)
    751. 

  751.     nt.BProperty = True
    752. 

  752.     AreEqual(nt.BProperty, True)
    753. 

  753.     nt.BProperty = None
    754. 

  754.     AreEqual(nt.BProperty, None)
    755. 

  755.     
    756. 

  756. def test_nullable_property_enum():
    757. 

  757.     from IronPythonTest import NullableTest
    758. 

  758.     nt = NullableTest()
    759. 

  759.     nt.EProperty = NullableTest.NullableEnums.NE1
    760. 

  760.     AreEqual(nt.EProperty, NullableTest.NullableEnums.NE1)
    761. 

  761.     nt.EProperty = None
    762. 

  762.     AreEqual(nt.EProperty, None)
    763. 

  763. 

  764. def test_nullable_parameter():
    765. 

  765.     from IronPythonTest import NullableTest
    766. 

  766.     nt = NullableTest()
    767. 

  767.     result = nt.Method(1)
    768. 

  768.     AreEqual(result, 1.0)
    769. 

  769.     result = nt.Method(2.0)
    770. 

  770.     AreEqual(result, 2.0)
    771. 

  771.     result = nt.Method(None)
    772. 

  772.     AreEqual(result, None)
    773. 

  773. 

  774. # Skip on silverlight because the System.Configuration is not available
    775. 

  775. @skip("silverlight")
    776. 

  776. @skip("netstandard") # no System.Configuration in netstandard
    777. 

  777. def test_xequals_call_for_optimization():
    778. 

  778.     """
    779. 

  779.     Testing specifically for System.Configuration.ConfigurationManager
    780. 

  780.     because currently its .Equals method will throw null reference
    781. 

  781.     exception when called with null argument. This is a case that could
    782. 

  782.     slip through our dynamic site checks.
    783. 

  783.     """
    784. 

    785. 

  785.     import clr
    786. 

  786.     clr.AddReference("System.Configuration");
    787. 

  787.     from System.Configuration import ConfigurationManager
    788. 

  788.     c = ConfigurationManager.ConnectionStrings
    789. 

  789.     
    790. 

  790.     #Invoke tests multiple times to make sure DynamicSites are utilized
    791. 

  791.     for i in xrange(3):
    792. 

  792.         if is_posix: # Posix has two default connection strings
    793. 

  793.             AreEqual(2, c.Count)
    794. 

  794.         else:
    795. 

  795.             AreEqual(1, c.Count)
    796. 

  796.         
    797. 

  797.     for i in xrange(3):
    798. 

  798.         count = c.Count
    799. 

  799.         if is_posix:
    800. 

  800.             AreEqual(2, count)
    801. 

  801.         else:
    802. 

  802.             AreEqual(1, count)
    803. 

  803.         AreEqual(c.Count, count)
    804. 

  804.             
    805. 

  805.     for i in xrange(3):
    806. 

  806.         #just ensure it doesn't throw
    807. 

  807.         c[0].Name
    808. 

  808.         
    809. 

  809.     #Just to be sure this doesn't throw...
    810. 

  810.     c.Count
    811. 

  811.     c.Count
    812. 

  812.         
    813. 

  813. 

  814. def test_interface_only_access():
    815. 

  815.     pc = InterfaceOnlyTest.PrivateClass
    816. 

  816.     
    817. 

  817.     # property set
    818. 

  818.     pc.Hello = InterfaceOnlyTest.PrivateClass
    819. 

  819.     # property get
    820. 

  820.     AreEqual(pc.Hello, pc)
    821. 

  821.     # method call w/ interface param
    822. 

  822.     pc.Foo(pc)
    823. 

  823.     # method call w/ interface ret val
    824. 

  824.     AreEqual(pc.RetInterface(), pc)
    825. 

  825.     
    826. 

  826.     # events
    827. 

  827.     global fired
    828. 

  828.     fired = False
    829. 

  829.     def fired(*args):
    830. 

  830.         global fired
    831. 

  831.         fired = True
    832. 

  832.         return args[0]
    833. 

  833.     # add event
    834. 

  834.     pc.MyEvent += fired
    835. 

  835.     # fire event
    836. 

  836.     AreEqual(pc.FireEvent(pc.GetEventArgs()), pc)
    837. 

  837.     AreEqual(fired, True)
    838. 

  838.     # remove event
    839. 

  839.     pc.MyEvent -= fired
    840. 

  840. 

  841. def test_ref_bytearr():
    842. 

  842.     target = COtherConcern()
    843. 

  843.     
    844. 

  844.     arr = System.Array[System.Byte]((2,3,4))
    845. 

  845.     
    846. 

  846.     res = target.M702(arr)
    847. 

  847.     AreEqual(Flag.Value, 702)
    848. 

  848.     AreEqual(type(res), System.Array[System.Byte])
    849. 

  849.     AreEqual(len(res), 0)
    850. 

  850.     
    851. 

  851.     i, res = target.M703(arr)
    852. 

  852.     AreEqual(Flag.Value, 703)
    853. 

  853.     AreEqual(i, 42)
    854. 

  854.     AreEqual(type(res), System.Array[System.Byte])
    855. 

  855.     AreEqual(len(res), 0)
    856. 

  856.     
    857. 

  857.     i, res = target.M704(arr, arr)
    858. 

  858.     AreEqual(Flag.Value, 704)
    859. 

  859.     AreEqual(i, 42)
    860. 

  860.     AreEqual(arr, res)
    861. 

  861.     
    862. 

  862.     sarr = clr.StrongBox[System.Array[System.Byte]](arr)
    863. 

  863.     res = target.M702(sarr)
    864. 

  864.     AreEqual(Flag.Value, 702)
    865. 

  865.     AreEqual(res, None)
    866. 

  866.     res = sarr.Value
    867. 

  867.     AreEqual(type(res), System.Array[System.Byte])
    868. 

  868.     AreEqual(len(res), 0)
    869. 

  869.     
    870. 

  870.     sarr.Value = arr
    871. 

  871.     i = target.M703(sarr)
    872. 

  872.     AreEqual(Flag.Value, 703)
    873. 

  873.     AreEqual(i, 42)
    874. 

  874.     AreEqual(len(sarr.Value), 0)
    875. 

  875.     
    876. 

  876.     i = target.M704(arr, sarr)
    877. 

  877.     AreEqual(Flag.Value, 704)
    878. 

  878.     AreEqual(i, 42)
    879. 

  879.     AreEqual(sarr.Value, arr)
    880. 

  880. 

  881. def test_struct_prop_assign():
    882. 

  882.     from IronPythonTest.BinderTest import SOtherConcern
    883. 

  883.     a = SOtherConcern()
    884. 

  884.     a.P100 = 42
    885. 

  885.     AreEqual(a.P100, 42)
    886. 

  886.     
    887. 

  887. def test_generic_type_inference():
    888. 

  888.     from IronPythonTest import GenericTypeInference, GenericTypeInferenceInstance, SelfEnumerable    
    889. 

  889.     from System import Array, Exception, ArgumentException
    890. 

  890.     from System.Collections.Generic import IEnumerable, List
    891. 

  891.     from System.Collections.Generic import Dictionary as Dict
    892. 

  892. 

  893.     class UserGenericType(GenericTypeInferenceInstance): pass
    894. 

  894. 

  895.     # public PythonType MInst<T>(T x) -> pytype(T)
    896. 

  896.     AreEqual(UserGenericType().MInst(42), int)
    897. 

  897. 

  898.     class UserObject(object): pass
    899. 

  899.         
    900. 

  900.     userInst = UserObject()
    901. 

  901.     userInt, userLong, userFloat, userComplex, userStr = myint(), mylong(), myfloat(), mycomplex(), mystr()
    902. 

  902.     userTuple, userList, userDict = mytuple(), mylist(), mydict()
    903. 

  903.     objArray = System.Array[object]( (1,2,3) )
    904. 

  904.     doubleArray = System.Array[float]( (1.0,2.0,3.0) )
    905. 

  905.     
    906. 

  906. 

  907.     for target in [GenericTypeInference, GenericTypeInferenceInstance(), UserGenericType()]:    
    908. 

  908.         tests = [     
    909. 

  909.          # simple single type tests, no constraints
    910. 

  910.          # public static PythonType M0<T>(T x) -> pytypeof(T)
    911. 

  911.          # target method,   args,                            Result,     KeywordCall,      Exception
    912. 

  912.          (target.M0,        (1, ),                          int,        True,             None),
    913. 

  913.          (target.M0,        (userInst, ),                   object,     True,             None),
    914. 

  914.          (target.M0,        (userInt, ),                    object,     True,             None),
    915. 

  915.          (target.M0,        (userStr, ),                    object,     True,             None),
    916. 

  916.          (target.M0,        (userLong, ),                   object,     True,             None),
    917. 

  917.          (target.M0,        (userFloat, ),                  object,     True,             None),
    918. 

  918.          (target.M0,        (userComplex, ),                object,     True,             None),
    919. 

  919.          (target.M0,        (userTuple, ),                  tuple,      True,             None),
    920. 

  920.          (target.M0,        (userList, ),                   list,       True,             None),
    921. 

  921.          (target.M0,        (userDict, ),                   dict,       True,             None),
    922. 

  922.          (target.M0,        ((), ),                         tuple,      True,             None),
    923. 

  923.          (target.M0,        ([], ),                         list,       True,             None),
    924. 

  924.          (target.M0,        ({}, ),                         dict,       True,             None),
    925. 

  925.          
    926. 

  926.          # multiple arguments
    927. 

  927.          # public static PythonType M1<T>(T x, T y) -> pytypeof(T)
    928. 

  928.          # public static PythonType M2<T>(T x, T y, T z) -> pytypeof(T)
    929. 

  929.          (target.M1,        (1, 2),                         int,        True,             None),
    930. 

  930.          (target.M2,        (1, 2, 3),                      int,        True,             None),
    931. 

  931.          (target.M1,        (userInst, userInst),           object,     True,             None),
    932. 

  932.          (target.M2,        (userInst, userInst, userInst), object,     True,             None),
    933. 

  933.          (target.M1,        (1, 2.0),                       None,       True,             TypeError),
    934. 

  934.          (target.M1,        (1, 'abc'),                     None,       True,             TypeError),
    935. 

  935.          (target.M1,        (object(), userInst),           object,     True,             None),
    936. 

  936.          (target.M1,        ([], userList),                 list,       True,             None),
    937. 

  937.     
    938. 

  938.          # params arguments
    939. 

  939.          # public static PythonType M3<T>(params T[] args) -> pytypeof(T)
    940. 

  940.          (target.M3,        (),                             None,       False,           TypeError),
    941. 

  941.          (target.M3,        (1, ),                          int,        False,            None),
    942. 

  942.          (target.M3,        (1, 2),                         int,        False,            None),
    943. 

  943.          (target.M3,        (1, 2, 3),                      int,        False,            None),
    944. 

  944.          (target.M3,        (1, 2.0),                       object,     False,            TypeError),
    945. 

  945.          (target.M3,        (1, 'abc'),                     object,     False,            TypeError),
    946. 

  946.          (target.M3,        (object(), userInst),           object,     False,            None),
    947. 

  947.          (target.M3,        ([], userList),                 list,       False,            None),
    948. 

  948.          
    949. 

  949.          # public static PythonType M4<T>(T x, params T[] args) -> pytypeof(T)
    950. 

  950.          (target.M4,        (1, 2),                         int,        False,            None),
    951. 

  951.          (target.M4,        (1, 2.0),                       object,     False,            TypeError),
    952. 

  952.          (target.M4,        (1, 'abc'),                     object,     False,            TypeError),
    953. 

  953.          (target.M4,        (object(), userInst),           object,     False,            None),
    954. 

  954.          (target.M4,        ([], userList),                 list,       False,            None),
    955. 

  955.          
    956. 

  956.          # simple constraints
    957. 

  957.          # public static PythonType M5<T>(T x) where T : class -> pytype(T)
    958. 

  958.          # public static PythonType M6<T>(T x) where T : struct -> pytype(T)
    959. 

  959.          # public static PythonType M7<T>(T x) where T : IList -> pytype(T)
    960. 

  960.          (target.M5,        (1, ),                           None,      False,           TypeError),
    961. 

  961.          (target.M6,        ('abc', ),                       None,      False,           TypeError),
    962. 

  962.          (target.M7,        (object(), ),                    None,      False,           TypeError),
    963. 

  963.          (target.M7,        (2, ),                           None,      False,           TypeError),
    964. 

  964.          (target.M5,        ('abc', ),                       str,        False,           None),
    965. 

  965.          (target.M5,        (object(), ),                    object,     False,           None),
    966. 

  966.          (target.M6,        (1, ),                           int,        False,           None),
    967. 

  967.          (target.M7,        ([], ),                          list,       False,           None),
    968. 

  968.          (target.M7,        (objArray, ),                    type(objArray),False,        None),
    969. 

  969.     
    970. 

  970.          # simple dependent constraints
    971. 

  971.          # public static PythonTuple M8<T0, T1>(T0 x, T1 y) where T0 : T1 -> (pytype(T0), pytype(T1))     
    972. 

  972.          (target.M8,        (1, 2),                         (int, int),   False,           None),
    973. 

  973.          (target.M8,        ('abc', object()),              (str, object),False,           None),
    974. 

  974.          (target.M8,        (object(), 'abc'),              None,         False,           TypeError),
    975. 

  975.          (target.M8,        (1, object()),                  (int, object),False,           None),
    976. 

  976.          (target.M8,        (object(), 1),                  None,         False,           TypeError),
    977. 

  977.     
    978. 

  978.          # no types can be inferred, error
    979. 

  979.          # public static PythonTuple M9<T0, T1>(object x, T1 y) where T0 : T1
    980. 

  980.          # public static PythonTuple M9b<T0, T1>(T0 x, object y) where T0 : T1
    981. 

  981.          # public static PythonType M11<T>(object x)
    982. 

  982.          # public static PythonType M12<T0, T1>(T0 x, object y)     
    983. 

  983.          (target.M9,        (1, 2),                         None,         False,           TypeError),
    984. 

  984.          (target.M9b,       (1, 2),                         None,         False,           TypeError),
    985. 

  985.          (target.M9,        (object(), object()),           None,        True,             TypeError),
    986. 

  986.          (target.M9b,       (object(), object()),           None,        True,             TypeError),
    987. 

  987.          (target.M11,       (1, ),                          None,         False,           TypeError),
    988. 

  988.          (target.M12,       (1, 2),                         None,         False,           TypeError),
    989. 

  989.          
    990. 

  990.          # multiple dependent constraints
    991. 

  991.          # public static PythonTuple M10<T0, T1, T2>(T0 x, T1 y, T2 z) where T0 : T1 where T1 : T2 -> (pytype(T0), pytype(T1), pytype(T2))
    992. 

  992.          (target.M10,        (ArgumentException(), Exception(), object()), (ArgumentException, Exception, object),False,           None),
    993. 

  993.          (target.M10,        (Exception(), ArgumentException(), object()), None,False,           TypeError),
    994. 

  994.          (target.M10,        (ArgumentException(), object(), Exception()), None,False,           TypeError),
    995. 

  995.          (target.M10,        (object(), ArgumentException(), Exception()), None,False,           TypeError),
    996. 

  996.          (target.M10,        (object(), Exception(), ArgumentException()), None,False,           TypeError),     
    997. 

  997.          
    998. 

  998.          # public static PythonType M11<T>(object x) -> pytypeof(T)
    999. 

  999.          # public static PythonType M12<T0, T1>(T0 x, object y) -> pytypeof(T0)
    1000. 

  1000.          (target.M11,       (object(), ),                   None,       True,             TypeError),
    1001. 

  1001.          (target.M12,       (3, object()),                  None,       True,             TypeError),     
    1002. 

  1002.          
    1003. 

  1003.          # public static PythonType M13<T>(T x, Func<T> y) -> pytype(T), func()
    1004. 

  1004.          # public static PythonType M14<T>(T x, Action<T> y) -> pytype(T)
    1005. 

  1005.          # public static PythonTuple M15<T>(T x, IList<T> y) -> pytype, list...
    1006. 

  1006.          # public static PythonType M16<T>(T x, Dictionary<T, IList<T>> list) -> pytype, listKeys...
    1007. 

  1007.          (target.M13,       (1, lambda: 42),               (object, 42),    False,           None),
    1008. 

  1008.          (target.M14,       (1, lambda x: None),           object,          False,           None),
    1009. 

  1009.          (target.M15,       (1, [2, ]),                     (object, 2),     True,           None),
    1010. 

  1010.          (target.M15,       (1, (2, )),                     (object, 2),     True,           None),
    1011. 

  1011.          (target.M15,       (1, objArray),                  (object, 1,2,3), True,           None),
    1012. 

  1012.          (target.M15,       (1, doubleArray),               None,            True,           TypeError),
    1013. 

  1013.          (target.M16,       (1, {1: [1,2]}),               None,             False,         TypeError),
    1014. 

  1014.     
    1015. 

  1015.          # public static PythonType M17<T>(T x, IEnumerable<T> y) -> pytype(T)
    1016. 

  1016.          (target.M17,       (SelfEnumerable(), SelfEnumerable()), SelfEnumerable,    True,  None),
    1017. 

  1017.          (target.M17,       (1, [1,2,3]),                  object,           True,         None),
    1018. 

  1018.          (target.M17,       (1.0, [1,2,3]),                object,         …
    1019.

Large files files are truncated, but you can click here to view the full file