# -*- coding: utf-8 -*-
"""Test CLR generics support."""
import clr
import System
import pytest
def assert_generic_wrapper_by_type(ptype, value):
"""Test Helper"""
from Python.Test import GenericWrapper
import System
inst = GenericWrapper[ptype](value)
assert inst.value == value
atype = System.Array[ptype]
items = atype([value, value, value])
inst = GenericWrapper[atype](items)
assert len(inst.value) == 3
assert inst.value[0] == value
assert inst.value[1] == value
def assert_generic_method_by_type(ptype, value, test_type=0):
"""Test Helper"""
from Python.Test import GenericMethodTest, GenericStaticMethodTest
import System
itype = GenericMethodTest[System.Type]
stype = GenericStaticMethodTest[System.Type]
# Explicit selection (static method)
result = stype.Overloaded[ptype](value)
if test_type:
assert result.__class__ == value.__class__
else:
assert result == value
# Type inference (static method)
result = stype.Overloaded(value)
assert result == value
if test_type:
assert result.__class__ == value.__class__
else:
assert result == value
# Explicit selection (instance method)
result = itype().Overloaded[ptype](value)
assert result == value
if test_type:
assert result.__class__ == value.__class__
else:
assert result == value
# Type inference (instance method)
result = itype().Overloaded(value)
assert result == value
if test_type:
assert result.__class__ == value.__class__
else:
assert result == value
atype = System.Array[ptype]
items = atype([value, value, value])
# Explicit selection (static method)
result = stype.Overloaded[atype](items)
if test_type:
assert len(result) == 3
assert result[0].__class__ == value.__class__
assert result[1].__class__ == value.__class__
else:
assert len(result) == 3
assert result[0] == value
assert result[1] == value
# Type inference (static method)
result = stype.Overloaded(items)
if test_type:
assert len(result) == 3
assert result[0].__class__ == value.__class__
assert result[1].__class__ == value.__class__
else:
assert len(result) == 3
assert result[0] == value
assert result[1] == value
# Explicit selection (instance method)
result = itype().Overloaded[atype](items)
if test_type:
assert len(result) == 3
assert result[0].__class__ == value.__class__
assert result[1].__class__ == value.__class__
else:
assert len(result) == 3
assert result[0] == value
assert result[1] == value
# Type inference (instance method)
result = itype().Overloaded(items)
if test_type:
assert len(result) == 3
assert result[0].__class__ == value.__class__
assert result[1].__class__ == value.__class__
else:
assert len(result) == 3
assert result[0] == value
assert result[1] == value
def test_python_type_aliasing():
"""Test python type alias support with generics."""
from System.Collections.Generic import Dictionary
dict_ = Dictionary[str, str]()
assert dict_.Count == 0
dict_.Add("one", "one")
assert dict_["one"] == "one"
dict_ = Dictionary[System.String, System.String]()
assert dict_.Count == 0
dict_.Add("one", "one")
assert dict_["one"] == "one"
dict_ = Dictionary[int, int]()
assert dict_.Count == 0
dict_.Add(1, 1)
assert dict_[1] == 1
dict_ = Dictionary[System.Int32, System.Int32]()
assert dict_.Count == 0
dict_.Add(1, 1)
assert dict_[1] == 1
dict_ = Dictionary[int, int]()
assert dict_.Count == 0
dict_.Add(1, 1)
assert dict_[1] == 1
dict_ = Dictionary[System.Int64, System.Int64]()
assert dict_.Count == 0
dict_.Add(1, 1)
assert dict_[1] == 1
dict_ = Dictionary[float, float]()
assert dict_.Count == 0
dict_.Add(1.5, 1.5)
assert dict_[1.5] == 1.5
dict_ = Dictionary[System.Double, System.Double]()
assert dict_.Count == 0
dict_.Add(1.5, 1.5)
assert dict_[1.5] == 1.5
dict_ = Dictionary[bool, bool]()
assert dict_.Count == 0
dict_.Add(True, False)
assert dict_[True] is False
dict_ = Dictionary[System.Boolean, System.Boolean]()
assert dict_.Count == 0
dict_.Add(True, False)
assert dict_[True] is False
def test_generic_reference_type():
"""Test usage of generic reference type definitions."""
from Python.Test import GenericTypeDefinition
inst = GenericTypeDefinition[System.String, System.Int32]("one", 2)
assert inst.value1 == "one"
assert inst.value2 == 2
def test_generic_value_type():
"""Test usage of generic value type definitions."""
from System import Int32
from Python.Test import GenericStructConstructorTest
ob = GenericStructConstructorTest[Int32](42)
assert ob.Value == 42
def test_nullable():
"""Test usage of Nullable[T] (special runtime handling)."""
inst = System.Nullable[System.Int32](10)
assert inst.HasValue
assert inst.Value == 10
with pytest.raises(TypeError):
inst = System.Nullable[System.Int32]()
def test_generic_interface():
# TODO NotImplemented
pass
def test_generic_delegate():
# TODO NotImplemented
pass
def test_open_generic_type():
"""Test behavior of reflected open constructed generic types."""
from Python.Test import DerivedFromOpenGeneric
open_generic_type = DerivedFromOpenGeneric.__bases__[0]
with pytest.raises(TypeError):
_ = open_generic_type()
with pytest.raises(TypeError):
_ = open_generic_type[System.String]
def test_derived_from_open_generic_type():
"""Test a generic type derived from an open generic type."""
from Python.Test import DerivedFromOpenGeneric
type_ = DerivedFromOpenGeneric[System.String, System.String]
inst = type_(1, 'two', 'three')
assert inst.value1 == 1
assert inst.value2 == 'two'
assert inst.value3 == 'three'
def test_generic_type_name_resolution():
"""Test the ability to disambiguate generic type names."""
from Python.Test import GenericNameTest1, GenericNameTest2
# If both a non-generic and generic type exist for a name, the
# unadorned name always resolves to the non-generic type.
_class = GenericNameTest1
assert _class().value == 0
assert _class.value == 0
# If no non-generic type exists for a name, the unadorned name
# cannot be instantiated. It can only be used to bind a generic.
with pytest.raises(TypeError):
_ = GenericNameTest2()
_class = GenericNameTest2[int]
assert _class().value == 1
assert _class.value == 1
_class = GenericNameTest2[int, int]
assert _class().value == 2
assert _class.value == 2
def test_generic_type_binding():
"""Test argument conversion / binding for generic methods."""
from Python.Test import InterfaceTest, ISayHello1, ShortEnum
import System
assert_generic_wrapper_by_type(System.Boolean, True)
assert_generic_wrapper_by_type(bool, True)
assert_generic_wrapper_by_type(System.Byte, 255)
assert_generic_wrapper_by_type(System.SByte, 127)
assert_generic_wrapper_by_type(System.Char, u'A')
assert_generic_wrapper_by_type(System.Int16, 32767)
assert_generic_wrapper_by_type(System.Int32, 2147483647)
assert_generic_wrapper_by_type(int, 2147483647)
assert_generic_wrapper_by_type(System.Int64, 9223372036854775807)
assert_generic_wrapper_by_type(System.UInt16, 65000)
assert_generic_wrapper_by_type(System.UInt32, 4294967295)
assert_generic_wrapper_by_type(System.UInt64, 18446744073709551615)
assert_generic_wrapper_by_type(System.Single, System.Single(3.402823e38))
assert_generic_wrapper_by_type(System.Double, 1.7976931348623157e308)
assert_generic_wrapper_by_type(float, 1.7976931348623157e308)
assert_generic_wrapper_by_type(System.Decimal, System.Decimal.One)
assert_generic_wrapper_by_type(System.String, "test")
assert_generic_wrapper_by_type(str, "test")
assert_generic_wrapper_by_type(ShortEnum, ShortEnum.Zero)
assert_generic_wrapper_by_type(System.Object, InterfaceTest())
assert_generic_wrapper_by_type(InterfaceTest, InterfaceTest())
assert_generic_wrapper_by_type(ISayHello1, InterfaceTest())
def test_generic_method_binding():
from Python.Test import GenericMethodTest, GenericStaticMethodTest
from System import InvalidOperationException
# Can invoke a static member on a closed generic type.
value = GenericStaticMethodTest[str].Overloaded()
assert value == 1
with pytest.raises(InvalidOperationException):
# Cannot invoke a static member on an open type.
GenericStaticMethodTest.Overloaded()
# Can invoke an instance member on a closed generic type.
value = GenericMethodTest[str]().Overloaded()
assert value == 1
with pytest.raises(TypeError):
# Cannot invoke an instance member on an open type,
# because the open type cannot be instantiated.
GenericMethodTest().Overloaded()
def test_generic_method_type_handling():
"""Test argument conversion / binding for generic methods."""
from Python.Test import InterfaceTest, ISayHello1, ShortEnum
import System
# FIXME: Fails because Converter.GetTypeByAlias returns int32 for any integer, including ulong
# assert_generic_method_by_type(System.UInt64, 18446744073709551615)
assert_generic_method_by_type(System.Boolean, True)
assert_generic_method_by_type(bool, True)
assert_generic_method_by_type(System.Byte, 255)
assert_generic_method_by_type(System.SByte, 127)
assert_generic_method_by_type(System.Char, u'A')
assert_generic_method_by_type(System.Int16, 32767)
assert_generic_method_by_type(System.Int32, 2147483647)
assert_generic_method_by_type(int, 2147483647)
assert_generic_method_by_type(System.UInt16, 65000)
assert_generic_method_by_type(System.Single, System.Single(3.402823e38))
assert_generic_method_by_type(System.Double, 1.7976931348623157e308)
assert_generic_method_by_type(float, 1.7976931348623157e308)
assert_generic_method_by_type(System.Decimal, System.Decimal.One)
assert_generic_method_by_type(System.String, "test")
assert_generic_method_by_type(str, "test")
assert_generic_method_by_type(ShortEnum, ShortEnum.Zero)
assert_generic_method_by_type(System.Object, InterfaceTest())
assert_generic_method_by_type(InterfaceTest, InterfaceTest(), 1)
def test_correct_overload_selection():
"""Test correct overloading selection for common types."""
from System import (String, Double, Single,
Int16, Int32, Int64)
from System import Math
substr = String("substring")
assert substr.Substring(2) == substr.Substring.__overloads__[Int32](
Int32(2))
assert substr.Substring(2, 3) == substr.Substring.__overloads__[Int32, Int32](
Int32(2), Int32(3))
for atype, value1, value2 in zip([Double, Single, Int16, Int32, Int64],
[1.0, 1.0, 1, 1, 1],
[2.0, 0.5, 2, 0, -1]):
assert Math.Abs(atype(value1)) == Math.Abs.__overloads__[atype](atype(value1))
assert Math.Abs(value1) == Math.Abs.__overloads__[atype](atype(value1))
assert Math.Max(atype(value1),
atype(value2)) == Math.Max.__overloads__[atype, atype](
atype(value1), atype(value2))
assert Math.Max(atype(value1),
value2) == Math.Max.__overloads__[atype, atype](
atype(value1), atype(value2))
clr.AddReference("System.Runtime.InteropServices")
from System.Runtime.InteropServices import GCHandle, GCHandleType
from System import Array, Byte
cs_array = Array.CreateInstance(Byte, 1000)
handler = GCHandle.Alloc(cs_array, GCHandleType.Pinned)
def test_generic_method_overload_selection():
"""Test explicit overload selection with generic methods."""
from Python.Test import GenericMethodTest, GenericStaticMethodTest
type = GenericStaticMethodTest[str]
inst = GenericMethodTest[str]()
# public static int Overloaded()
value = type.Overloaded()
assert value == 1
# public int Overloaded()
value = inst.Overloaded()
assert value == 1
# public static T Overloaded(T arg) (inferred)
value = type.Overloaded("test")
assert value == "test"
# public T Overloaded(T arg) (inferred)
value = inst.Overloaded("test")
assert value == "test"
# public static T Overloaded(T arg) (explicit)
value = type.Overloaded[str]("test")
assert value == "test"
# public T Overloaded(T arg) (explicit)
value = inst.Overloaded[str]("test")
assert value == "test"
# public static Q Overloaded(Q arg)
value = type.Overloaded[float](2.2)
assert value == 2.2
# public Q Overloaded(Q arg)
value = inst.Overloaded[float](2.2)
assert value == 2.2
# public static Q Overloaded(Q arg)
value = type.Overloaded[bool](True)
assert value is True
# public Q Overloaded(Q arg)
value = inst.Overloaded[bool](True)
assert value is True
# public static U Overloaded(Q arg1, U arg2)
value = type.Overloaded[bool, str](True, "true")
assert value == "true"
# public U Overloaded(Q arg1, U arg2)
value = inst.Overloaded[bool, str](True, "true")
assert value == "true"
# public static U Overloaded(Q arg1, U arg2)
value = type.Overloaded[str, bool]("true", True)
assert value is True
# public U Overloaded(Q arg1, U arg2)
value = inst.Overloaded[str, bool]("true", True)
assert value is True
# public static string Overloaded(int arg1, int arg2, string arg3)
value = type.Overloaded[str](123, 456, "success")
assert value == "success"
# public string Overloaded(int arg1, int arg2, string arg3)
value = inst.Overloaded[str](123, 456, "success")
assert value == "success"
with pytest.raises(TypeError):
_ = type.Overloaded[str, bool, int]("true", True, 1)
with pytest.raises(TypeError):
_ = inst.Overloaded[str, bool, int]("true", True, 1)
def test_method_overload_selection_with_generic_types():
"""Check method overload selection using generic types."""
from Python.Test import ISayHello1, InterfaceTest, ShortEnum
from Python.Test import MethodTest, GenericWrapper
inst = InterfaceTest()
vtype = GenericWrapper[System.Boolean]
input_ = vtype(True)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value is True
vtype = GenericWrapper[bool]
input_ = vtype(True)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value is True
vtype = GenericWrapper[System.Byte]
input_ = vtype(255)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 255
vtype = GenericWrapper[System.SByte]
input_ = vtype(127)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 127
vtype = GenericWrapper[System.Char]
input_ = vtype(u'A')
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == u'A'
vtype = GenericWrapper[System.Char]
input_ = vtype(65535)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == chr(65535)
vtype = GenericWrapper[System.Int16]
input_ = vtype(32767)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 32767
vtype = GenericWrapper[System.Int32]
input_ = vtype(2147483647)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 2147483647
vtype = GenericWrapper[int]
input_ = vtype(2147483647)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 2147483647
vtype = GenericWrapper[System.Int64]
input_ = vtype(9223372036854775807)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 9223372036854775807
vtype = GenericWrapper[System.UInt16]
input_ = vtype(65000)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 65000
vtype = GenericWrapper[System.UInt32]
input_ = vtype(4294967295)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 4294967295
vtype = GenericWrapper[System.UInt64]
input_ = vtype(18446744073709551615)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 18446744073709551615
vtype = GenericWrapper[System.Single]
input_ = vtype(3.402823e38)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == System.Single(3.402823e38)
vtype = GenericWrapper[System.Double]
input_ = vtype(1.7976931348623157e308)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 1.7976931348623157e308
vtype = GenericWrapper[float]
input_ = vtype(1.7976931348623157e308)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == 1.7976931348623157e308
vtype = GenericWrapper[System.Decimal]
input_ = vtype(System.Decimal.One)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == System.Decimal.One
vtype = GenericWrapper[System.String]
input_ = vtype("spam")
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == "spam"
vtype = GenericWrapper[str]
input_ = vtype("spam")
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == "spam"
vtype = GenericWrapper[ShortEnum]
input_ = vtype(ShortEnum.Zero)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value == ShortEnum.Zero
vtype = GenericWrapper[System.Object]
input_ = vtype(inst)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value.__class__ == inst.__class__
vtype = GenericWrapper[InterfaceTest]
input_ = vtype(inst)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value.__class__ == inst.__class__
iface_class = ISayHello1(inst).__class__
vtype = GenericWrapper[ISayHello1]
input_ = vtype(inst)
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value.value.__class__ == iface_class
vtype = System.Array[GenericWrapper[int]]
input_ = vtype([GenericWrapper[int](0), GenericWrapper[int](1)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 0
assert value[1].value == 1
def test_overload_selection_with_arrays_of_generic_types():
"""Check overload selection using arrays of generic types."""
from Python.Test import ISayHello1, InterfaceTest, ShortEnum
from Python.Test import MethodTest, GenericWrapper
inst = InterfaceTest()
gtype = GenericWrapper[System.Boolean]
vtype = System.Array[gtype]
input_ = vtype([gtype(True), gtype(True)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value is True
assert value.Length == 2
gtype = GenericWrapper[bool]
vtype = System.Array[gtype]
input_ = vtype([gtype(True), gtype(True)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value is True
assert value.Length == 2
gtype = GenericWrapper[System.Byte]
vtype = System.Array[gtype]
input_ = vtype([gtype(255), gtype(255)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 255
assert value.Length == 2
gtype = GenericWrapper[System.SByte]
vtype = System.Array[gtype]
input_ = vtype([gtype(127), gtype(127)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 127
assert value.Length == 2
gtype = GenericWrapper[System.Char]
vtype = System.Array[gtype]
input_ = vtype([gtype(u'A'), gtype(u'A')])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == u'A'
assert value.Length == 2
gtype = GenericWrapper[System.Char]
vtype = System.Array[gtype]
input_ = vtype([gtype(65535), gtype(65535)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == chr(65535)
assert value.Length == 2
gtype = GenericWrapper[System.Int16]
vtype = System.Array[gtype]
input_ = vtype([gtype(32767), gtype(32767)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 32767
assert value.Length == 2
gtype = GenericWrapper[System.Int32]
vtype = System.Array[gtype]
input_ = vtype([gtype(2147483647), gtype(2147483647)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 2147483647
assert value.Length == 2
gtype = GenericWrapper[int]
vtype = System.Array[gtype]
input_ = vtype([gtype(2147483647), gtype(2147483647)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 2147483647
assert value.Length == 2
gtype = GenericWrapper[System.Int64]
vtype = System.Array[gtype]
input_ = vtype([gtype(9223372036854775807),
gtype(9223372036854775807)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 9223372036854775807
assert value.Length == 2
gtype = GenericWrapper[System.UInt16]
vtype = System.Array[gtype]
input_ = vtype([gtype(65000), gtype(65000)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 65000
assert value.Length == 2
gtype = GenericWrapper[System.UInt32]
vtype = System.Array[gtype]
input_ = vtype([gtype(4294967295), gtype(4294967295)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 4294967295
assert value.Length == 2
gtype = GenericWrapper[System.UInt64]
vtype = System.Array[gtype]
input_ = vtype([gtype(18446744073709551615),
gtype(18446744073709551615)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 18446744073709551615
assert value.Length == 2
gtype = GenericWrapper[System.Single]
vtype = System.Array[gtype]
input_ = vtype([gtype(3.402823e38), gtype(3.402823e38)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == System.Single(3.402823e38)
assert value.Length == 2
gtype = GenericWrapper[System.Double]
vtype = System.Array[gtype]
input_ = vtype([gtype(1.7976931348623157e308),
gtype(1.7976931348623157e308)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 1.7976931348623157e308
assert value.Length == 2
gtype = GenericWrapper[float]
vtype = System.Array[gtype]
input_ = vtype([gtype(1.7976931348623157e308),
gtype(1.7976931348623157e308)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == 1.7976931348623157e308
assert value.Length == 2
gtype = GenericWrapper[System.Decimal]
vtype = System.Array[gtype]
input_ = vtype([gtype(System.Decimal.One),
gtype(System.Decimal.One)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == System.Decimal.One
assert value.Length == 2
gtype = GenericWrapper[System.String]
vtype = System.Array[gtype]
input_ = vtype([gtype("spam"), gtype("spam")])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == "spam"
assert value.Length == 2
gtype = GenericWrapper[str]
vtype = System.Array[gtype]
input_ = vtype([gtype("spam"), gtype("spam")])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == "spam"
assert value.Length == 2
gtype = GenericWrapper[ShortEnum]
vtype = System.Array[gtype]
input_ = vtype([gtype(ShortEnum.Zero), gtype(ShortEnum.Zero)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value == ShortEnum.Zero
assert value.Length == 2
gtype = GenericWrapper[System.Object]
vtype = System.Array[gtype]
input_ = vtype([gtype(inst), gtype(inst)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value.__class__ == inst.__class__
assert value.Length == 2
gtype = GenericWrapper[InterfaceTest]
vtype = System.Array[gtype]
input_ = vtype([gtype(inst), gtype(inst)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value.__class__ == inst.__class__
assert value.Length == 2
iface_class = ISayHello1(inst).__class__
gtype = GenericWrapper[ISayHello1]
vtype = System.Array[gtype]
input_ = vtype([gtype(inst), gtype(inst)])
value = MethodTest.Overloaded.__overloads__[vtype](input_)
assert value[0].value.__class__ == iface_class
assert value.Length == 2
def test_generic_overload_selection_magic_name_only():
"""Test using only __overloads__ to select on type & sig"""
# TODO NotImplemented
pass
def test_nested_generic_class():
"""Check nested generic classes."""
# TODO NotImplemented
pass
def test_missing_generic_type():
from System.Collections import IList
with pytest.raises(TypeError):
IList[bool]
# https://github.com/pythonnet/pythonnet/issues/1522
def test_overload_generic_parameter():
from Python.Test import MethodTest, MethodTestSub
inst = MethodTest()
generic = MethodTestSub()
inst.OverloadedConstrainedGeneric(generic)
inst.OverloadedConstrainedGeneric[MethodTestSub](generic)
inst.OverloadedConstrainedGeneric[MethodTestSub](generic, '42')
inst.OverloadedConstrainedGeneric[MethodTestSub](generic, System.String('42'))
def test_invalid_generic_type_parameter():
from Python.Test import GenericTypeWithConstraint
with pytest.raises(TypeError):
GenericTypeWithConstraint[System.Object]
def test_invalid_generic_method_type_parameter():
from Python.Test import ConversionTest
with pytest.raises(TypeError):
ConversionTest.Echo[System.Object]
def test_generic_list_array_conversion():
"""Test conversion of lists to generic array arguments."""
from Python.Test import GenericArrayConversionTest
from Python.Test import Spam
items = []
for i in range(10):
items.append(Spam(str(i)))
result = GenericArrayConversionTest.EchoRange[Spam](items)
assert result[0].__class__ == Spam
assert len(result) == 10
# Currently raises an exception because the correct generic type parameter is not inferred
with pytest.raises(TypeError):
result = GenericArrayConversionTest.EchoRange(items)
assert result[0].__class__ == Spam
assert len(result) == 10