x=13

def f():

return x

z = 8

if a < b:

return c

elif c < 5 :

return a + b

else:

def f0(self): return 0

def f1(self, a): return 1

def f2(self, a, b): return 2

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

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

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

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

def test_basics(self):

self.assertTrue(x(1,2,10) == 10)

self.assertTrue(x(2,1,4) == 3)

self.assertTrue(x(1,1,10) == 8)

def f():

pass

f.a = 10

self.assertTrue(f.a == 10)

self.assertEqual(f.__module__, __name__)

def g():

g.a = 20

g()

self.assertTrue(g.a == 20)

def foo(): pass

self.assertEqual(foo.__code__.co_filename.lower().endswith('test_function.py'), True)

self.assertEqual(foo.__code__.co_firstlineno, 66) # if you added lines to the top of this file you need to update this number.

def test_inherit_function(self):

def foo(): pass

# Cannot inherit from a function

def CreateSubType(t):

class SubType(t): pass

return SubType

self.assertRaisesRegexp(TypeError, ".*\n?.* is not an acceptable base type", CreateSubType, type(foo))

def test_varargs(self):

def a(*args): return args

def b(*args): return a(*args)

self.assertEqual(b(1,2,3), (1,2,3))

def test_default_values(self):

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

z = 8

if a < b:

return c

elif c < 5 :

return a + b

else:

return z

self.assertEqual(x,x)

self.assertEqual(xwd(), 3)

self.assertRaises(TypeError, (lambda:x()))

self.assertEqual(xwd(2), 3)

self.assertRaises(TypeError, (lambda:x(1)))

self.assertEqual(xwd(0,5), 3)

self.assertRaises(TypeError, (lambda:x(0,5)))

self.assertEqual( (x == "not-a-Function3"), False)

def test_missin_params(self):

def y(a,b,c,d):

return a+b+c+d

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

return a+b+c+d

self.assertEqual(y, y)

self.assertEqual(ywd(), 6)

self.assertRaises(TypeError, y)

self.assertEqual(ywd(4), 10)

self.assertRaises(TypeError, y, 4)

self.assertEqual(ywd(4,5), 14)

self.assertRaises(TypeError, y, 4, 5)

self.assertEqual(ywd(4,5,6), 18)

self.assertRaises(TypeError, y, 4,5,6)

self.assertEqual( (y == "not-a-Function4"), False)

def test__doc__(self):

def foo(): "hello world"

self.assertEqual(foo.__doc__, 'hello world')

def test_coverage(self):

# function5

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

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

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

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

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

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

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

self.assertRaises(TypeError, f, 1, 1, 1, 1, 1, 1) # 6 args

self.assertEqual(f(10,11,12,13,14), 10 * 11 * 12 * 13 * 14) # 5 args

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

self.assertEqual(f(10,11,12,13), 10 * 11 * 12 * 13 * 5) # 4 args

for f in (f6,):

self.assertRaises(TypeError, f, 1, 1, 1, 1)

for f in (f1, f2, f3, f4):

self.assertEqual(f(10,11,12), 10 * 11 * 12 * 4 * 5) # 3 args

for f in (f5, f6):

self.assertRaises(TypeError, f, 1, 1, 1)

for f in (f1, f2, f3):

self.assertEqual(f(10,11), 10 * 11 * 3 * 4 * 5) # 2 args

for f in (f4, f5, f6):

self.assertRaises(TypeError, f, 1, 1)

for f in (f1, f2):

self.assertEqual(f(10), 10 * 2 * 3 * 4 * 5) # 1 args

for f in (f3, f4, f5, f6):

self.assertRaises(TypeError, f, 1)

for f in (f1,):

self.assertEqual(f(), 1 * 2 * 3 * 4 * 5) # no args

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

self.assertRaises(TypeError, f)

def test_class_method(self):

# method

class C2: pass

c1, c2 = C1(), C2()

line = ""

for i in range(8):

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

line += "self.assertEqual(c1.f%d(%s), %d)\n" % (i, args, i)

line += "self.assertEqual(C1.f%d(c1,%s), %d)\n" % (i, args, i)

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

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

#print line

exec(line)

def test_set_attr_instance_method(self):

C1.f0.attr = 1

self.assertEqual(C1.f0.attr, 1)

self.assertEqual(dir(C1.f0).__contains__("attr"), True)

self.assertEqual(C1.f0.__module__, __name__)

def test_kwargs(self):

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

return (x, y, z), args, kws

self.assertTrue(f(10, l=20) == ((10, 10, 20), (), {'l': 20}))

self.assertTrue(f(1, *(2,), **{'z':20}) == ((1, 2, 20), (), {}))

self.assertTrue(f(*[1,2,3]) == ((1, 2, 3), (), {}))

def a(*args, **kws): return args, kws

def b(*args, **kws):

return a(*args, **kws)

self.assertTrue(b(1,2,3, x=10, y=20) == ((1, 2, 3), {'y': 20, 'x': 10}))

def b(*args, **kws):

return a(**kws)

self.assertTrue(b(1,2,3, x=10, y=20) == ((), {'y': 20, 'x': 10}))

try:

b(**[])

self.assertTrue(False)

except TypeError:

pass

def f(x, *args):

return (x, args)

self.assertEqual(f(1, *[2]), (1, (2,)))

self.assertEqual(f(7, *(i for i in range(3))), (7, (0, 1, 2,)))

self.assertEqual(f(9, *range(11, 13)), (9, (11, 12)))

def test_sorted_kwargs(self):

"""verify we can call sorted w/ keyword args"""

import operator

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

getcount = operator.itemgetter(1)

sorted_inventory = sorted(inventory, key=getcount)

def test_kwargs2(self):

"""verify proper handling of keyword args for python functions"""

def kwfunc(a,b,c): pass

try:

kwfunc(10, 20, b=30)

self.assertTrue(False)

except TypeError:

pass

try:

kwfunc(10, None, b=30)

self.assertTrue(False)

except TypeError:

pass

try:

kwfunc(10, None, 40, b=30)

self.assertTrue(False)

except TypeError:

pass

if is_cli:

import System

# Test Hashtable and Dictionary.

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

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

for ht in htlist:

def foo(**kwargs):

return kwargs['key']

ht['key'] = 'xyz'

self.assertEqual(foo(**ht), 'xyz')

def foo(a,b):

return a-b

self.assertEqual(foo(b=1, *(2,)), 1)

# kw-args passed to init through method instance

s = self

class foo:

def __init__(self, group=None, target=None):

s.assertEqual(group, None)

s.assertEqual(target,'baz')

a = foo(target='baz')

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

@skipUnlessIronPython()

def test_params_method_no_params(self):

"""call a params method w/ no params"""

import clr

import System

self.assertEqual('abc\ndef'.Split()[0], 'abc')

self.assertEqual('abc\ndef'.Split()[1], 'def')

x = 'a bc def'.Split()

self.assertEqual(x[0], 'a')

self.assertEqual(x[1], 'bc')

self.assertEqual(x[2], '')

self.assertEqual(x[3], '')

self.assertEqual(x[4], 'def')

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

# an OpsExtensibleType and doesn't define __str__ on this

# overload

self.assertEqual(System.Double.ToString(1.0, 'f', System.Globalization.CultureInfo.InvariantCulture), '1.00')

def test_incorrect_number_of_args(self):

"""Incorrect number of arguments"""

def f(a): pass

if is_cli:

self.assertRaisesMessage(TypeError, "f() takes exactly 1 argument (0 given)", f)

self.assertRaisesMessage(TypeError, "f() takes exactly 1 argument (3 given)", f, 1, 2, 3)

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", f)

self.assertRaisesMessage(TypeError, "f() takes 1 positional argument but 3 were given", f, 1, 2, 3)

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=2)

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=2)

#self.assertRaises calls f(*args), which generates a different AST than f(1,2,3)

if is_cli:

self.assertRaisesMessage(TypeError, "f() takes exactly 1 argument (0 given)", lambda:f())

self.assertRaisesMessage(TypeError, "f() takes exactly 1 argument (3 given)", lambda:f(1, 2, 3))

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", lambda:f())

self.assertRaisesMessage(TypeError, "f() takes 1 positional argument but 3 were given", lambda:f(1, 2, 3))

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(dummy=2))

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(1, dummy=2))

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

if is_cli:

self.assertRaisesMessage(TypeError, "f() takes exactly 10 arguments (0 given)", f)

self.assertRaisesMessage(TypeError, "f() takes exactly 10 arguments (3 given)", f, 1, 2, 3)

else:

self.assertRaisesMessage(TypeError, "f() missing 10 required positional arguments: 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', and 'j'", f)

self.assertRaisesMessage(TypeError, "f() missing 7 required positional arguments: 'd', 'e', 'f', 'g', 'h', 'i', and 'j'", f, 1, 2, 3)

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=2)

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=2)

if is_cli:

self.assertRaisesMessage(TypeError, "f() takes exactly 10 arguments (0 given)", lambda:f())

self.assertRaisesMessage(TypeError, "f() takes exactly 10 arguments (3 given)", lambda:f(1, 2, 3))

else:

self.assertRaisesMessage(TypeError, "f() missing 10 required positional arguments: 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', and 'j'", lambda:f())

self.assertRaisesMessage(TypeError, "f() missing 7 required positional arguments: 'd', 'e', 'f', 'g', 'h', 'i', and 'j'", lambda:f(1, 2, 3))

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(dummy=2))

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(1, dummy=2))

def f(a, b=2): pass

if is_cli:

self.assertRaisesMessage(TypeError, "f() takes at least 1 argument (0 given)", f)

self.assertRaisesMessage(TypeError, "f() takes at most 2 arguments (3 given)", f, 1, 2, 3)

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", f)

self.assertRaisesMessage(TypeError, "f() takes from 1 to 2 positional arguments but 3 were given", f, 1, 2, 3)

if is_cli: #CPython bug 9326

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

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", f, b=2)

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=3)

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, b=2, dummy=3)

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, 1, dummy=3)

if is_cli:

self.assertRaisesMessage(TypeError, "f() takes at least 1 argument (0 given)", lambda:f())

self.assertRaisesMessage(TypeError, "f() takes at most 2 arguments (3 given)", lambda:f(1, 2, 3))

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", lambda:f())

self.assertRaisesMessage(TypeError, "f() takes from 1 to 2 positional arguments but 3 were given", lambda:f(1, 2, 3))

if is_cli: #CPython bug 9326

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

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", lambda:f(b=2))

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(dummy=3))

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

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(1, dummy=3))

def f(a, *argList): pass

if is_cli:

self.assertRaisesMessage(TypeError, "f() takes at least 1 argument (0 given)", f)

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", f)

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, dummy=2)

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", f, 1, dummy=2)

if is_cli:

self.assertRaisesMessage(TypeError, "f() takes at least 1 argument (0 given)", lambda:f())

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", lambda:f())

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(dummy=2))

self.assertRaisesMessage(TypeError, "f() got an unexpected keyword argument 'dummy'", lambda:f(1, dummy=2))

def f(a, **keywordDict): pass

if is_cli:

self.assertRaisesMessage(TypeError, "f() takes exactly 1 argument (0 given)", f)

self.assertRaisesMessage(TypeError, "f() takes exactly 1 argument (3 given)", f, 1, 2, 3)

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", f)

self.assertRaisesMessage(TypeError, "f() takes 1 positional argument but 3 were given", f, 1, 2, 3)

if is_cli: #CPython bug 9326

self.assertRaisesMessage(TypeError, "f() takes exactly 1 non-keyword argument (0 given)", f, dummy=2)

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

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", f, dummy=2)

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", f, dummy=2, dummy2=3)

if is_cli:

self.assertRaisesMessage(TypeError, "f() takes exactly 1 argument (0 given)", lambda:f())

self.assertRaisesMessage(TypeError, "f() takes exactly 1 argument (3 given)", lambda:f(1, 2, 3))

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", lambda:f())

self.assertRaisesMessage(TypeError, "f() takes 1 positional argument but 3 were given", lambda:f(1, 2, 3))

if is_cli: #CPython bug 9326

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

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

else:

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", lambda:f(dummy=2))

self.assertRaisesMessage(TypeError, "f() missing 1 required positional argument: 'a'", lambda:f(dummy=2, dummy2=3))

if is_cli:

self.assertRaisesMessage(TypeError, "abs() takes exactly 1 argument (0 given)", abs)

self.assertRaisesMessage(TypeError, "abs() takes exactly 1 argument (3 given)", abs, 1, 2, 3)

self.assertRaisesMessage(TypeError, "abs() got an unexpected keyword argument 'dummy'", abs, dummy=2)

self.assertRaisesMessage(TypeError, "abs() takes exactly 1 argument (2 given)", abs, 1, dummy=2)

self.assertRaisesMessage(TypeError, "abs() takes exactly 1 argument (0 given)", lambda:abs())

self.assertRaisesMessage(TypeError, "abs() takes exactly 1 argument (3 given)", lambda:abs(1, 2, 3))

self.assertRaisesMessage(TypeError, "abs() got an unexpected keyword argument 'dummy'", lambda:abs(dummy=2))

self.assertRaisesMessage(TypeError, "abs() takes exactly 1 argument (2 given)", lambda:abs(1, dummy=2))

else:

self.assertRaisesMessage(TypeError, "abs() takes exactly one argument (0 given)", abs)

self.assertRaisesMessage(TypeError, "abs() takes exactly one argument (3 given)", abs, 1, 2, 3)

self.assertRaisesMessage(TypeError, "abs() takes no keyword arguments", abs, dummy=2)

self.assertRaisesMessage(TypeError, "abs() takes no keyword arguments", abs, 1, dummy=2)

self.assertRaisesMessage(TypeError, "abs() takes exactly one argument (0 given)", lambda:abs())

self.assertRaisesMessage(TypeError, "abs() takes exactly one argument (3 given)", lambda:abs(1, 2, 3))

self.assertRaisesMessage(TypeError, "abs() takes no keyword arguments", lambda:abs(dummy=2))

self.assertRaisesMessage(TypeError, "abs() takes no keyword arguments", lambda:abs(1, dummy=2))

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

#self.assertRaisesMessage(TypeError, "list() takes at most 1 argument (2 given)", list, 1, 2)

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

#======== BUG 697 ===========

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

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

#self.assertRaisesMessage(TypeError, "complex() takes at most 2 arguments (3 given)", complex, 1, 2, 3)

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

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

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

#self.assertRaisesMessage(TypeError, "bool() takes at most 1 argument (2 given)", bool, 1, 2)

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

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

class UserClass(object): pass

if is_cli:

self.assertRaisesMessage(TypeError, "object.__new__() takes no parameters", UserClass, 1)

with self.assertRaisesMessage(TypeError, "object.__new__() takes no parameters"):

UserClass(*[], **dict({"dummy":2}))

else:

self.assertRaisesMessage(TypeError, "object() takes no parameters", UserClass, 1)

with self.assertRaisesMessage(TypeError, "object() takes no parameters"):

UserClass(*[], **dict({"dummy":2}))

class OldStyleClass: pass

if is_cli:

self.assertRaisesMessage(TypeError, "object.__new__() takes no parameters", OldStyleClass, 1)

with self.assertRaisesMessage(TypeError, "object.__new__() takes no parameters"):

OldStyleClass(*[], **dict({"dummy":2}))

else:

self.assertRaisesMessage(TypeError, "object() takes no parameters", OldStyleClass, 1)

with self.assertRaisesMessage(TypeError, "object() takes no parameters"):

OldStyleClass(*[], **dict({"dummy":2}))

@skipUnlessIronPython()

def test_runtime_type_checking(self):

"""accepts / returns runtype type checking tests"""

import clr

@clr.accepts(object)

def foo(x):

return x

self.assertEqual(foo('abc'), 'abc')

self.assertEqual(foo(2), 2)

self.assertEqual(foo(long(2)), long(2))

self.assertEqual(foo(2.0), 2.0)

self.assertEqual(foo(True), True)

@clr.accepts(str)

def foo(x):

return x

self.assertEqual(foo('abc'), 'abc')

self.assertRaises(AssertionError, foo, 2)

self.assertRaises(AssertionError, foo, long(2))

self.assertRaises(AssertionError, foo, 2.0)

self.assertRaises(AssertionError, foo, True)

@clr.accepts(str, bool)

def foo(x, y):

return x, y

self.assertEqual(foo('abc', True), ('abc', True))

self.assertRaises(AssertionError, foo, ('abc',2))

self.assertRaises(AssertionError, foo, ('abc',long(2)))

self.assertRaises(AssertionError, foo, ('abc',2.0))

class bar:

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

def foo(self, x):

return x

a = bar()

self.assertEqual(a.foo('xyz'), 'xyz')

self.assertRaises(AssertionError, a.foo, 2)

self.assertRaises(AssertionError, a.foo, long(2))

self.assertRaises(AssertionError, a.foo, 2.0)

self.assertRaises(AssertionError, a.foo, True)

@clr.returns(str)

def foo(x):

return x

self.assertEqual(foo('abc'), 'abc')

self.assertRaises(AssertionError, foo, 2)

self.assertRaises(AssertionError, foo, long(2))

self.assertRaises(AssertionError, foo, 2.0)

self.assertRaises(AssertionError, foo, True)

@clr.accepts(bool)

@clr.returns(str)

def foo(x):

if x: return str(x)

else: return 0

self.assertEqual(foo(True), 'True')

self.assertRaises(AssertionError, foo, 2)

self.assertRaises(AssertionError, foo, long(2))

self.assertRaises(AssertionError, foo, False)

@clr.returns(None)

def foo(): pass

self.assertEqual(foo(), None)

def test_error_message(self):

try:

repr()

except TypeError as e:

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

self.assertTrue(str(e).startswith("repr()"))

def test_caller_context(self):

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

def foo(*args):

return hasattr(*args)

self.assertEqual(foo('', 'index'), True)

@skipUnlessIronPython()

def test_dispatch_to_ReflectOptimized(self):

"""dispatch to a ReflectOptimized method"""

from iptest.console_util import IronPythonInstance

from System import Environment

from sys import executable

wkdir = self.test_dir

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

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

else:

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

if (ipi.Start()):

try:

result = ipi.ExecuteLine("from iptest.ipunittest import load_ironpython_test")

result = ipi.ExecuteLine("load_ironpython_test()")

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

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

self.assertEqual(response, '1184')

finally:

ipi.End()

def test_zip(self):

p = ((1, 2),)

self.assertEqual(list(zip(*(p * 10))), [(1, 1, 1, 1, 1, 1, 1, 1, 1, 1), (2, 2, 2, 2, 2, 2, 2, 2, 2, 2)])

self.assertEqual(list(zip(*(p * 10))), [(1, 1, 1, 1, 1, 1, 1, 1, 1, 1), (2, 2, 2, 2, 2, 2, 2, 2, 2, 2)])

def test_super(self):

class A(object): pass

class B(A): pass

#unbound super

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

self.assertEqual(x.__thisclass__, B)

self.assertEqual(x.__self__, None)

self.assertEqual(x.__self_class__, None)

# super w/ both types

x = super(B,B)

self.assertEqual(x.__thisclass__,B)

self.assertEqual(x.__self_class__, B)

self.assertEqual(x.__self__, B)

# super w/ type and instance

b = B()

x = super(B, b)

self.assertEqual(x.__thisclass__,B)

self.assertEqual(x.__self_class__, B)

self.assertEqual(x.__self__, b)

# super w/ mixed types

x = super(A,B)

self.assertEqual(x.__thisclass__,A)

self.assertEqual(x.__self_class__, B)

self.assertEqual(x.__self__, B)

# invalid super cases

try:

x = super(B, 'abc')

self.assertUnreachable()

except TypeError:

pass

try:

super(B,A)

self.assertUnreachable()

except TypeError:

pass

class A(object):

def __init__(self, name):

self.__name__ = name

def meth(self):

return self.__name__

classmeth = classmethod(meth)

class B(A): pass

b = B('derived')

self.assertEqual(super(B,b).__thisclass__.__name__, 'B')

self.assertEqual(super(B,b).__self__.__name__, 'derived')

self.assertEqual(super(B,b).__self_class__.__name__, 'B')

self.assertEqual(super(B,b).classmeth(), 'B')

# descriptor supper

class A(object):

def meth(self): return 'A'

class B(A):

def meth(self):

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

B._B__super = super(B)

b = B()

self.assertEqual(b.meth(), 'BA')

def test_class_method_calls(self):

"""class method should get correct meta class."""

class D(object):

@classmethod

def classmeth(cls): pass

self.assertEqual(D.classmeth.__class__, MethodType)

class MetaType(type): pass

class D(object, metaclass = MetaType):

@classmethod

def classmeth(cls): pass

self.assertEqual(D.classmeth.__class__, MethodType)

def test_cases(self):

def runTest(testCase):

class foo(testCase.subtype):

def __new__(cls, param):

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

self.assertTrue(ret == testCase.newEq)

self.assertTrue((ret != testCase.newEq) != True)

return ret

def __init__(self, param):

testCase.subtype.__init__(self, param)

self.assertTrue(self == testCase.initEq)

self.assertTrue((self != testCase.initEq) != True)

a = foo(testCase.param)

self.assertTrue((type(a) == foo) == testCase.match)

class TestCase(object):

__slots__ = ['subtype', 'newEq', 'initEq', 'match', 'param']

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

self.match = match

self.subtype = subtype

self.newEq = newEq

self.initEq = initEq

self.param = param

cases = [TestCase(int, 2, 2, True, 2),

TestCase(list, [], [2,3,4], True, (2,3,4)),

TestCase(deque, deque(), deque((2,3,4)), True, (2,3,4)),

TestCase(set, set(), set((2,3,4)), True, (2,3,4)),

TestCase(frozenset, frozenset((2,3,4)), frozenset((2,3,4)), True, (2,3,4)),

TestCase(tuple, (2,3,4), (2,3,4), True, (2,3,4)),

TestCase(str, 'abc', 'abc', True, 'abc'),

TestCase(float, 2.3, 2.3, True, 2.3),

TestCase(type, type(object), type(object), False, object),

TestCase(long, long(10000000000), long(10000000000), True, long(10000000000)),

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

# TestCase(file, 'abc', True), # ???

]

for case in cases:

runTest(case)

@unittest.skipIf(is_posix or is_netcoreapp, 'missing System.Windows.Forms support')

@skipUnlessIronPython()

def test_call_base_init(self):

"""verify we can call the base init directly"""

import clr

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

from System.Windows.Forms import Form

class MyForm(Form):

def __init__(self, title):

Form.__init__(self)

self.Text = title

a = MyForm('abc')

self.assertEqual(a.Text, 'abc')

def test_func_flags(self):

def foo0(): pass

def foo1(*args): pass

def foo2(**args): pass

def foo3(*args, **kwargs): pass

def foo4(a): pass

def foo5(a, *args): pass

def foo6(a, **args): pass

def foo7(a, *args, **kwargs): pass

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

def foo9(a,b): pass

self.assertEqual(foo0.__code__.co_flags & 12, 0)

self.assertEqual(foo1.__code__.co_flags & 12, 4)

self.assertEqual(foo2.__code__.co_flags & 12, 8)

self.assertEqual(foo3.__code__.co_flags & 12, 12)

self.assertEqual(foo4.__code__.co_flags & 12, 0)

self.assertEqual(foo5.__code__.co_flags & 12, 4)

self.assertEqual(foo6.__code__.co_flags & 12, 8)

self.assertEqual(foo7.__code__.co_flags & 12, 12)

self.assertEqual(foo8.__code__.co_flags & 12, 0)

self.assertEqual(foo9.__code__.co_flags & 12, 0)

self.assertEqual(foo0.__code__.co_argcount, 0)

self.assertEqual(foo1.__code__.co_argcount, 0)

self.assertEqual(foo2.__code__.co_argcount, 0)

self.assertEqual(foo3.__code__.co_argcount, 0)

self.assertEqual(foo4.__code__.co_argcount, 1)

self.assertEqual(foo5.__code__.co_argcount, 1)

self.assertEqual(foo6.__code__.co_argcount, 1)

self.assertEqual(foo7.__code__.co_argcount, 1)

self.assertEqual(foo8.__code__.co_argcount, 6)

self.assertEqual(foo9.__code__.co_argcount, 2)

def test_big_calls(self):

# check various function call sizes and boundaries

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]

# mono has a limitation of < 1023

if not is_mono:

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

for size in sizes:

d = {}

# w/o defaults

if size <= 255 or is_cli:

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

else:

with self.assertRaises(SyntaxError):

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

continue

# w/ defaults

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

if size <= 255 or is_cli:

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

exec('a = f(' + ', '.join([str(x) for x in range(size)]) + ')', d)

self.assertEqual(d["a"], tuple(range(size)))

exec('a = g()', d)

self.assertEqual(d["a"], tuple(range(size)))

exec('a = g(' + ', '.join([str(x) for x in range(size)]) + ')', d)

self.assertEqual(d["a"], tuple(range(size)))

exec('a = f(*(' + ', '.join([str(x) for x in range(size)]) + '))', d)

self.assertEqual(d["a"], tuple(range(size)))

def test_compile(self):

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

if is_cli:

self.assertEqual(x.co_flags & 8192, 0)

else:

self.assertEqual(x.co_flags & 8192, 8192)

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

self.assertEqual(eval(x), 2.0 / 3.0)

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

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

"longlonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglong",

"""

]

for name in names:

self.assertEqual(compile("print(2/3)", name, "exec", 8192).co_filename,

name)

def test_filename(self):

c = compile("x = 2", "test", "exec")

self.assertEqual(c.co_filename, 'test')

def test_name(self):

def f(): pass

f.__name__ = 'g'

self.assertEqual(f.__name__, 'g')

if is_cli:

self.assertTrue(repr(f).startswith('<function g'))

else:

self.assertTrue(repr(f).startswith('<function FunctionTest.test_name.<locals>.f'))

f.__qualname__ = 'x'

self.assertEqual(f.__qualname__, 'x')

if is_cli:

self.assertTrue(repr(f).startswith('<function g'))

else:

self.assertTrue(repr(f).startswith('<function x'))

def test_argcount(self):

def foo0(): pass

def foo1(*args): pass

def foo2(**args): pass

def foo3(*args, **kwargs): pass

def foo4(a): pass

def foo5(a, *args): pass

def foo6(a, **args): pass

def foo7(a, *args, **kwargs): pass

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

def foo9(a,b): pass

self.assertEqual(foo0.__code__.co_argcount, 0)

self.assertEqual(foo1.__code__.co_argcount, 0)

self.assertEqual(foo2.__code__.co_argcount, 0)

self.assertEqual(foo3.__code__.co_argcount, 0)

self.assertEqual(foo4.__code__.co_argcount, 1)

self.assertEqual(foo5.__code__.co_argcount, 1)

self.assertEqual(foo6.__code__.co_argcount, 1)

self.assertEqual(foo7.__code__.co_argcount, 1)

self.assertEqual(foo8.__code__.co_argcount, 6)

self.assertEqual(foo9.__code__.co_argcount, 2)

def test_defaults(self):

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

for default in defaults:

def helperFunc(): pass

self.assertEqual(helperFunc.__defaults__, None)

self.assertEqual(helperFunc.__defaults__, None)

def helperFunc1(a): pass

self.assertEqual(helperFunc1.__defaults__, None)

self.assertEqual(helperFunc1.__defaults__, None)

def helperFunc2(a=default): pass