From ba7794b616ea810a457cdbd4728077d085105319 Mon Sep 17 00:00:00 2001 From: Victor Uriarte Date: Fri, 13 Jan 2017 12:09:52 -0700 Subject: [PATCH 1/4] Add pytest to CI pytest on travis initially required `sudo=required` otherwise failed. Without the sudo flag pytest wasn't being upgraded. Needed to force upgrade. https://github.com/pytest-dev/pytest/issues/2240 --- .travis.yml | 6 ++++-- appveyor.yml | 2 +- ci/appveyor_run_tests.ps1 | 2 +- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index fd462ea6a..7043d4893 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,5 +1,6 @@ sudo: false +# language: csharp installs mono/dotnet but has limited python. language: python python: - 2.7 @@ -29,12 +30,13 @@ addons: - ca-certificates-mono install: - - pip install pycparser coverage codecov + - pip install --upgrade pycparser coverage codecov pytest + # setup.py install works too, but need to deal w Python.test then - coverage run setup.py build_ext --inplace script: - export PYTHONPATH=`pwd`:$PYTHONPATH - - python src/tests/runtests.py + - python -m pytest # - mono ./packages/NUnit.*/tools/nunit-console.exe src/embed_tests/bin/Python.EmbeddingTest.dll after_success: diff --git a/appveyor.yml b/appveyor.yml index fd5822ac9..6876bb442 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -48,7 +48,7 @@ init: install: # install for wheels & coverage - - pip install --upgrade pip wheel coverage codecov + - pip install --upgrade pip wheel coverage codecov pytest # Install OpenCover. Can't put on packages.config; not Linux/Mono compatible - .\tools\nuget\nuget.exe install OpenCover -OutputDirectory packages diff --git a/ci/appveyor_run_tests.ps1 b/ci/appveyor_run_tests.ps1 index 18005a047..974114cdb 100644 --- a/ci/appveyor_run_tests.ps1 +++ b/ci/appveyor_run_tests.ps1 @@ -14,7 +14,7 @@ $RUNTIME_DIR = ".\src\runtime\bin\" # why `2>&1 | %{ "$_" }`? see: http://stackoverflow.com/a/20950421/5208670 Write-Host ("Starting Python tests") -ForegroundColor "Green" .$OPENCOVER -register:user -searchdirs:"$RUNTIME_DIR" -output:py.coverage ` - -target:"$PY" -targetargs:src\tests\runtests.py ` + -target:"$PY" -targetargs:"-m pytest" ` -returntargetcode ` 2>&1 | %{ "$_" } $PYTHON_STATUS = $LastExitCode From 1ea29c71a4b1fec28fc90d9c4deff1305e5d7cdb Mon Sep 17 00:00:00 2001 From: Victor Uriarte Date: Sat, 14 Jan 2017 20:10:27 -0700 Subject: [PATCH 2/4] Convert unittest to pytest Needs local imports to work. Conversion done with unittests2pytests and a couple regex --- src/tests/_compat.py | 2 +- src/tests/{test_suite => }/_missing_import.py | 0 src/tests/conftest.py | 57 + src/tests/leaktest.py | 8 +- src/tests/profile.py | 2 +- src/tests/runtests.py | 62 +- src/tests/stress.py | 4 +- src/tests/stresstest.py | 2 +- src/tests/test_array.py | 2115 +++++++++-------- src/tests/test_callback.py | 27 + src/tests/test_class.py | 391 +-- src/tests/test_compat.py | 438 ++-- src/tests/test_constructors.py | 62 +- src/tests/test_conversion.py | 979 ++++---- src/tests/test_delegate.py | 365 +-- src/tests/test_docstring.py | 37 +- src/tests/test_engine.py | 59 +- src/tests/test_enum.py | 271 ++- src/tests/test_event.py | 789 +++--- src/tests/test_exceptions.py | 523 ++-- src/tests/test_field.py | 541 +++-- src/tests/test_generic.py | 1525 ++++++------ src/tests/test_import.py | 13 + src/tests/test_indexer.py | 802 ++++--- src/tests/test_interface.py | 93 +- src/tests/test_method.py | 1238 +++++----- src/tests/test_module.py | 647 ++--- src/tests/test_property.py | 201 +- src/tests/test_recursive_types.py | 12 + src/tests/test_subclass.py | 223 +- src/tests/test_suite/__init__.py | 15 - src/tests/test_suite/test_callback.py | 33 - src/tests/test_suite/test_import.py | 18 - src/tests/test_suite/test_recursive_types.py | 19 - src/tests/test_sysargv.py | 19 +- src/tests/test_thread.py | 88 +- src/tests/utils.py | 2 +- 37 files changed, 5937 insertions(+), 5745 deletions(-) rename src/tests/{test_suite => }/_missing_import.py (100%) create mode 100644 src/tests/conftest.py create mode 100644 src/tests/test_callback.py create mode 100644 src/tests/test_import.py create mode 100644 src/tests/test_recursive_types.py delete mode 100644 src/tests/test_suite/__init__.py delete mode 100644 src/tests/test_suite/test_callback.py delete mode 100644 src/tests/test_suite/test_import.py delete mode 100644 src/tests/test_suite/test_recursive_types.py diff --git a/src/tests/_compat.py b/src/tests/_compat.py index 3a9d48c7e..178777e4a 100644 --- a/src/tests/_compat.py +++ b/src/tests/_compat.py @@ -33,7 +33,7 @@ unicode = str # from nowhere import Nothing - cmp = lambda a, b: (a > b) - (a < b) # No Py3 equivalent + cmp = lambda a, b: (a > b) - (a < b) # No PY3 equivalent map = map range = range zip = zip diff --git a/src/tests/test_suite/_missing_import.py b/src/tests/_missing_import.py similarity index 100% rename from src/tests/test_suite/_missing_import.py rename to src/tests/_missing_import.py diff --git a/src/tests/conftest.py b/src/tests/conftest.py new file mode 100644 index 000000000..85fff291f --- /dev/null +++ b/src/tests/conftest.py @@ -0,0 +1,57 @@ +# -*- coding: utf-8 -*- +# TODO: move tests one out of src. Pythonnet doesn't run... + +"""Helpers for testing.""" + +import io +import os +import sys + +import pytest +import clr + +sys.path.append('C:/testdir/') +clr.AddReference("Python.Test") +clr.AddReference("System.Collections") +clr.AddReference("System.Data") + +DIR_PATH = os.path.dirname(__file__) +FILES_DIR = os.path.join(DIR_PATH, 'files') + + +@pytest.fixture() +def filepath(): + """Returns full file path for test files.""" + + def make_filepath(filename): + # http://stackoverflow.com/questions/18011902/parameter-to-a-fixture + # Alternate solution is to use paramtrization `inderect=True` + # http://stackoverflow.com/a/33879151 + # Syntax is noisy and requires specific variable names + return os.path.join(FILES_DIR, filename) + + return make_filepath + + +@pytest.fixture() +def load_file(filepath): + """Opens filename with encoding and return its contents.""" + + def make_load_file(filename, encoding='utf-8'): + # http://stackoverflow.com/questions/18011902/parameter-to-a-fixture + # Alternate solution is to use paramtrization `inderect=True` + # http://stackoverflow.com/a/33879151 + # Syntax is noisy and requires specific variable names + # And seems to be limited to only 1 argument. + with io.open(filepath(filename), encoding=encoding) as f: + return f.read().strip() + + return make_load_file + + +@pytest.fixture() +def get_stream(filepath): + def make_stream(filename, encoding='utf-8'): + return io.open(filepath(filename), encoding=encoding) + + return make_stream diff --git a/src/tests/leaktest.py b/src/tests/leaktest.py index 646cb512e..05b76e867 100644 --- a/src/tests/leaktest.py +++ b/src/tests/leaktest.py @@ -10,10 +10,10 @@ import System -from _compat import range -from utils import (CallableHandler, ClassMethodHandler, GenericHandler, - HelloClass, StaticMethodHandler, VarCallableHandler, - VariableArgsHandler, hello_func) +from ._compat import range +from .utils import (CallableHandler, ClassMethodHandler, GenericHandler, + HelloClass, StaticMethodHandler, VarCallableHandler, + VariableArgsHandler, hello_func) class LeakTest(object): diff --git a/src/tests/profile.py b/src/tests/profile.py index f6576ddce..4af3589e8 100644 --- a/src/tests/profile.py +++ b/src/tests/profile.py @@ -14,7 +14,7 @@ import time import runtests -from _compat import range +from ._compat import range def main(): diff --git a/src/tests/runtests.py b/src/tests/runtests.py index 92d9ecbd0..8011d05e6 100644 --- a/src/tests/runtests.py +++ b/src/tests/runtests.py @@ -5,11 +5,10 @@ from __future__ import print_function -import os import sys -import unittest +import pytest -from _compat import input +from ._compat import input try: import System @@ -22,63 +21,16 @@ clr.AddReference("System.Data") clr.AddReference("System.Management") -test_modules = ( - # has to be first test before other module import clr - 'test_sysargv', - + +def main(verbosity=1): # test_module passes on its own, but not here if # other test modules that import System.Windows.Forms # run first. They must not do module level import/AddReference() # of the System.Windows.Forms namespace. - 'test_module', - - 'test_suite', - 'test_event', - 'test_constructors', - 'test_enum', - 'test_method', - 'test_exceptions', - 'test_compat', - 'test_generic', - 'test_conversion', - 'test_class', - 'test_interface', - 'test_field', - 'test_property', - 'test_indexer', - 'test_delegate', - 'test_array', - 'test_thread', - 'test_docstring', - - # FIXME: Has tests that are being skipped. - 'test_engine', - - # FIXME: Has tests that are being skipped. - 'test_subclass', -) - - -def remove_pyc(): - path = os.path.dirname(os.path.abspath(__file__)) - for name in test_modules: - pyc = os.path.join(path, "{0}.pyc".format(name)) - if os.path.isfile(pyc): - os.unlink(pyc) - - -def main(verbosity=1): - remove_pyc() - - suite = unittest.TestSuite() - - for name in test_modules: - module = __import__(name) - suite.addTests((module.test_suite(),)) - result = unittest.TextTestRunner(verbosity=verbosity).run(suite) - if not result.wasSuccessful(): - raise Exception("Tests failed") + # FIXME: test_engine has tests that are being skipped. + # FIXME: test_subclass has tests that are being skipped. + pytest.main() if __name__ == '__main__': diff --git a/src/tests/stress.py b/src/tests/stress.py index 2ffe06958..c6fa8b7e3 100644 --- a/src/tests/stress.py +++ b/src/tests/stress.py @@ -17,8 +17,8 @@ import threading import time -from _compat import range, thread -from utils import dprint +from ._compat import range, thread +from .utils import dprint class StressTest(object): diff --git a/src/tests/stresstest.py b/src/tests/stresstest.py index 947959239..74b863bdc 100644 --- a/src/tests/stresstest.py +++ b/src/tests/stresstest.py @@ -11,7 +11,7 @@ import unittest # import pdb -from _compat import range +from ._compat import range try: import System diff --git a/src/tests/test_array.py b/src/tests/test_array.py index 36f225c82..7ccadddff 100644 --- a/src/tests/test_array.py +++ b/src/tests/test_array.py @@ -1,1306 +1,1339 @@ # -*- coding: utf-8 -*- -import unittest +"""Test support for managed arrays.""" import Python.Test as Test import System +import pytest -from _compat import PY2, UserList, long, range, unichr +from ._compat import PY2, UserList, long, range, unichr -class ArrayTests(unittest.TestCase): - """Test support for managed arrays.""" +def test_public_array(): + """Test public arrays.""" + ob = Test.PublicArrayTest() + items = ob.items - def test_public_array(self): - """Test public arrays.""" - ob = Test.PublicArrayTest() - items = ob.items + assert len(items) == 5 - self.assertTrue(len(items) == 5) + assert items[0] == 0 + assert items[4] == 4 - self.assertTrue(items[0] == 0) - self.assertTrue(items[4] == 4) + items[0] = 8 + assert items[0] == 8 - items[0] = 8 - self.assertTrue(items[0] == 8) + items[4] = 9 + assert items[4] == 9 - items[4] = 9 - self.assertTrue(items[4] == 9) + items[-4] = 0 + assert items[-4] == 0 - items[-4] = 0 - self.assertTrue(items[-4] == 0) + items[-1] = 4 + assert items[-1] == 4 - items[-1] = 4 - self.assertTrue(items[-1] == 4) - def test_protected_array(self): - """Test protected arrays.""" - ob = Test.ProtectedArrayTest() - items = ob.items +def test_protected_array(): + """Test protected arrays.""" + ob = Test.ProtectedArrayTest() + items = ob.items - self.assertTrue(len(items) == 5) + assert len(items) == 5 - self.assertTrue(items[0] == 0) - self.assertTrue(items[4] == 4) + assert items[0] == 0 + assert items[4] == 4 - items[0] = 8 - self.assertTrue(items[0] == 8) + items[0] = 8 + assert items[0] == 8 - items[4] = 9 - self.assertTrue(items[4] == 9) + items[4] = 9 + assert items[4] == 9 - items[-4] = 0 - self.assertTrue(items[-4] == 0) + items[-4] = 0 + assert items[-4] == 0 - items[-1] = 4 - self.assertTrue(items[-1] == 4) + items[-1] = 4 + assert items[-1] == 4 - def test_internal_array(self): - """Test internal arrays.""" - with self.assertRaises(AttributeError): - ob = Test.InternalArrayTest() - _ = ob.items +def test_internal_array(): + """Test internal arrays.""" - def test_private_array(self): - """Test private arrays.""" + with pytest.raises(AttributeError): + ob = Test.InternalArrayTest() + _ = ob.items - with self.assertRaises(AttributeError): - ob = Test.PrivateArrayTest() - _ = ob.items - def test_array_bounds_checking(self): - """Test array bounds checking.""" +def test_private_array(): + """Test private arrays.""" - ob = Test.Int32ArrayTest() - items = ob.items + with pytest.raises(AttributeError): + ob = Test.PrivateArrayTest() + _ = ob.items - self.assertTrue(items[0] == 0) - self.assertTrue(items[1] == 1) - self.assertTrue(items[2] == 2) - self.assertTrue(items[3] == 3) - self.assertTrue(items[4] == 4) - self.assertTrue(items[-5] == 0) - self.assertTrue(items[-4] == 1) - self.assertTrue(items[-3] == 2) - self.assertTrue(items[-2] == 3) - self.assertTrue(items[-1] == 4) +def test_array_bounds_checking(): + """Test array bounds checking.""" - with self.assertRaises(IndexError): - ob = Test.Int32ArrayTest() - _ = ob.items[5] + ob = Test.Int32ArrayTest() + items = ob.items - with self.assertRaises(IndexError): - ob = Test.Int32ArrayTest() - ob.items[5] = 0 + assert items[0] == 0 + assert items[1] == 1 + assert items[2] == 2 + assert items[3] == 3 + assert items[4] == 4 - with self.assertRaises(IndexError): - ob = Test.Int32ArrayTest() - items[-6] + assert items[-5] == 0 + assert items[-4] == 1 + assert items[-3] == 2 + assert items[-2] == 3 + assert items[-1] == 4 - with self.assertRaises(IndexError): - ob = Test.Int32ArrayTest() - items[-6] = 0 + with pytest.raises(IndexError): + ob = Test.Int32ArrayTest() + _ = ob.items[5] - def test_array_contains(self): - """Test array support for __contains__.""" + with pytest.raises(IndexError): + ob = Test.Int32ArrayTest() + ob.items[5] = 0 + + with pytest.raises(IndexError): + ob = Test.Int32ArrayTest() + items[-6] + with pytest.raises(IndexError): ob = Test.Int32ArrayTest() - items = ob.items + items[-6] = 0 - self.assertTrue(0 in items) - self.assertTrue(1 in items) - self.assertTrue(2 in items) - self.assertTrue(3 in items) - self.assertTrue(4 in items) - self.assertFalse(5 in items) # "H:\Python27\Lib\unittest\case.py", line 592, in deprecated_func, - self.assertFalse(-1 in items) # TypeError: int() argument must be a string or a number, not 'NoneType' - self.assertFalse(None in items) # which threw ^ here which is a little odd. - # But when run from runtests.py. Not when this module ran by itself. +def test_array_contains(): + """Test array support for __contains__.""" - def test_boolean_array(self): - """Test boolean arrays.""" - ob = Test.BooleanArrayTest() - items = ob.items + ob = Test.Int32ArrayTest() + items = ob.items - self.assertTrue(len(items) == 5) + assert 0 in items + assert 1 in items + assert 2 in items + assert 3 in items + assert 4 in items - self.assertTrue(items[0] is True) - self.assertTrue(items[1] is False) - self.assertTrue(items[2] is True) - self.assertTrue(items[3] is False) - self.assertTrue(items[4] is True) + assert not (5 in items) # "H:\Python27\Lib\unittest\case.py", line 592, in deprecated_func, + assert not (-1 in items) # TypeError: int() argument must be a string or a number, not 'NoneType' + assert not (None in items) # which threw ^ here which is a little odd. + # But when run from runtests.py. Not when this module ran by itself. - items[0] = False - self.assertTrue(items[0] is False) - items[0] = True - self.assertTrue(items[0] is True) +def test_boolean_array(): + """Test boolean arrays.""" + ob = Test.BooleanArrayTest() + items = ob.items - with self.assertRaises(TypeError): - ob = Test.ByteArrayTest() - _ = ob.items["wrong"] + assert len(items) == 5 - with self.assertRaises(TypeError): - ob = Test.ByteArrayTest() - ob[0] = "wrong" + assert items[0] is True + assert items[1] is False + assert items[2] is True + assert items[3] is False + assert items[4] is True + + items[0] = False + assert items[0] is False + + items[0] = True + assert items[0] is True + + with pytest.raises(TypeError): + ob = Test.ByteArrayTest() + _ = ob.items["wrong"] - def test_byte_array(self): - """Test byte arrays.""" + with pytest.raises(TypeError): ob = Test.ByteArrayTest() - items = ob.items + ob[0] = "wrong" - self.assertTrue(len(items) == 5) - self.assertTrue(items[0] == 0) - self.assertTrue(items[4] == 4) +def test_byte_array(): + """Test byte arrays.""" + ob = Test.ByteArrayTest() + items = ob.items - max_ = 255 - min_ = 0 + assert len(items) == 5 - items[0] = max_ - self.assertTrue(items[0] == max_) + assert items[0] == 0 + assert items[4] == 4 - items[0] = min_ - self.assertTrue(items[0] == min_) + max_ = 255 + min_ = 0 - items[-4] = max_ - self.assertTrue(items[-4] == max_) + items[0] = max_ + assert items[0] == max_ - items[-1] = min_ - self.assertTrue(items[-1] == min_) + items[0] = min_ + assert items[0] == min_ - with self.assertRaises(OverflowError): - ob = Test.ByteArrayTest() - ob.items[0] = max_ + 1 + items[-4] = max_ + assert items[-4] == max_ - with self.assertRaises(OverflowError): - ob = Test.ByteArrayTest() - ob.items[0] = min_ - 1 + items[-1] = min_ + assert items[-1] == min_ + + with pytest.raises(OverflowError): + ob = Test.ByteArrayTest() + ob.items[0] = max_ + 1 + + with pytest.raises(OverflowError): + ob = Test.ByteArrayTest() + ob.items[0] = min_ - 1 + + with pytest.raises(TypeError): + ob = Test.ByteArrayTest() + _ = ob.items["wrong"] + + with pytest.raises(TypeError): + ob = Test.ByteArrayTest() + ob[0] = "wrong" - with self.assertRaises(TypeError): - ob = Test.ByteArrayTest() - _ = ob.items["wrong"] - with self.assertRaises(TypeError): - ob = Test.ByteArrayTest() - ob[0] = "wrong" +def test_sbyte_array(): + """Test sbyte arrays.""" + ob = Test.SByteArrayTest() + items = ob.items - def test_sbyte_array(self): - """Test sbyte arrays.""" + assert len(items) == 5 + + assert items[0] == 0 + assert items[4] == 4 + + max_ = 127 + min_ = -128 + + items[0] = max_ + assert items[0] == max_ + + items[0] = min_ + assert items[0] == min_ + + items[-4] = max_ + assert items[-4] == max_ + + items[-1] = min_ + assert items[-1] == min_ + + with pytest.raises(OverflowError): + ob = Test.SByteArrayTest() + ob.items[0] = max_ + 1 + + with pytest.raises(OverflowError): + ob = Test.SByteArrayTest() + ob.items[0] = min_ - 1 + + with pytest.raises(TypeError): ob = Test.SByteArrayTest() - items = ob.items + _ = ob.items["wrong"] - self.assertTrue(len(items) == 5) + with pytest.raises(TypeError): + ob = Test.SByteArrayTest() + ob[0] = "wrong" - self.assertTrue(items[0] == 0) - self.assertTrue(items[4] == 4) - max_ = 127 - min_ = -128 +def test_char_array(): + """Test char arrays.""" + ob = Test.CharArrayTest() + items = ob.items - items[0] = max_ - self.assertTrue(items[0] == max_) + assert len(items) == 5 - items[0] = min_ - self.assertTrue(items[0] == min_) + assert items[0] == 'a' + assert items[4] == 'e' - items[-4] = max_ - self.assertTrue(items[-4] == max_) + max_ = unichr(65535) + min_ = unichr(0) - items[-1] = min_ - self.assertTrue(items[-1] == min_) + items[0] = max_ + assert items[0] == max_ - with self.assertRaises(OverflowError): - ob = Test.SByteArrayTest() - ob.items[0] = max_ + 1 + items[0] = min_ + assert items[0] == min_ - with self.assertRaises(OverflowError): - ob = Test.SByteArrayTest() - ob.items[0] = min_ - 1 + items[-4] = max_ + assert items[-4] == max_ - with self.assertRaises(TypeError): - ob = Test.SByteArrayTest() - _ = ob.items["wrong"] + items[-1] = min_ + assert items[-1] == min_ - with self.assertRaises(TypeError): - ob = Test.SByteArrayTest() - ob[0] = "wrong" + with pytest.raises(TypeError): + ob = Test.CharArrayTest() + _ = ob.items["wrong"] - def test_char_array(self): - """Test char arrays.""" + with pytest.raises(TypeError): ob = Test.CharArrayTest() - items = ob.items + ob[0] = "wrong" + + +def test_int16_array(): + """Test Int16 arrays.""" + ob = Test.Int16ArrayTest() + items = ob.items + + assert len(items) == 5 - self.assertTrue(len(items) == 5) + assert items[0] == 0 + assert items[4] == 4 - self.assertTrue(items[0] == 'a') - self.assertTrue(items[4] == 'e') + max_ = 32767 + min_ = -32768 - max_ = unichr(65535) - min_ = unichr(0) + items[0] = max_ + assert items[0] == max_ - items[0] = max_ - self.assertTrue(items[0] == max_) + items[0] = min_ + assert items[0] == min_ - items[0] = min_ - self.assertTrue(items[0] == min_) + items[-4] = max_ + assert items[-4] == max_ - items[-4] = max_ - self.assertTrue(items[-4] == max_) + items[-1] = min_ + assert items[-1] == min_ - items[-1] = min_ - self.assertTrue(items[-1] == min_) + with pytest.raises(OverflowError): + ob = Test.Int16ArrayTest() + ob.items[0] = max_ + 1 - with self.assertRaises(TypeError): - ob = Test.CharArrayTest() - _ = ob.items["wrong"] + with pytest.raises(OverflowError): + ob = Test.Int16ArrayTest() + ob.items[0] = min_ - 1 - with self.assertRaises(TypeError): - ob = Test.CharArrayTest() - ob[0] = "wrong" + with pytest.raises(TypeError): + ob = Test.Int16ArrayTest() + _ = ob.items["wrong"] - def test_int16_array(self): - """Test Int16 arrays.""" + with pytest.raises(TypeError): ob = Test.Int16ArrayTest() - items = ob.items + ob[0] = "wrong" - self.assertTrue(len(items) == 5) - self.assertTrue(items[0] == 0) - self.assertTrue(items[4] == 4) +def test_int32_array(): + """Test Int32 arrays.""" + ob = Test.Int32ArrayTest() + items = ob.items - max_ = 32767 - min_ = -32768 + assert len(items) == 5 - items[0] = max_ - self.assertTrue(items[0] == max_) + assert items[0] == 0 + assert items[4] == 4 - items[0] = min_ - self.assertTrue(items[0] == min_) + max_ = 2147483647 + min_ = -2147483648 - items[-4] = max_ - self.assertTrue(items[-4] == max_) + items[0] = max_ + assert items[0] == max_ - items[-1] = min_ - self.assertTrue(items[-1] == min_) + items[0] = min_ + assert items[0] == min_ - with self.assertRaises(OverflowError): - ob = Test.Int16ArrayTest() - ob.items[0] = max_ + 1 + items[-4] = max_ + assert items[-4] == max_ - with self.assertRaises(OverflowError): - ob = Test.Int16ArrayTest() - ob.items[0] = min_ - 1 + items[-1] = min_ + assert items[-1] == min_ - with self.assertRaises(TypeError): - ob = Test.Int16ArrayTest() - _ = ob.items["wrong"] + with pytest.raises(OverflowError): + ob = Test.Int32ArrayTest() + ob.items[0] = max_ + 1 - with self.assertRaises(TypeError): - ob = Test.Int16ArrayTest() - ob[0] = "wrong" + with pytest.raises(OverflowError): + ob = Test.Int32ArrayTest() + ob.items[0] = min_ - 1 - def test_int32_array(self): - """Test Int32 arrays.""" + with pytest.raises(TypeError): ob = Test.Int32ArrayTest() - items = ob.items + _ = ob.items["wrong"] - self.assertTrue(len(items) == 5) + with pytest.raises(TypeError): + ob = Test.Int32ArrayTest() + ob[0] = "wrong" - self.assertTrue(items[0] == 0) - self.assertTrue(items[4] == 4) - max_ = 2147483647 - min_ = -2147483648 +def test_int64_array(): + """Test Int64 arrays.""" + ob = Test.Int64ArrayTest() + items = ob.items - items[0] = max_ - self.assertTrue(items[0] == max_) + assert len(items) == 5 - items[0] = min_ - self.assertTrue(items[0] == min_) + assert items[0] == 0 + assert items[4] == 4 - items[-4] = max_ - self.assertTrue(items[-4] == max_) + max_ = long(9223372036854775807) + min_ = long(-9223372036854775808) - items[-1] = min_ - self.assertTrue(items[-1] == min_) + items[0] = max_ + assert items[0] == max_ - with self.assertRaises(OverflowError): - ob = Test.Int32ArrayTest() - ob.items[0] = max_ + 1 + items[0] = min_ + assert items[0] == min_ - with self.assertRaises(OverflowError): - ob = Test.Int32ArrayTest() - ob.items[0] = min_ - 1 + items[-4] = max_ + assert items[-4] == max_ - with self.assertRaises(TypeError): - ob = Test.Int32ArrayTest() - _ = ob.items["wrong"] + items[-1] = min_ + assert items[-1] == min_ - with self.assertRaises(TypeError): - ob = Test.Int32ArrayTest() - ob[0] = "wrong" + with pytest.raises(OverflowError): + ob = Test.Int64ArrayTest() + ob.items[0] = max_ + 1 - def test_int64_array(self): - """Test Int64 arrays.""" + with pytest.raises(OverflowError): ob = Test.Int64ArrayTest() - items = ob.items + ob.items[0] = min_ - 1 - self.assertTrue(len(items) == 5) + with pytest.raises(TypeError): + ob = Test.Int64ArrayTest() + _ = ob.items["wrong"] - self.assertTrue(items[0] == 0) - self.assertTrue(items[4] == 4) + with pytest.raises(TypeError): + ob = Test.Int64ArrayTest() + ob[0] = "wrong" - max_ = long(9223372036854775807) - min_ = long(-9223372036854775808) - items[0] = max_ - self.assertTrue(items[0] == max_) +def test_uint16_array(): + """Test UInt16 arrays.""" + ob = Test.UInt16ArrayTest() + items = ob.items - items[0] = min_ - self.assertTrue(items[0] == min_) + assert len(items) == 5 - items[-4] = max_ - self.assertTrue(items[-4] == max_) + assert items[0] == 0 + assert items[4] == 4 - items[-1] = min_ - self.assertTrue(items[-1] == min_) + max_ = 65535 + min_ = 0 - with self.assertRaises(OverflowError): - ob = Test.Int64ArrayTest() - ob.items[0] = max_ + 1 + items[0] = max_ + assert items[0] == max_ - with self.assertRaises(OverflowError): - ob = Test.Int64ArrayTest() - ob.items[0] = min_ - 1 + items[0] = min_ + assert items[0] == min_ - with self.assertRaises(TypeError): - ob = Test.Int64ArrayTest() - _ = ob.items["wrong"] + items[-4] = max_ + assert items[-4] == max_ - with self.assertRaises(TypeError): - ob = Test.Int64ArrayTest() - ob[0] = "wrong" + items[-1] = min_ + assert items[-1] == min_ - def test_uint16_array(self): - """Test UInt16 arrays.""" + with pytest.raises(OverflowError): ob = Test.UInt16ArrayTest() - items = ob.items + ob.items[0] = max_ + 1 - self.assertTrue(len(items) == 5) + with pytest.raises(OverflowError): + ob = Test.UInt16ArrayTest() + ob.items[0] = min_ - 1 + + with pytest.raises(TypeError): + ob = Test.UInt16ArrayTest() + _ = ob.items["wrong"] + + with pytest.raises(TypeError): + ob = Test.UInt16ArrayTest() + ob[0] = "wrong" - self.assertTrue(items[0] == 0) - self.assertTrue(items[4] == 4) - max_ = 65535 - min_ = 0 +def test_uint32_array(): + """Test UInt32 arrays.""" + ob = Test.UInt32ArrayTest() + items = ob.items - items[0] = max_ - self.assertTrue(items[0] == max_) + assert len(items) == 5 - items[0] = min_ - self.assertTrue(items[0] == min_) + assert items[0] == 0 + assert items[4] == 4 - items[-4] = max_ - self.assertTrue(items[-4] == max_) + max_ = long(4294967295) + min_ = 0 - items[-1] = min_ - self.assertTrue(items[-1] == min_) + items[0] = max_ + assert items[0] == max_ - with self.assertRaises(OverflowError): - ob = Test.UInt16ArrayTest() - ob.items[0] = max_ + 1 + items[0] = min_ + assert items[0] == min_ - with self.assertRaises(OverflowError): - ob = Test.UInt16ArrayTest() - ob.items[0] = min_ - 1 + items[-4] = max_ + assert items[-4] == max_ - with self.assertRaises(TypeError): - ob = Test.UInt16ArrayTest() - _ = ob.items["wrong"] + items[-1] = min_ + assert items[-1] == min_ - with self.assertRaises(TypeError): - ob = Test.UInt16ArrayTest() - ob[0] = "wrong" + with pytest.raises(OverflowError): + ob = Test.UInt32ArrayTest() + ob.items[0] = max_ + 1 - def test_uint32_array(self): - """Test UInt32 arrays.""" + with pytest.raises(OverflowError): ob = Test.UInt32ArrayTest() - items = ob.items + ob.items[0] = min_ - 1 - self.assertTrue(len(items) == 5) + with pytest.raises(TypeError): + ob = Test.UInt32ArrayTest() + _ = ob.items["wrong"] - self.assertTrue(items[0] == 0) - self.assertTrue(items[4] == 4) + with pytest.raises(TypeError): + ob = Test.UInt32ArrayTest() + ob[0] = "wrong" - max_ = long(4294967295) - min_ = 0 - items[0] = max_ - self.assertTrue(items[0] == max_) +def test_uint64_array(): + """Test UInt64 arrays.""" + ob = Test.UInt64ArrayTest() + items = ob.items - items[0] = min_ - self.assertTrue(items[0] == min_) + assert len(items) == 5 - items[-4] = max_ - self.assertTrue(items[-4] == max_) + assert items[0] == 0 + assert items[4] == 4 - items[-1] = min_ - self.assertTrue(items[-1] == min_) + max_ = long(18446744073709551615) + min_ = 0 - with self.assertRaises(OverflowError): - ob = Test.UInt32ArrayTest() - ob.items[0] = max_ + 1 + items[0] = max_ + assert items[0] == max_ - with self.assertRaises(OverflowError): - ob = Test.UInt32ArrayTest() - ob.items[0] = min_ - 1 + items[0] = min_ + assert items[0] == min_ - with self.assertRaises(TypeError): - ob = Test.UInt32ArrayTest() - _ = ob.items["wrong"] + items[-4] = max_ + assert items[-4] == max_ - with self.assertRaises(TypeError): - ob = Test.UInt32ArrayTest() - ob[0] = "wrong" + items[-1] = min_ + assert items[-1] == min_ - def test_uint64_array(self): - """Test UInt64 arrays.""" + with pytest.raises(OverflowError): ob = Test.UInt64ArrayTest() - items = ob.items + ob.items[0] = max_ + 1 - self.assertTrue(len(items) == 5) + with pytest.raises(OverflowError): + ob = Test.UInt64ArrayTest() + ob.items[0] = min_ - 1 + + with pytest.raises(TypeError): + ob = Test.UInt64ArrayTest() + _ = ob.items["wrong"] + + with pytest.raises(TypeError): + ob = Test.UInt64ArrayTest() + ob[0] = "wrong" - self.assertTrue(items[0] == 0) - self.assertTrue(items[4] == 4) - max_ = long(18446744073709551615) - min_ = 0 +def test_single_array(): + """Test Single arrays.""" + ob = Test.SingleArrayTest() + items = ob.items - items[0] = max_ - self.assertTrue(items[0] == max_) + assert len(items) == 5 - items[0] = min_ - self.assertTrue(items[0] == min_) + assert items[0] == 0.0 + assert items[4] == 4.0 - items[-4] = max_ - self.assertTrue(items[-4] == max_) + max_ = 3.402823e38 + min_ = -3.402823e38 - items[-1] = min_ - self.assertTrue(items[-1] == min_) + items[0] = max_ + assert items[0] == max_ - with self.assertRaises(OverflowError): - ob = Test.UInt64ArrayTest() - ob.items[0] = max_ + 1 + items[0] = min_ + assert items[0] == min_ - with self.assertRaises(OverflowError): - ob = Test.UInt64ArrayTest() - ob.items[0] = min_ - 1 + items[-4] = max_ + assert items[-4] == max_ - with self.assertRaises(TypeError): - ob = Test.UInt64ArrayTest() - _ = ob.items["wrong"] + items[-1] = min_ + assert items[-1] == min_ - with self.assertRaises(TypeError): - ob = Test.UInt64ArrayTest() - ob[0] = "wrong" + with pytest.raises(TypeError): + ob = Test.SingleArrayTest() + _ = ob.items["wrong"] - def test_single_array(self): - """Test Single arrays.""" + with pytest.raises(TypeError): ob = Test.SingleArrayTest() - items = ob.items + ob[0] = "wrong" - self.assertTrue(len(items) == 5) - self.assertTrue(items[0] == 0.0) - self.assertTrue(items[4] == 4.0) +def test_double_array(): + """Test Double arrays.""" + ob = Test.DoubleArrayTest() + items = ob.items - max_ = 3.402823e38 - min_ = -3.402823e38 + assert len(items) == 5 - items[0] = max_ - self.assertTrue(items[0] == max_) + assert items[0] == 0.0 + assert items[4] == 4.0 - items[0] = min_ - self.assertTrue(items[0] == min_) + max_ = 1.7976931348623157e308 + min_ = -1.7976931348623157e308 - items[-4] = max_ - self.assertTrue(items[-4] == max_) + items[0] = max_ + assert items[0] == max_ - items[-1] = min_ - self.assertTrue(items[-1] == min_) + items[0] = min_ + assert items[0] == min_ - with self.assertRaises(TypeError): - ob = Test.SingleArrayTest() - _ = ob.items["wrong"] + items[-4] = max_ + assert items[-4] == max_ - with self.assertRaises(TypeError): - ob = Test.SingleArrayTest() - ob[0] = "wrong" + items[-1] = min_ + assert items[-1] == min_ + + with pytest.raises(TypeError): + ob = Test.DoubleArrayTest() + _ = ob.items["wrong"] - def test_double_array(self): - """Test Double arrays.""" + with pytest.raises(TypeError): ob = Test.DoubleArrayTest() - items = ob.items + ob[0] = "wrong" - self.assertTrue(len(items) == 5) - self.assertTrue(items[0] == 0.0) - self.assertTrue(items[4] == 4.0) +def test_decimal_array(): + """Test Decimal arrays.""" + ob = Test.DecimalArrayTest() + items = ob.items - max_ = 1.7976931348623157e308 - min_ = -1.7976931348623157e308 + from System import Decimal + max_d = Decimal.Parse("79228162514264337593543950335") + min_d = Decimal.Parse("-79228162514264337593543950335") - items[0] = max_ - self.assertTrue(items[0] == max_) + assert len(items) == 5 - items[0] = min_ - self.assertTrue(items[0] == min_) + assert items[0] == Decimal(0) + assert items[4] == Decimal(4) - items[-4] = max_ - self.assertTrue(items[-4] == max_) + items[0] = max_d + assert items[0] == max_d - items[-1] = min_ - self.assertTrue(items[-1] == min_) + items[0] = min_d + assert items[0] == min_d - with self.assertRaises(TypeError): - ob = Test.DoubleArrayTest() - _ = ob.items["wrong"] + items[-4] = max_d + assert items[-4] == max_d - with self.assertRaises(TypeError): - ob = Test.DoubleArrayTest() - ob[0] = "wrong" + items[-1] = min_d + assert items[-1] == min_d - def test_decimal_array(self): - """Test Decimal arrays.""" + with pytest.raises(TypeError): ob = Test.DecimalArrayTest() - items = ob.items + _ = ob.items["wrong"] - from System import Decimal - max_d = Decimal.Parse("79228162514264337593543950335") - min_d = Decimal.Parse("-79228162514264337593543950335") + with pytest.raises(TypeError): + ob = Test.DecimalArrayTest() + ob[0] = "wrong" - self.assertTrue(len(items) == 5) - self.assertTrue(items[0] == Decimal(0)) - self.assertTrue(items[4] == Decimal(4)) +def test_string_array(): + """Test String arrays.""" + ob = Test.StringArrayTest() + items = ob.items - items[0] = max_d - self.assertTrue(items[0] == max_d) + assert len(items) == 5 - items[0] = min_d - self.assertTrue(items[0] == min_d) + assert items[0] == '0' + assert items[4] == '4' - items[-4] = max_d - self.assertTrue(items[-4] == max_d) + items[0] = "spam" + assert items[0] == "spam" - items[-1] = min_d - self.assertTrue(items[-1] == min_d) + items[0] = "eggs" + assert items[0] == "eggs" - with self.assertRaises(TypeError): - ob = Test.DecimalArrayTest() - _ = ob.items["wrong"] + items[-4] = "spam" + assert items[-4] == "spam" - with self.assertRaises(TypeError): - ob = Test.DecimalArrayTest() - ob[0] = "wrong" + items[-1] = "eggs" + assert items[-1] == "eggs" - def test_string_array(self): - """Test String arrays.""" + with pytest.raises(TypeError): ob = Test.StringArrayTest() - items = ob.items + _ = ob.items["wrong"] + + with pytest.raises(TypeError): + ob = Test.Int64ArrayTest() + ob[0] = 0 + - self.assertTrue(len(items) == 5) +def test_enum_array(): + """Test enum arrays.""" + from Python.Test import ShortEnum + ob = Test.EnumArrayTest() + items = ob.items - self.assertTrue(items[0] == '0') - self.assertTrue(items[4] == '4') + assert len(items) == 5 - items[0] = "spam" - self.assertTrue(items[0] == "spam") + assert items[0] == ShortEnum.Zero + assert items[4] == ShortEnum.Four - items[0] = "eggs" - self.assertTrue(items[0] == "eggs") + items[0] = ShortEnum.Four + assert items[0] == ShortEnum.Four - items[-4] = "spam" - self.assertTrue(items[-4] == "spam") + items[0] = ShortEnum.Zero + assert items[0] == ShortEnum.Zero - items[-1] = "eggs" - self.assertTrue(items[-1] == "eggs") + items[-4] = ShortEnum.Four + assert items[-4] == ShortEnum.Four - with self.assertRaises(TypeError): - ob = Test.StringArrayTest() - _ = ob.items["wrong"] + items[-1] = ShortEnum.Zero + assert items[-1] == ShortEnum.Zero - with self.assertRaises(TypeError): - ob = Test.Int64ArrayTest() - ob[0] = 0 + with pytest.raises(ValueError): + ob = Test.EnumArrayTest() + ob.items[0] = 99 + + with pytest.raises(TypeError): + ob = Test.EnumArrayTest() + _ = ob.items["wrong"] - def test_enum_array(self): - """Test enum arrays.""" - from Python.Test import ShortEnum + with pytest.raises(TypeError): ob = Test.EnumArrayTest() - items = ob.items + ob[0] = "wrong" + - self.assertTrue(len(items) == 5) +def test_object_array(): + """Test ob arrays.""" + from Python.Test import Spam + ob = Test.ObjectArrayTest() + items = ob.items - self.assertTrue(items[0] == ShortEnum.Zero) - self.assertTrue(items[4] == ShortEnum.Four) + assert len(items) == 5 - items[0] = ShortEnum.Four - self.assertTrue(items[0] == ShortEnum.Four) + assert items[0].GetValue() == "0" + assert items[4].GetValue() == "4" - items[0] = ShortEnum.Zero - self.assertTrue(items[0] == ShortEnum.Zero) + items[0] = Spam("4") + assert items[0].GetValue() == "4" - items[-4] = ShortEnum.Four - self.assertTrue(items[-4] == ShortEnum.Four) + items[0] = Spam("0") + assert items[0].GetValue() == "0" - items[-1] = ShortEnum.Zero - self.assertTrue(items[-1] == ShortEnum.Zero) + items[-4] = Spam("4") + assert items[-4].GetValue() == "4" - with self.assertRaises(ValueError): - ob = Test.EnumArrayTest() - ob.items[0] = 99 + items[-1] = Spam("0") + assert items[-1].GetValue() == "0" - with self.assertRaises(TypeError): - ob = Test.EnumArrayTest() - _ = ob.items["wrong"] + items[0] = 99 + assert items[0] == 99 - with self.assertRaises(TypeError): - ob = Test.EnumArrayTest() - ob[0] = "wrong" + items[0] = None + assert items[0] is None - def test_object_array(self): - """Test ob arrays.""" - from Python.Test import Spam + with pytest.raises(TypeError): ob = Test.ObjectArrayTest() - items = ob.items + _ = ob.items["wrong"] - self.assertTrue(len(items) == 5) + with pytest.raises(TypeError): + ob = Test.ObjectArrayTest() + ob.items["wrong"] = "wrong" - self.assertTrue(items[0].GetValue() == "0") - self.assertTrue(items[4].GetValue() == "4") - items[0] = Spam("4") - self.assertTrue(items[0].GetValue() == "4") +def test_null_array(): + """Test null arrays.""" + ob = Test.NullArrayTest() + items = ob.items - items[0] = Spam("0") - self.assertTrue(items[0].GetValue() == "0") + assert len(items) == 5 - items[-4] = Spam("4") - self.assertTrue(items[-4].GetValue() == "4") + assert items[0] is None + assert items[4] is None - items[-1] = Spam("0") - self.assertTrue(items[-1].GetValue() == "0") + items[0] = "spam" + assert items[0] == "spam" - items[0] = 99 - self.assertTrue(items[0] == 99) + items[0] = None + assert items[0] is None - items[0] = None - self.assertTrue(items[0] is None) + items[-4] = "spam" + assert items[-4] == "spam" - with self.assertRaises(TypeError): - ob = Test.ObjectArrayTest() - _ = ob.items["wrong"] + items[-1] = None + assert items[-1] is None - with self.assertRaises(TypeError): - ob = Test.ObjectArrayTest() - ob.items["wrong"] = "wrong" + empty = ob.empty + assert len(empty) == 0 - def test_null_array(self): - """Test null arrays.""" + with pytest.raises(TypeError): ob = Test.NullArrayTest() - items = ob.items + _ = ob.items["wrong"] + - self.assertTrue(len(items) == 5) +def test_interface_array(): + """Test interface arrays.""" + from Python.Test import Spam + ob = Test.InterfaceArrayTest() + items = ob.items - self.assertTrue(items[0] is None) - self.assertTrue(items[4] is None) + assert len(items) == 5 - items[0] = "spam" - self.assertTrue(items[0] == "spam") + assert items[0].GetValue() == "0" + assert items[4].GetValue() == "4" - items[0] = None - self.assertTrue(items[0] is None) + items[0] = Spam("4") + assert items[0].GetValue() == "4" - items[-4] = "spam" - self.assertTrue(items[-4] == "spam") + items[0] = Spam("0") + assert items[0].GetValue() == "0" - items[-1] = None - self.assertTrue(items[-1] is None) + items[-4] = Spam("4") + assert items[-4].GetValue() == "4" - empty = ob.empty - self.assertTrue(len(empty) == 0) + items[-1] = Spam("0") + assert items[-1].GetValue() == "0" - with self.assertRaises(TypeError): - ob = Test.NullArrayTest() - _ = ob.items["wrong"] + items[0] = None + assert items[0] is None - def test_interface_array(self): - """Test interface arrays.""" - from Python.Test import Spam + with pytest.raises(TypeError): ob = Test.InterfaceArrayTest() - items = ob.items + ob.items[0] = 99 - self.assertTrue(len(items) == 5) + with pytest.raises(TypeError): + ob = Test.InterfaceArrayTest() + _ = ob.items["wrong"] + + with pytest.raises(TypeError): + ob = Test.InterfaceArrayTest() + ob.items["wrong"] = "wrong" - self.assertTrue(items[0].GetValue() == "0") - self.assertTrue(items[4].GetValue() == "4") - items[0] = Spam("4") - self.assertTrue(items[0].GetValue() == "4") +def test_typed_array(): + """Test typed arrays.""" + from Python.Test import Spam + ob = Test.TypedArrayTest() + items = ob.items - items[0] = Spam("0") - self.assertTrue(items[0].GetValue() == "0") + assert len(items) == 5 - items[-4] = Spam("4") - self.assertTrue(items[-4].GetValue() == "4") + assert items[0].GetValue() == "0" + assert items[4].GetValue() == "4" - items[-1] = Spam("0") - self.assertTrue(items[-1].GetValue() == "0") + items[0] = Spam("4") + assert items[0].GetValue() == "4" - items[0] = None - self.assertTrue(items[0] is None) + items[0] = Spam("0") + assert items[0].GetValue() == "0" - with self.assertRaises(TypeError): - ob = Test.InterfaceArrayTest() - ob.items[0] = 99 + items[-4] = Spam("4") + assert items[-4].GetValue() == "4" - with self.assertRaises(TypeError): - ob = Test.InterfaceArrayTest() - _ = ob.items["wrong"] + items[-1] = Spam("0") + assert items[-1].GetValue() == "0" - with self.assertRaises(TypeError): - ob = Test.InterfaceArrayTest() - ob.items["wrong"] = "wrong" + items[0] = None + assert items[0] is None - def test_typed_array(self): - """Test typed arrays.""" - from Python.Test import Spam + with pytest.raises(TypeError): ob = Test.TypedArrayTest() - items = ob.items + ob.items[0] = 99 - self.assertTrue(len(items) == 5) + with pytest.raises(TypeError): + ob = Test.TypedArrayTest() + _ = ob.items["wrong"] - self.assertTrue(items[0].GetValue() == "0") - self.assertTrue(items[4].GetValue() == "4") + with pytest.raises(TypeError): + ob = Test.TypedArrayTest() + ob.items["wrong"] = "wrong" + + +def test_multi_dimensional_array(): + """Test multi-dimensional arrays.""" + ob = Test.MultiDimensionalArrayTest() + items = ob.items + + assert len(items) == 25 + + assert items[0, 0] == 0 + assert items[0, 1] == 1 + assert items[0, 2] == 2 + assert items[0, 3] == 3 + assert items[0, 4] == 4 + assert items[1, 0] == 5 + assert items[1, 1] == 6 + assert items[1, 2] == 7 + assert items[1, 3] == 8 + assert items[1, 4] == 9 + assert items[2, 0] == 10 + assert items[2, 1] == 11 + assert items[2, 2] == 12 + assert items[2, 3] == 13 + assert items[2, 4] == 14 + assert items[3, 0] == 15 + assert items[3, 1] == 16 + assert items[3, 2] == 17 + assert items[3, 3] == 18 + assert items[3, 4] == 19 + assert items[4, 0] == 20 + assert items[4, 1] == 21 + assert items[4, 2] == 22 + assert items[4, 3] == 23 + assert items[4, 4] == 24 + + max_ = 2147483647 + min_ = -2147483648 + + items[0, 0] = max_ + assert items[0, 0] == max_ + + items[0, 0] = min_ + assert items[0, 0] == min_ + + items[-4, 0] = max_ + assert items[-4, 0] == max_ + + items[-1, -1] = min_ + assert items[-1, -1] == min_ + + with pytest.raises(OverflowError): + ob = Test.MultiDimensionalArrayTest() + ob.items[0, 0] = max_ + 1 - items[0] = Spam("4") - self.assertTrue(items[0].GetValue() == "4") + with pytest.raises(OverflowError): + ob = Test.MultiDimensionalArrayTest() + ob.items[0, 0] = min_ - 1 - items[0] = Spam("0") - self.assertTrue(items[0].GetValue() == "0") + with pytest.raises(TypeError): + ob = Test.MultiDimensionalArrayTest() + _ = ob.items["wrong", 0] + + with pytest.raises(TypeError): + ob = Test.MultiDimensionalArrayTest() + ob[0, 0] = "wrong" - items[-4] = Spam("4") - self.assertTrue(items[-4].GetValue() == "4") - items[-1] = Spam("0") - self.assertTrue(items[-1].GetValue() == "0") +def test_array_iteration(): + """Test array iteration.""" + items = Test.Int32ArrayTest().items - items[0] = None - self.assertTrue(items[0] is None) + for i in items: + assert (i > -1) and (i < 5) - with self.assertRaises(TypeError): - ob = Test.TypedArrayTest() - ob.items[0] = 99 + items = Test.NullArrayTest().items - with self.assertRaises(TypeError): - ob = Test.TypedArrayTest() - _ = ob.items["wrong"] + for i in items: + assert i is None - with self.assertRaises(TypeError): - ob = Test.TypedArrayTest() - ob.items["wrong"] = "wrong" + empty = Test.NullArrayTest().empty + + for i in empty: + raise TypeError('iteration over empty array') + + +def test_tuple_array_conversion(): + """Test conversion of tuples to array arguments.""" + from Python.Test import ArrayConversionTest + from Python.Test import Spam + + items = [] + for i in range(10): + items.append(Spam(str(i))) + items = tuple(items) + + result = ArrayConversionTest.EchoRange(items) + assert result[0].__class__ == Spam + assert len(result) == 10 + + +def test_tuple_nested_array_conversion(): + """Test conversion of tuples to array-of-array arguments.""" + from Python.Test import ArrayConversionTest + from Python.Test import Spam + + items = [] + for i in range(10): + subs = [] + for _ in range(10): + subs.append(Spam(str(i))) + items.append(tuple(subs)) + items = tuple(items) + + result = ArrayConversionTest.EchoRangeAA(items) + + assert len(result) == 10 + assert len(result[0]) == 10 + assert result[0][0].__class__ == Spam + + +def test_list_array_conversion(): + """Test conversion of lists to array arguments.""" + from Python.Test import ArrayConversionTest + from Python.Test import Spam + + items = [] + for i in range(10): + items.append(Spam(str(i))) + + result = ArrayConversionTest.EchoRange(items) + assert result[0].__class__ == Spam + assert len(result) == 10 + + +def test_list_nested_array_conversion(): + """Test conversion of lists to array-of-array arguments.""" + from Python.Test import ArrayConversionTest + from Python.Test import Spam + + items = [] + for i in range(10): + subs = [] + for _ in range(10): + subs.append(Spam(str(i))) + items.append(subs) + + result = ArrayConversionTest.EchoRangeAA(items) + + assert len(result) == 10 + assert len(result[0]) == 10 + assert result[0][0].__class__ == Spam + + +def test_sequence_array_conversion(): + """Test conversion of sequence-like obs to array arguments.""" + from Python.Test import ArrayConversionTest + from Python.Test import Spam + + items = UserList() + for i in range(10): + items.append(Spam(str(i))) + + result = ArrayConversionTest.EchoRange(items) + assert result[0].__class__ == Spam + assert len(result) == 10 + + +def test_sequence_nested_array_conversion(): + """Test conversion of sequences to array-of-array arguments.""" + from Python.Test import ArrayConversionTest + from Python.Test import Spam + + items = UserList() + for i in range(10): + subs = UserList() + for _ in range(10): + subs.append(Spam(str(i))) + items.append(subs) + + result = ArrayConversionTest.EchoRangeAA(items) + + assert len(result) == 10 + assert len(result[0]) == 10 + assert result[0][0].__class__ == Spam + + +def test_tuple_array_conversion_type_checking(): + """Test error handling for tuple conversion to array arguments.""" + from Python.Test import ArrayConversionTest + from Python.Test import Spam + + # This should work, because null / None is a valid value in an + # array of reference types. + + items = [] + for i in range(10): + items.append(Spam(str(i))) + items[1] = None + items = tuple(items) + + result = ArrayConversionTest.EchoRange(items) + + assert result[0].__class__ == Spam + assert result[1] is None + assert len(result) == 10 + + with pytest.raises(TypeError): + temp = list(items) + temp[1] = 1 + _ = ArrayConversionTest.EchoRange(tuple(temp)) + + with pytest.raises(TypeError): + temp = list(items) + temp[1] = "spam" + _ = ArrayConversionTest.EchoRange(tuple(temp)) + + +def test_list_array_conversion_type_checking(): + """Test error handling for list conversion to array arguments.""" + from Python.Test import ArrayConversionTest + from Python.Test import Spam + + # This should work, because null / None is a valid value in an + # array of reference types. + + items = [] + for i in range(10): + items.append(Spam(str(i))) + items[1] = None + + result = ArrayConversionTest.EchoRange(items) + + assert result[0].__class__ == Spam + assert result[1] is None + assert len(result) == 10 + + with pytest.raises(TypeError): + items[1] = 1 + _ = ArrayConversionTest.EchoRange(items) + + with pytest.raises(TypeError): + items[1] = "spam" + _ = ArrayConversionTest.EchoRange(items) + + +def test_sequence_array_conversion_type_checking(): + """Test error handling for sequence conversion to array arguments.""" + from Python.Test import ArrayConversionTest + from Python.Test import Spam + + # This should work, because null / None is a valid value in an + # array of reference types. + + items = UserList() + for i in range(10): + items.append(Spam(str(i))) + items[1] = None + + result = ArrayConversionTest.EchoRange(items) + + assert result[0].__class__ == Spam + assert result[1] is None + assert len(result) == 10 + + with pytest.raises(TypeError): + items[1] = 1 + _ = ArrayConversionTest.EchoRange(items) + + with pytest.raises(TypeError): + items[1] = "spam" + _ = ArrayConversionTest.EchoRange(items) - def test_multi_dimensional_array(self): - """Test multi-dimensional arrays.""" - ob = Test.MultiDimensionalArrayTest() - items = ob.items - - self.assertTrue(len(items) == 25) - - self.assertTrue(items[0, 0] == 0) - self.assertTrue(items[0, 1] == 1) - self.assertTrue(items[0, 2] == 2) - self.assertTrue(items[0, 3] == 3) - self.assertTrue(items[0, 4] == 4) - self.assertTrue(items[1, 0] == 5) - self.assertTrue(items[1, 1] == 6) - self.assertTrue(items[1, 2] == 7) - self.assertTrue(items[1, 3] == 8) - self.assertTrue(items[1, 4] == 9) - self.assertTrue(items[2, 0] == 10) - self.assertTrue(items[2, 1] == 11) - self.assertTrue(items[2, 2] == 12) - self.assertTrue(items[2, 3] == 13) - self.assertTrue(items[2, 4] == 14) - self.assertTrue(items[3, 0] == 15) - self.assertTrue(items[3, 1] == 16) - self.assertTrue(items[3, 2] == 17) - self.assertTrue(items[3, 3] == 18) - self.assertTrue(items[3, 4] == 19) - self.assertTrue(items[4, 0] == 20) - self.assertTrue(items[4, 1] == 21) - self.assertTrue(items[4, 2] == 22) - self.assertTrue(items[4, 3] == 23) - self.assertTrue(items[4, 4] == 24) - - max_ = 2147483647 - min_ = -2147483648 - - items[0, 0] = max_ - self.assertTrue(items[0, 0] == max_) - - items[0, 0] = min_ - self.assertTrue(items[0, 0] == min_) - - items[-4, 0] = max_ - self.assertTrue(items[-4, 0] == max_) - - items[-1, -1] = min_ - self.assertTrue(items[-1, -1] == min_) - - with self.assertRaises(OverflowError): - ob = Test.MultiDimensionalArrayTest() - ob.items[0, 0] = max_ + 1 - - with self.assertRaises(OverflowError): - ob = Test.MultiDimensionalArrayTest() - ob.items[0, 0] = min_ - 1 - - with self.assertRaises(TypeError): - ob = Test.MultiDimensionalArrayTest() - _ = ob.items["wrong", 0] - - with self.assertRaises(TypeError): - ob = Test.MultiDimensionalArrayTest() - ob[0, 0] = "wrong" - - def test_array_iteration(self): - """Test array iteration.""" - items = Test.Int32ArrayTest().items - - for i in items: - self.assertTrue((i > -1) and (i < 5)) - - items = Test.NullArrayTest().items - - for i in items: - self.assertTrue(i is None) - - empty = Test.NullArrayTest().empty - - for i in empty: - raise TypeError('iteration over empty array') - - def test_tuple_array_conversion(self): - """Test conversion of tuples to array arguments.""" - from Python.Test import ArrayConversionTest - from Python.Test import Spam - - items = [] - for i in range(10): - items.append(Spam(str(i))) - items = tuple(items) - - result = ArrayConversionTest.EchoRange(items) - self.assertTrue(result[0].__class__ == Spam) - self.assertTrue(len(result) == 10) - - def test_tuple_nested_array_conversion(self): - """Test conversion of tuples to array-of-array arguments.""" - from Python.Test import ArrayConversionTest - from Python.Test import Spam - - items = [] - for i in range(10): - subs = [] - for _ in range(10): - subs.append(Spam(str(i))) - items.append(tuple(subs)) - items = tuple(items) - - result = ArrayConversionTest.EchoRangeAA(items) - - self.assertTrue(len(result) == 10) - self.assertTrue(len(result[0]) == 10) - self.assertTrue(result[0][0].__class__ == Spam) - - def test_list_array_conversion(self): - """Test conversion of lists to array arguments.""" - from Python.Test import ArrayConversionTest - from Python.Test import Spam - - items = [] - for i in range(10): - items.append(Spam(str(i))) - - result = ArrayConversionTest.EchoRange(items) - self.assertTrue(result[0].__class__ == Spam) - self.assertTrue(len(result) == 10) - - def test_list_nested_array_conversion(self): - """Test conversion of lists to array-of-array arguments.""" - from Python.Test import ArrayConversionTest - from Python.Test import Spam - items = [] - for i in range(10): - subs = [] - for _ in range(10): - subs.append(Spam(str(i))) - items.append(subs) +def test_md_array_conversion(): + """Test passing of multi-dimensional array arguments.""" + from Python.Test import ArrayConversionTest + from Python.Test import Spam + from System import Array - result = ArrayConversionTest.EchoRangeAA(items) + # Currently, the runtime does not support automagic conversion of + # Python sequences to true multi-dimensional arrays (though it + # does support arrays-of-arrays). This test exists mostly as an + # example of how a multi-dimensional array can be created and used + # with managed code from Python. - self.assertTrue(len(result) == 10) - self.assertTrue(len(result[0]) == 10) - self.assertTrue(result[0][0].__class__ == Spam) - - def test_sequence_array_conversion(self): - """Test conversion of sequence-like obs to array arguments.""" - from Python.Test import ArrayConversionTest - from Python.Test import Spam - - items = UserList() - for i in range(10): - items.append(Spam(str(i))) - - result = ArrayConversionTest.EchoRange(items) - self.assertTrue(result[0].__class__ == Spam) - self.assertTrue(len(result) == 10) - - def test_sequence_nested_array_conversion(self): - """Test conversion of sequences to array-of-array arguments.""" - from Python.Test import ArrayConversionTest - from Python.Test import Spam - - items = UserList() - for i in range(10): - subs = UserList() - for _ in range(10): - subs.append(Spam(str(i))) - items.append(subs) - - result = ArrayConversionTest.EchoRangeAA(items) - - self.assertTrue(len(result) == 10) - self.assertTrue(len(result[0]) == 10) - self.assertTrue(result[0][0].__class__ == Spam) - - def test_tuple_array_conversion_type_checking(self): - """Test error handling for tuple conversion to array arguments.""" - from Python.Test import ArrayConversionTest - from Python.Test import Spam - - # This should work, because null / None is a valid value in an - # array of reference types. - - items = [] - for i in range(10): - items.append(Spam(str(i))) - items[1] = None - items = tuple(items) - - result = ArrayConversionTest.EchoRange(items) - - self.assertTrue(result[0].__class__ == Spam) - self.assertTrue(result[1] is None) - self.assertTrue(len(result) == 10) - - with self.assertRaises(TypeError): - temp = list(items) - temp[1] = 1 - _ = ArrayConversionTest.EchoRange(tuple(temp)) - - with self.assertRaises(TypeError): - temp = list(items) - temp[1] = "spam" - _ = ArrayConversionTest.EchoRange(tuple(temp)) - - def test_list_array_conversion_type_checking(self): - """Test error handling for list conversion to array arguments.""" - from Python.Test import ArrayConversionTest - from Python.Test import Spam - - # This should work, because null / None is a valid value in an - # array of reference types. - - items = [] - for i in range(10): - items.append(Spam(str(i))) - items[1] = None - - result = ArrayConversionTest.EchoRange(items) - - self.assertTrue(result[0].__class__ == Spam) - self.assertTrue(result[1] is None) - self.assertTrue(len(result) == 10) - - with self.assertRaises(TypeError): - items[1] = 1 - _ = ArrayConversionTest.EchoRange(items) - - with self.assertRaises(TypeError): - items[1] = "spam" - _ = ArrayConversionTest.EchoRange(items) - - def test_sequence_array_conversion_type_checking(self): - """Test error handling for sequence conversion to array arguments.""" - from Python.Test import ArrayConversionTest - from Python.Test import Spam - - # This should work, because null / None is a valid value in an - # array of reference types. - - items = UserList() - for i in range(10): - items.append(Spam(str(i))) - items[1] = None - - result = ArrayConversionTest.EchoRange(items) - - self.assertTrue(result[0].__class__ == Spam) - self.assertTrue(result[1] is None) - self.assertTrue(len(result) == 10) - - with self.assertRaises(TypeError): - items[1] = 1 - _ = ArrayConversionTest.EchoRange(items) - - with self.assertRaises(TypeError): - items[1] = "spam" - _ = ArrayConversionTest.EchoRange(items) - - def test_md_array_conversion(self): - """Test passing of multi-dimensional array arguments.""" - from Python.Test import ArrayConversionTest - from Python.Test import Spam - from System import Array - - # Currently, the runtime does not support automagic conversion of - # Python sequences to true multi-dimensional arrays (though it - # does support arrays-of-arrays). This test exists mostly as an - # example of how a multi-dimensional array can be created and used - # with managed code from Python. - - items = Array.CreateInstance(Spam, 5, 5) - - for i in range(5): - for n in range(5): - items.SetValue(Spam(str((i, n))), (i, n)) - - result = ArrayConversionTest.EchoRangeMD(items) - - self.assertTrue(len(result) == 25) - self.assertTrue(result[0, 0].__class__ == Spam) - self.assertTrue(result[0, 0].__class__ == Spam) - - def test_boxed_value_type_mutation_result(self): - """Test behavior of boxed value types.""" - - # This test actually exists mostly as documentation of an important - # concern when dealing with value types. Python does not have any - # value type semantics that can be mapped to the CLR, so it is easy - # to accidentally write code like the following which is not really - # mutating value types in-place but changing boxed copies. - - from System.Drawing import Point - from System import Array - - items = Array.CreateInstance(Point, 5) - - for i in range(5): - items[i] = Point(i, i) - - for i in range(5): - # Boxed items, so set_attr will not change the array member. - self.assertTrue(items[i].X == i) - self.assertTrue(items[i].Y == i) - items[i].X = i + 1 - items[i].Y = i + 1 - self.assertTrue(items[i].X == i) - self.assertTrue(items[i].Y == i) - - for i in range(5): - # Demonstrates the workaround that will change the members. - self.assertTrue(items[i].X == i) - self.assertTrue(items[i].Y == i) - item = items[i] - item.X = i + 1 - item.Y = i + 1 - items[i] = item - self.assertTrue(items[i].X == i + 1) - self.assertTrue(items[i].Y == i + 1) - - def test_special_array_creation(self): - """Test using the Array[] syntax for creating arrays.""" - from Python.Test import ISayHello1, InterfaceTest, ShortEnum - from System import Array - inst = InterfaceTest() - - value = Array[System.Boolean]([True, True]) - self.assertTrue(value[0] is True) - self.assertTrue(value[1] is True) - self.assertTrue(value.Length == 2) - - value = Array[bool]([True, True]) - self.assertTrue(value[0] is True) - self.assertTrue(value[1] is True) - self.assertTrue(value.Length == 2) - - value = Array[System.Byte]([0, 255]) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 255) - self.assertTrue(value.Length == 2) - - value = Array[System.SByte]([0, 127]) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 127) - self.assertTrue(value.Length == 2) - - value = Array[System.Char]([u'A', u'Z']) - self.assertTrue(value[0] == u'A') - self.assertTrue(value[1] == u'Z') - self.assertTrue(value.Length == 2) - - value = Array[System.Char]([0, 65535]) - self.assertTrue(value[0] == unichr(0)) - self.assertTrue(value[1] == unichr(65535)) - self.assertTrue(value.Length == 2) - - value = Array[System.Int16]([0, 32767]) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 32767) - self.assertTrue(value.Length == 2) - - value = Array[System.Int32]([0, 2147483647]) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 2147483647) - self.assertTrue(value.Length == 2) - - value = Array[int]([0, 2147483647]) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 2147483647) - self.assertTrue(value.Length == 2) - - value = Array[System.Int64]([0, long(9223372036854775807)]) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == long(9223372036854775807)) - self.assertTrue(value.Length == 2) - - # there's no explicit long type in python3, use System.Int64 instead - if PY2: - value = Array[long]([0, long(9223372036854775807)]) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == long(9223372036854775807)) - self.assertTrue(value.Length == 2) - - value = Array[System.UInt16]([0, 65000]) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 65000) - self.assertTrue(value.Length == 2) - - value = Array[System.UInt32]([0, long(4294967295)]) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == long(4294967295)) - self.assertTrue(value.Length == 2) - - value = Array[System.UInt64]([0, long(18446744073709551615)]) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == long(18446744073709551615)) - self.assertTrue(value.Length == 2) - - value = Array[System.Single]([0.0, 3.402823e38]) - self.assertTrue(value[0] == 0.0) - self.assertTrue(value[1] == 3.402823e38) - self.assertTrue(value.Length == 2) - - value = Array[System.Double]([0.0, 1.7976931348623157e308]) - self.assertTrue(value[0] == 0.0) - self.assertTrue(value[1] == 1.7976931348623157e308) - self.assertTrue(value.Length == 2) - - value = Array[float]([0.0, 1.7976931348623157e308]) - self.assertTrue(value[0] == 0.0) - self.assertTrue(value[1] == 1.7976931348623157e308) - self.assertTrue(value.Length == 2) - - value = Array[System.Decimal]([System.Decimal.Zero, System.Decimal.One]) - self.assertTrue(value[0] == System.Decimal.Zero) - self.assertTrue(value[1] == System.Decimal.One) - self.assertTrue(value.Length == 2) - - value = Array[System.String](["one", "two"]) - self.assertTrue(value[0] == "one") - self.assertTrue(value[1] == "two") - self.assertTrue(value.Length == 2) - - value = Array[str](["one", "two"]) - self.assertTrue(value[0] == "one") - self.assertTrue(value[1] == "two") - self.assertTrue(value.Length == 2) - - value = Array[ShortEnum]([ShortEnum.Zero, ShortEnum.One]) - self.assertTrue(value[0] == ShortEnum.Zero) - self.assertTrue(value[1] == ShortEnum.One) - self.assertTrue(value.Length == 2) - - value = Array[System.Object]([inst, inst]) - self.assertTrue(value[0].__class__ == inst.__class__) - self.assertTrue(value[1].__class__ == inst.__class__) - self.assertTrue(value.Length == 2) - - value = Array[InterfaceTest]([inst, inst]) - self.assertTrue(value[0].__class__ == inst.__class__) - self.assertTrue(value[1].__class__ == inst.__class__) - self.assertTrue(value.Length == 2) - - value = Array[ISayHello1]([inst, inst]) - self.assertTrue(value[0].__class__ == inst.__class__) - self.assertTrue(value[1].__class__ == inst.__class__) - self.assertTrue(value.Length == 2) - - inst = System.Exception("badness") - value = Array[System.Exception]([inst, inst]) - self.assertTrue(value[0].__class__ == inst.__class__) - self.assertTrue(value[1].__class__ == inst.__class__) - self.assertTrue(value.Length == 2) - - def test_array_abuse(self): - """Test array abuse.""" - _class = Test.PublicArrayTest - ob = Test.PublicArrayTest() - - with self.assertRaises(AttributeError): - del _class.__getitem__ - - with self.assertRaises(AttributeError): - del ob.__getitem__ - - with self.assertRaises(AttributeError): - del _class.__setitem__ - - with self.assertRaises(AttributeError): - del ob.__setitem__ - - with self.assertRaises(TypeError): - Test.PublicArrayTest.__getitem__(0, 0) - - with self.assertRaises(TypeError): - Test.PublicArrayTest.__setitem__(0, 0, 0) - - with self.assertRaises(TypeError): - desc = Test.PublicArrayTest.__dict__['__getitem__'] - desc(0, 0) - - with self.assertRaises(TypeError): - desc = Test.PublicArrayTest.__dict__['__setitem__'] - desc(0, 0, 0) - - -def test_suite(): - return unittest.makeSuite(ArrayTests) + items = Array.CreateInstance(Spam, 5, 5) + + for i in range(5): + for n in range(5): + items.SetValue(Spam(str((i, n))), (i, n)) + + result = ArrayConversionTest.EchoRangeMD(items) + + assert len(result) == 25 + assert result[0, 0].__class__ == Spam + assert result[0, 0].__class__ == Spam + + +def test_boxed_value_type_mutation_result(): + """Test behavior of boxed value types.""" + + # This test actually exists mostly as documentation of an important + # concern when dealing with value types. Python does not have any + # value type semantics that can be mapped to the CLR, so it is easy + # to accidentally write code like the following which is not really + # mutating value types in-place but changing boxed copies. + + from System.Drawing import Point + from System import Array + + items = Array.CreateInstance(Point, 5) + + for i in range(5): + items[i] = Point(i, i) + + for i in range(5): + # Boxed items, so set_attr will not change the array member. + assert items[i].X == i + assert items[i].Y == i + items[i].X = i + 1 + items[i].Y = i + 1 + assert items[i].X == i + assert items[i].Y == i + + for i in range(5): + # Demonstrates the workaround that will change the members. + assert items[i].X == i + assert items[i].Y == i + item = items[i] + item.X = i + 1 + item.Y = i + 1 + items[i] = item + assert items[i].X == i + 1 + assert items[i].Y == i + 1 + + +def test_special_array_creation(): + """Test using the Array[] syntax for creating arrays.""" + from Python.Test import ISayHello1, InterfaceTest, ShortEnum + from System import Array + inst = InterfaceTest() + + value = Array[System.Boolean]([True, True]) + assert value[0] is True + assert value[1] is True + assert value.Length == 2 + + value = Array[bool]([True, True]) + assert value[0] is True + assert value[1] is True + assert value.Length == 2 + + value = Array[System.Byte]([0, 255]) + assert value[0] == 0 + assert value[1] == 255 + assert value.Length == 2 + + value = Array[System.SByte]([0, 127]) + assert value[0] == 0 + assert value[1] == 127 + assert value.Length == 2 + + value = Array[System.Char]([u'A', u'Z']) + assert value[0] == u'A' + assert value[1] == u'Z' + assert value.Length == 2 + + value = Array[System.Char]([0, 65535]) + assert value[0] == unichr(0) + assert value[1] == unichr(65535) + assert value.Length == 2 + + value = Array[System.Int16]([0, 32767]) + assert value[0] == 0 + assert value[1] == 32767 + assert value.Length == 2 + + value = Array[System.Int32]([0, 2147483647]) + assert value[0] == 0 + assert value[1] == 2147483647 + assert value.Length == 2 + + value = Array[int]([0, 2147483647]) + assert value[0] == 0 + assert value[1] == 2147483647 + assert value.Length == 2 + + value = Array[System.Int64]([0, long(9223372036854775807)]) + assert value[0] == 0 + assert value[1] == long(9223372036854775807) + assert value.Length == 2 + + # there's no explicit long type in python3, use System.Int64 instead + if PY2: + value = Array[long]([0, long(9223372036854775807)]) + assert value[0] == 0 + assert value[1] == long(9223372036854775807) + assert value.Length == 2 + + value = Array[System.UInt16]([0, 65000]) + assert value[0] == 0 + assert value[1] == 65000 + assert value.Length == 2 + + value = Array[System.UInt32]([0, long(4294967295)]) + assert value[0] == 0 + assert value[1] == long(4294967295) + assert value.Length == 2 + + value = Array[System.UInt64]([0, long(18446744073709551615)]) + assert value[0] == 0 + assert value[1] == long(18446744073709551615) + assert value.Length == 2 + + value = Array[System.Single]([0.0, 3.402823e38]) + assert value[0] == 0.0 + assert value[1] == 3.402823e38 + assert value.Length == 2 + + value = Array[System.Double]([0.0, 1.7976931348623157e308]) + assert value[0] == 0.0 + assert value[1] == 1.7976931348623157e308 + assert value.Length == 2 + + value = Array[float]([0.0, 1.7976931348623157e308]) + assert value[0] == 0.0 + assert value[1] == 1.7976931348623157e308 + assert value.Length == 2 + + value = Array[System.Decimal]([System.Decimal.Zero, System.Decimal.One]) + assert value[0] == System.Decimal.Zero + assert value[1] == System.Decimal.One + assert value.Length == 2 + + value = Array[System.String](["one", "two"]) + assert value[0] == "one" + assert value[1] == "two" + assert value.Length == 2 + + value = Array[str](["one", "two"]) + assert value[0] == "one" + assert value[1] == "two" + assert value.Length == 2 + + value = Array[ShortEnum]([ShortEnum.Zero, ShortEnum.One]) + assert value[0] == ShortEnum.Zero + assert value[1] == ShortEnum.One + assert value.Length == 2 + + value = Array[System.Object]([inst, inst]) + assert value[0].__class__ == inst.__class__ + assert value[1].__class__ == inst.__class__ + assert value.Length == 2 + + value = Array[InterfaceTest]([inst, inst]) + assert value[0].__class__ == inst.__class__ + assert value[1].__class__ == inst.__class__ + assert value.Length == 2 + + value = Array[ISayHello1]([inst, inst]) + assert value[0].__class__ == inst.__class__ + assert value[1].__class__ == inst.__class__ + assert value.Length == 2 + + inst = System.Exception("badness") + value = Array[System.Exception]([inst, inst]) + assert value[0].__class__ == inst.__class__ + assert value[1].__class__ == inst.__class__ + assert value.Length == 2 + + +def test_array_abuse(): + """Test array abuse.""" + _class = Test.PublicArrayTest + ob = Test.PublicArrayTest() + + with pytest.raises(AttributeError): + del _class.__getitem__ + + with pytest.raises(AttributeError): + del ob.__getitem__ + + with pytest.raises(AttributeError): + del _class.__setitem__ + + with pytest.raises(AttributeError): + del ob.__setitem__ + + with pytest.raises(TypeError): + Test.PublicArrayTest.__getitem__(0, 0) + + with pytest.raises(TypeError): + Test.PublicArrayTest.__setitem__(0, 0, 0) + + with pytest.raises(TypeError): + desc = Test.PublicArrayTest.__dict__['__getitem__'] + desc(0, 0) + + with pytest.raises(TypeError): + desc = Test.PublicArrayTest.__dict__['__setitem__'] + desc(0, 0, 0) diff --git a/src/tests/test_callback.py b/src/tests/test_callback.py new file mode 100644 index 000000000..f94a9d52e --- /dev/null +++ b/src/tests/test_callback.py @@ -0,0 +1,27 @@ +# -*- coding: utf-8 -*- + +"""Test that callbacks from C# into python work.""" + + +def simpleDefaultArg(arg='test'): + return arg + + +def test_default_for_null(): + """Test that C# can use null for an optional python argument""" + from Python.Test import CallbackTest + + test_instance = CallbackTest() + ret_val = test_instance.Call_simpleDefaultArg_WithNull(__name__) + python_ret_val = simpleDefaultArg(None) + assert ret_val == python_ret_val + + +def test_default_for_none(): + """Test that C# can use no argument for an optional python argument""" + from Python.Test import CallbackTest + + test_instance = CallbackTest() + ret_val = test_instance.Call_simpleDefaultArg_WithEmptyArgs(__name__) + python_ret_val = simpleDefaultArg() + assert ret_val == python_ret_val diff --git a/src/tests/test_class.py b/src/tests/test_class.py index bf3b6f143..68773508b 100644 --- a/src/tests/test_class.py +++ b/src/tests/test_class.py @@ -1,130 +1,138 @@ # -*- coding: utf-8 -*- # TODO: Add tests for ClassicClass, NewStyleClass? -import unittest +"""Test CLR class support.""" import Python.Test as Test import System +import pytest -from _compat import DictProxyType, range +from ._compat import DictProxyType, range -class ClassTests(unittest.TestCase): - """Test CLR class support.""" +def test_basic_reference_type(): + """Test usage of CLR defined reference types.""" + assert System.String.Empty == "" - def test_basic_reference_type(self): - """Test usage of CLR defined reference types.""" - self.assertEquals(System.String.Empty, "") - def test_basic_value_type(self): - """Test usage of CLR defined value types.""" - self.assertEquals(System.Int32.MaxValue, 2147483647) +def test_basic_value_type(): + """Test usage of CLR defined value types.""" + assert System.Int32.MaxValue == 2147483647 - def test_class_standard_attrs(self): - """Test standard class attributes.""" - from Python.Test import ClassTest - self.assertTrue(ClassTest.__name__ == 'ClassTest') - self.assertTrue(ClassTest.__module__ == 'Python.Test') - self.assertTrue(isinstance(ClassTest.__dict__, DictProxyType)) - self.assertTrue(len(ClassTest.__doc__) > 0) +def test_class_standard_attrs(): + """Test standard class attributes.""" + from Python.Test import ClassTest - def test_class_docstrings(self): - """Test standard class docstring generation""" - from Python.Test import ClassTest + assert ClassTest.__name__ == 'ClassTest' + assert ClassTest.__module__ == 'Python.Test' + assert isinstance(ClassTest.__dict__, DictProxyType) + assert len(ClassTest.__doc__) > 0 - value = 'Void .ctor()' - self.assertTrue(ClassTest.__doc__ == value) - def test_class_default_str(self): - """Test the default __str__ implementation for managed objects.""" - s = System.String("this is a test") - self.assertTrue(str(s) == "this is a test") +def test_class_docstrings(): + """Test standard class docstring generation""" + from Python.Test import ClassTest - def test_class_default_repr(self): - """Test the default __repr__ implementation for managed objects.""" - s = System.String("this is a test") - self.assertTrue(repr(s).startswith(" -1) and (item < 10) + + dict_ = ClassTest.GetHashtable() + + for item in dict_: + cname = item.__class__.__name__ + assert cname.endswith('DictionaryEntry') + - for item in list_: - self.assertTrue((item > -1) and (item < 10)) +def test_ienumerator_iteration(): + """Test iteration over objects supporting IEnumerator.""" + from Python.Test import ClassTest - dict_ = ClassTest.GetHashtable() + chars = ClassTest.GetEnumerator() - for item in dict_: - cname = item.__class__.__name__ - self.assertTrue(cname.endswith('DictionaryEntry')) + for item in chars: + assert item in 'test string' - def test_ienumerator_iteration(self): - """Test iteration over objects supporting IEnumerator.""" - from Python.Test import ClassTest - chars = ClassTest.GetEnumerator() +def test_override_get_item(): + """Test managed subclass overriding __getitem__.""" + from System.Collections import Hashtable - for item in chars: - self.assertTrue(item in 'test string') + class MyTable(Hashtable): + def __getitem__(self, key): + value = Hashtable.__getitem__(self, key) + return 'my ' + str(value) - def test_override_get_item(self): - """Test managed subclass overriding __getitem__.""" - from System.Collections import Hashtable + table = MyTable() + table['one'] = 'one' + table['two'] = 'two' + table['three'] = 'three' - class MyTable(Hashtable): - def __getitem__(self, key): - value = Hashtable.__getitem__(self, key) - return 'my ' + str(value) + assert table['one'] == 'my one' + assert table['two'] == 'my two' + assert table['three'] == 'my three' - table = MyTable() - table['one'] = 'one' - table['two'] = 'two' - table['three'] = 'three' + assert table.Count == 3 - self.assertTrue(table['one'] == 'my one') - self.assertTrue(table['two'] == 'my two') - self.assertTrue(table['three'] == 'my three') - self.assertTrue(table.Count == 3) +def test_override_set_item(): + """Test managed subclass overriding __setitem__.""" + from System.Collections import Hashtable - def test_override_set_item(self): - """Test managed subclass overriding __setitem__.""" - from System.Collections import Hashtable + class MyTable(Hashtable): + def __setitem__(self, key, value): + value = 'my ' + str(value) + Hashtable.__setitem__(self, key, value) - class MyTable(Hashtable): - def __setitem__(self, key, value): - value = 'my ' + str(value) - Hashtable.__setitem__(self, key, value) + table = MyTable() + table['one'] = 'one' + table['two'] = 'two' + table['three'] = 'three' - table = MyTable() - table['one'] = 'one' - table['two'] = 'two' - table['three'] = 'three' + assert table['one'] == 'my one' + assert table['two'] == 'my two' + assert table['three'] == 'my three' - self.assertTrue(table['one'] == 'my one') - self.assertTrue(table['two'] == 'my two') - self.assertTrue(table['three'] == 'my three') + assert table.Count == 3 - self.assertTrue(table.Count == 3) - def test_add_and_remove_class_attribute(self): - from System import TimeSpan +def test_add_and_remove_class_attribute(): + from System import TimeSpan - for _ in range(100): - TimeSpan.new_method = lambda self_: self_.TotalMinutes - ts = TimeSpan.FromHours(1) - self.assertTrue(ts.new_method() == 60) - del TimeSpan.new_method - self.assertFalse(hasattr(ts, "new_method")) + for _ in range(100): + TimeSpan.new_method = lambda self_: self_.TotalMinutes + ts = TimeSpan.FromHours(1) + assert ts.new_method() == 60 + del TimeSpan.new_method + assert not hasattr(ts, "new_method") - def test_comparisons(self): - from System import DateTimeOffset - from Python.Test import ClassTest - d1 = DateTimeOffset.Parse("2016-11-14") - d2 = DateTimeOffset.Parse("2016-11-15") +def test_comparisons(): + from System import DateTimeOffset + from Python.Test import ClassTest - self.assertEqual(d1 == d2, False) - self.assertEqual(d1 != d2, True) + d1 = DateTimeOffset.Parse("2016-11-14") + d2 = DateTimeOffset.Parse("2016-11-15") - self.assertEqual(d1 < d2, True) - self.assertEqual(d1 <= d2, True) - self.assertEqual(d1 >= d2, False) - self.assertEqual(d1 > d2, False) + assert (d1 == d2) == False + assert (d1 != d2) == True - self.assertEqual(d1 == d1, True) - self.assertEqual(d1 != d1, False) + assert (d1 < d2) == True + assert (d1 <= d2) == True + assert (d1 >= d2) == False + assert (d1 > d2) == False - self.assertEqual(d1 < d1, False) - self.assertEqual(d1 <= d1, True) - self.assertEqual(d1 >= d1, True) - self.assertEqual(d1 > d1, False) + assert (d1 == d1) == True + assert (d1 != d1) == False - self.assertEqual(d2 == d1, False) - self.assertEqual(d2 != d1, True) + assert (d1 < d1) == False + assert (d1 <= d1) == True + assert (d1 >= d1) == True + assert (d1 > d1) == False - self.assertEqual(d2 < d1, False) - self.assertEqual(d2 <= d1, False) - self.assertEqual(d2 >= d1, True) - self.assertEqual(d2 > d1, True) + assert (d2 == d1) == False + assert (d2 != d1) == True - with self.assertRaises(TypeError): - d1 < None + assert (d2 < d1) == False + assert (d2 <= d1) == False + assert (d2 >= d1) == True + assert (d2 > d1) == True - with self.assertRaises(TypeError): - d1 < System.Guid() + with pytest.raises(TypeError): + d1 < None - # ClassTest does not implement IComparable - c1 = ClassTest() - c2 = ClassTest() - with self.assertRaises(TypeError): - c1 < c2 + with pytest.raises(TypeError): + d1 < System.Guid() - def test_self_callback(self): - """Test calling back and forth between this and a c# baseclass.""" + # ClassTest does not implement IComparable + c1 = ClassTest() + c2 = ClassTest() + with pytest.raises(TypeError): + c1 < c2 - class CallbackUser(Test.SelfCallbackTest): - def DoCallback(self): - self.PyCallbackWasCalled = False - self.SameReference = False - return self.Callback(self) - def PyCallback(self, self2): - self.PyCallbackWasCalled = True - self.SameReference = self == self2 +def test_self_callback(): + """Test calling back and forth between this and a c# baseclass.""" - testobj = CallbackUser() - testobj.DoCallback() - self.assertTrue(testobj.PyCallbackWasCalled) - self.assertTrue(testobj.SameReference) + class CallbackUser(Test.SelfCallbackTest): + def DoCallback(self): + self.PyCallbackWasCalled = False + self.SameReference = False + return self.Callback(self) + def PyCallback(self, self2): + self.PyCallbackWasCalled = True + self.SameReference = self == self2 -def test_suite(): - return unittest.makeSuite(ClassTests) + testobj = CallbackUser() + testobj.DoCallback() + assert testobj.PyCallbackWasCalled + assert testobj.SameReference diff --git a/src/tests/test_compat.py b/src/tests/test_compat.py index cea51ca49..81e7f8143 100644 --- a/src/tests/test_compat.py +++ b/src/tests/test_compat.py @@ -1,233 +1,243 @@ # -*- coding: utf-8 -*- # TODO: Complete removal of methods below. Similar to test_module +"""Backward-compatibility tests for deprecated features.""" + import types -import unittest -from _compat import ClassType, PY2, PY3, range -from utils import is_clr_class, is_clr_module, is_clr_root_module +import pytest +from ._compat import ClassType, PY2, PY3, range +from .utils import is_clr_class, is_clr_module, is_clr_root_module -class CompatibilityTests(unittest.TestCase): - """Backward-compatibility tests for deprecated features.""" - # Tests for old-style CLR-prefixed module naming. +# Tests for old-style CLR-prefixed module naming. +def test_simple_import(): + """Test simple import.""" + import CLR + assert is_clr_root_module(CLR) + assert CLR.__name__ == 'clr' - def test_simple_import(self): - """Test simple import.""" - import CLR - self.assertTrue(is_clr_root_module(CLR)) - self.assertTrue(CLR.__name__ == 'clr') - - import sys - self.assertTrue(isinstance(sys, types.ModuleType)) - self.assertTrue(sys.__name__ == 'sys') - - if PY3: - import http.client - self.assertTrue(isinstance(http.client, types.ModuleType)) - self.assertTrue(http.client.__name__ == 'http.client') - - elif PY2: - import httplib - self.assertTrue(isinstance(httplib, types.ModuleType)) - self.assertTrue(httplib.__name__ == 'httplib') - - def test_simple_import_with_alias(self): - """Test simple import with aliasing.""" - import CLR as myCLR - self.assertTrue(is_clr_root_module(myCLR)) - self.assertTrue(myCLR.__name__ == 'clr') - - import sys as mySys - self.assertTrue(isinstance(mySys, types.ModuleType)) - self.assertTrue(mySys.__name__ == 'sys') - - if PY3: - import http.client as myHttplib - self.assertTrue(isinstance(myHttplib, types.ModuleType)) - self.assertTrue(myHttplib.__name__ == 'http.client') - - elif PY2: - import httplib as myHttplib - self.assertTrue(isinstance(myHttplib, types.ModuleType)) - self.assertTrue(myHttplib.__name__ == 'httplib') - - def test_dotted_name_import(self): - """Test dotted-name import.""" - import CLR.System - self.assertTrue(is_clr_module(CLR.System)) - self.assertTrue(CLR.System.__name__ == 'System') - - import System - self.assertTrue(is_clr_module(System)) - self.assertTrue(System.__name__ == 'System') - - self.assertTrue(System is CLR.System) - - import xml.dom - self.assertTrue(isinstance(xml.dom, types.ModuleType)) - self.assertTrue(xml.dom.__name__ == 'xml.dom') - - def test_dotted_name_import_with_alias(self): - """Test dotted-name import with aliasing.""" - import CLR.System as myCLRSystem - self.assertTrue(is_clr_module(myCLRSystem)) - self.assertTrue(myCLRSystem.__name__ == 'System') - - import System as mySystem - self.assertTrue(is_clr_module(mySystem)) - self.assertTrue(mySystem.__name__ == 'System') - - self.assertTrue(mySystem is myCLRSystem) - - import xml.dom as myDom - self.assertTrue(isinstance(myDom, types.ModuleType)) - self.assertTrue(myDom.__name__ == 'xml.dom') - - def test_simple_import_from(self): - """Test simple 'import from'.""" - from CLR import System - self.assertTrue(is_clr_module(System)) - self.assertTrue(System.__name__ == 'System') - - from xml import dom - self.assertTrue(isinstance(dom, types.ModuleType)) - self.assertTrue(dom.__name__ == 'xml.dom') - - def test_simple_import_from_with_alias(self): - """Test simple 'import from' with aliasing.""" - from CLR import System as mySystem - self.assertTrue(is_clr_module(mySystem)) - self.assertTrue(mySystem.__name__ == 'System') - - from xml import dom as myDom - self.assertTrue(isinstance(myDom, types.ModuleType)) - self.assertTrue(myDom.__name__ == 'xml.dom') - - def test_dotted_name_import_from(self): - """Test dotted-name 'import from'.""" - from CLR.System import Xml - self.assertTrue(is_clr_module(Xml)) - self.assertTrue(Xml.__name__ == 'System.Xml') - - from CLR.System.Xml import XmlDocument - self.assertTrue(is_clr_class(XmlDocument)) - self.assertTrue(XmlDocument.__name__ == 'XmlDocument') - - from xml.dom import pulldom - self.assertTrue(isinstance(pulldom, types.ModuleType)) - self.assertTrue(pulldom.__name__ == 'xml.dom.pulldom') - - from xml.dom.pulldom import PullDOM - self.assertTrue(isinstance(PullDOM, ClassType)) - self.assertTrue(PullDOM.__name__ == 'PullDOM') - - def test_dotted_name_import_from_with_alias(self): - """Test dotted-name 'import from' with aliasing.""" - from CLR.System import Xml as myXml - self.assertTrue(is_clr_module(myXml)) - self.assertTrue(myXml.__name__ == 'System.Xml') - - from CLR.System.Xml import XmlDocument as myXmlDocument - self.assertTrue(is_clr_class(myXmlDocument)) - self.assertTrue(myXmlDocument.__name__ == 'XmlDocument') - - from xml.dom import pulldom as myPulldom - self.assertTrue(isinstance(myPulldom, types.ModuleType)) - self.assertTrue(myPulldom.__name__ == 'xml.dom.pulldom') - - from xml.dom.pulldom import PullDOM as myPullDOM - self.assertTrue(isinstance(myPullDOM, ClassType)) - self.assertTrue(myPullDOM.__name__ == 'PullDOM') - - def test_from_module_import_star(self): - """Test from module import * behavior.""" - count = len(locals().keys()) - m = __import__('CLR.System.Management', globals(), locals(), ['*']) - self.assertTrue(m.__name__ == 'System.Management') - self.assertTrue(is_clr_module(m)) - self.assertTrue(len(locals().keys()) > count + 1) - - m2 = __import__('System.Management', globals(), locals(), ['*']) - self.assertTrue(m2.__name__ == 'System.Management') - self.assertTrue(is_clr_module(m2)) - self.assertTrue(len(locals().keys()) > count + 1) - - self.assertTrue(m is m2) - - def test_explicit_assembly_load(self): - """Test explicit assembly loading using standard CLR tools.""" - from CLR.System.Reflection import Assembly - from CLR import System - import sys - - assembly = Assembly.LoadWithPartialName('System.Data') - self.assertTrue(assembly is not None) - - import CLR.System.Data - self.assertTrue('System.Data' in sys.modules) - - assembly = Assembly.LoadWithPartialName('SpamSpamSpamSpamEggsAndSpam') - self.assertTrue(assembly is None) - - def test_implicit_load_already_valid_namespace(self): - """Test implicit assembly load over an already valid namespace.""" - # In this case, the mscorlib assembly (loaded by default) defines - # a number of types in the System namespace. There is also a System - # assembly, which is _not_ loaded by default, which also contains - # types in the System namespace. The desired behavior is for the - # Python runtime to "do the right thing", allowing types from both - # assemblies to be found in the CLR.System module implicitly. - import CLR.System - self.assertTrue(is_clr_class(CLR.System.UriBuilder)) - - def test_import_non_existant_module(self): - """Test import failure for a non-existent module.""" - with self.assertRaises(ImportError): - import System.SpamSpamSpam - - with self.assertRaises(ImportError): - import CLR.System.SpamSpamSpam - - def test_lookup_no_namespace_type(self): - """Test lookup of types without a qualified namespace.""" - import CLR.Python.Test - import CLR - self.assertTrue(is_clr_class(CLR.NoNamespaceType)) + import sys + assert isinstance(sys, types.ModuleType) + assert sys.__name__ == 'sys' + + if PY3: + import http.client + assert isinstance(http.client, types.ModuleType) + assert http.client.__name__ == 'http.client' + + elif PY2: + import httplib + assert isinstance(httplib, types.ModuleType) + assert httplib.__name__ == 'httplib' + + +def test_simple_import_with_alias(): + """Test simple import with aliasing.""" + import CLR as myCLR + assert is_clr_root_module(myCLR) + assert myCLR.__name__ == 'clr' + + import sys as mySys + assert isinstance(mySys, types.ModuleType) + assert mySys.__name__ == 'sys' + + if PY3: + import http.client as myHttplib + assert isinstance(myHttplib, types.ModuleType) + assert myHttplib.__name__ == 'http.client' + + elif PY2: + import httplib as myHttplib + assert isinstance(myHttplib, types.ModuleType) + assert myHttplib.__name__ == 'httplib' + + +def test_dotted_name_import(): + """Test dotted-name import.""" + import CLR.System + assert is_clr_module(CLR.System) + assert CLR.System.__name__ == 'System' + + import System + assert is_clr_module(System) + assert System.__name__ == 'System' + + assert System is CLR.System + + import xml.dom + assert isinstance(xml.dom, types.ModuleType) + assert xml.dom.__name__ == 'xml.dom' + + +def test_dotted_name_import_with_alias(): + """Test dotted-name import with aliasing.""" + import CLR.System as myCLRSystem + assert is_clr_module(myCLRSystem) + assert myCLRSystem.__name__ == 'System' + + import System as mySystem + assert is_clr_module(mySystem) + assert mySystem.__name__ == 'System' + + assert mySystem is myCLRSystem + + import xml.dom as myDom + assert isinstance(myDom, types.ModuleType) + assert myDom.__name__ == 'xml.dom' + + +def test_simple_import_from(): + """Test simple 'import from'.""" + from CLR import System + assert is_clr_module(System) + assert System.__name__ == 'System' + + from xml import dom + assert isinstance(dom, types.ModuleType) + assert dom.__name__ == 'xml.dom' + + +def test_simple_import_from_with_alias(): + """Test simple 'import from' with aliasing.""" + from CLR import System as mySystem + assert is_clr_module(mySystem) + assert mySystem.__name__ == 'System' + + from xml import dom as myDom + assert isinstance(myDom, types.ModuleType) + assert myDom.__name__ == 'xml.dom' + + +def test_dotted_name_import_from(): + """Test dotted-name 'import from'.""" + from CLR.System import Xml + assert is_clr_module(Xml) + assert Xml.__name__ == 'System.Xml' - def test_module_lookup_recursion(self): - """Test for recursive lookup handling.""" - with self.assertRaises(ImportError): - from CLR import CLR + from CLR.System.Xml import XmlDocument + assert is_clr_class(XmlDocument) + assert XmlDocument.__name__ == 'XmlDocument' - with self.assertRaises(AttributeError): - import CLR - _ = CLR.CLR + from xml.dom import pulldom + assert isinstance(pulldom, types.ModuleType) + assert pulldom.__name__ == 'xml.dom.pulldom' - def test_module_get_attr(self): - """Test module getattr behavior.""" - import CLR.System as System + from xml.dom.pulldom import PullDOM + assert isinstance(PullDOM, ClassType) + assert PullDOM.__name__ == 'PullDOM' - int_type = System.Int32 - self.assertTrue(is_clr_class(int_type)) - module = System.Xml - self.assertTrue(is_clr_module(module)) +def test_dotted_name_import_from_with_alias(): + """Test dotted-name 'import from' with aliasing.""" + from CLR.System import Xml as myXml + assert is_clr_module(myXml) + assert myXml.__name__ == 'System.Xml' - with self.assertRaises(AttributeError): - _ = System.Spam + from CLR.System.Xml import XmlDocument as myXmlDocument + assert is_clr_class(myXmlDocument) + assert myXmlDocument.__name__ == 'XmlDocument' - with self.assertRaises(TypeError): - _ = getattr(System, 1) + from xml.dom import pulldom as myPulldom + assert isinstance(myPulldom, types.ModuleType) + assert myPulldom.__name__ == 'xml.dom.pulldom' - def test_multiple_imports(self): - # import CLR did raise a Seg Fault once - # test if the Exceptions.warn() method still causes it - for _ in range(100): - import CLR - _ = CLR + from xml.dom.pulldom import PullDOM as myPullDOM + assert isinstance(myPullDOM, ClassType) + assert myPullDOM.__name__ == 'PullDOM' -def test_suite(): - return unittest.makeSuite(CompatibilityTests) +def test_from_module_import_star(): + """Test from module import * behavior.""" + count = len(locals().keys()) + m = __import__('CLR.System.Management', globals(), locals(), ['*']) + assert m.__name__ == 'System.Management' + assert is_clr_module(m) + assert len(locals().keys()) > count + 1 + + m2 = __import__('System.Management', globals(), locals(), ['*']) + assert m2.__name__ == 'System.Management' + assert is_clr_module(m2) + assert len(locals().keys()) > count + 1 + + assert m is m2 + + +def test_explicit_assembly_load(): + """Test explicit assembly loading using standard CLR tools.""" + from CLR.System.Reflection import Assembly + from CLR import System + import sys + + assembly = Assembly.LoadWithPartialName('System.Data') + assert assembly is not None + + import CLR.System.Data + assert 'System.Data' in sys.modules + + assembly = Assembly.LoadWithPartialName('SpamSpamSpamSpamEggsAndSpam') + assert assembly is None + + +def test_implicit_load_already_valid_namespace(): + """Test implicit assembly load over an already valid namespace.""" + # In this case, the mscorlib assembly (loaded by default) defines + # a number of types in the System namespace. There is also a System + # assembly, which is _not_ loaded by default, which also contains + # types in the System namespace. The desired behavior is for the + # Python runtime to "do the right thing", allowing types from both + # assemblies to be found in the CLR.System module implicitly. + import CLR.System + assert is_clr_class(CLR.System.UriBuilder) + + +def test_import_non_existant_module(): + """Test import failure for a non-existent module.""" + with pytest.raises(ImportError): + import System.SpamSpamSpam + + with pytest.raises(ImportError): + import CLR.System.SpamSpamSpam + + +def test_lookup_no_namespace_type(): + """Test lookup of types without a qualified namespace.""" + import CLR.Python.Test + import CLR + assert is_clr_class(CLR.NoNamespaceType) + + +def test_module_lookup_recursion(): + """Test for recursive lookup handling.""" + with pytest.raises(ImportError): + from CLR import CLR + + with pytest.raises(AttributeError): + import CLR + _ = CLR.CLR + + +def test_module_get_attr(): + """Test module getattr behavior.""" + import CLR.System as System + + int_type = System.Int32 + assert is_clr_class(int_type) + + module = System.Xml + assert is_clr_module(module) + + with pytest.raises(AttributeError): + _ = System.Spam + + with pytest.raises(TypeError): + _ = getattr(System, 1) + + +def test_multiple_imports(): + # import CLR did raise a Seg Fault once + # test if the Exceptions.warn() method still causes it + for _ in range(100): + import CLR + _ = CLR diff --git a/src/tests/test_constructors.py b/src/tests/test_constructors.py index 0039f9bf3..5e5489630 100644 --- a/src/tests/test_constructors.py +++ b/src/tests/test_constructors.py @@ -1,50 +1,46 @@ # -*- coding: utf-8 -*- -import unittest +"""Test CLR class constructor support.""" import System -class ConstructorTests(unittest.TestCase): - """Test CLR class constructor support.""" +def test_enum_constructor(): + """Test enum constructor args""" + from System import TypeCode + from Python.Test import EnumConstructorTest - def test_enum_constructor(self): - """Test enum constructor args""" - from System import TypeCode - from Python.Test import EnumConstructorTest + ob = EnumConstructorTest(TypeCode.Int32) + assert ob.value == TypeCode.Int32 - ob = EnumConstructorTest(TypeCode.Int32) - self.assertTrue(ob.value == TypeCode.Int32) - def test_flags_constructor(self): - """Test flags constructor args""" - from Python.Test import FlagsConstructorTest - from System.IO import FileAccess +def test_flags_constructor(): + """Test flags constructor args""" + from Python.Test import FlagsConstructorTest + from System.IO import FileAccess - flags = FileAccess.Read | FileAccess.Write - ob = FlagsConstructorTest(flags) - self.assertTrue(ob.value == flags) + flags = FileAccess.Read | FileAccess.Write + ob = FlagsConstructorTest(flags) + assert ob.value == flags - def test_struct_constructor(self): - """Test struct constructor args""" - from System import Guid - from Python.Test import StructConstructorTest - guid = Guid.NewGuid() - ob = StructConstructorTest(guid) - self.assertTrue(ob.value == guid) +def test_struct_constructor(): + """Test struct constructor args""" + from System import Guid + from Python.Test import StructConstructorTest - def test_subclass_constructor(self): - """Test subclass constructor args""" - from Python.Test import SubclassConstructorTest + guid = Guid.NewGuid() + ob = StructConstructorTest(guid) + assert ob.value == guid - class Sub(System.Exception): - pass - instance = Sub() - ob = SubclassConstructorTest(instance) - self.assertTrue(isinstance(ob.value, System.Exception)) +def test_subclass_constructor(): + """Test subclass constructor args""" + from Python.Test import SubclassConstructorTest + class Sub(System.Exception): + pass -def test_suite(): - return unittest.makeSuite(ConstructorTests) + instance = Sub() + ob = SubclassConstructorTest(instance) + assert isinstance(ob.value, System.Exception) diff --git a/src/tests/test_conversion.py b/src/tests/test_conversion.py index 0d0cd4008..ac263ef5d 100644 --- a/src/tests/test_conversion.py +++ b/src/tests/test_conversion.py @@ -1,684 +1,699 @@ # -*- coding: utf-8 -*- -import unittest +"""Test CLR <-> Python type conversions.""" import System +import pytest from Python.Test import ConversionTest -from _compat import indexbytes, long, unichr +from ._compat import indexbytes, long, unichr -class ConversionTests(unittest.TestCase): - """Test CLR <-> Python type conversions.""" +def test_bool_conversion(): + """Test bool conversion.""" + ob = ConversionTest() + assert ob.BooleanField is False + assert ob.BooleanField is False + assert ob.BooleanField == 0 - def test_bool_conversion(self): - """Test bool conversion.""" - ob = ConversionTest() - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField == 0) - - ob.BooleanField = True - self.assertTrue(ob.BooleanField is True) - self.assertTrue(ob.BooleanField is True) - self.assertTrue(ob.BooleanField == 1) - - ob.BooleanField = False - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField == 0) - - ob.BooleanField = 1 - self.assertTrue(ob.BooleanField is True) - self.assertTrue(ob.BooleanField is True) - self.assertTrue(ob.BooleanField == 1) - - ob.BooleanField = 0 - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField == 0) - - ob.BooleanField = System.Boolean(None) - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField == 0) - - ob.BooleanField = System.Boolean('') - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField == 0) - - ob.BooleanField = System.Boolean(0) - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField is False) - self.assertTrue(ob.BooleanField == 0) - - ob.BooleanField = System.Boolean(1) - self.assertTrue(ob.BooleanField is True) - self.assertTrue(ob.BooleanField is True) - self.assertTrue(ob.BooleanField == 1) - - ob.BooleanField = System.Boolean('a') - self.assertTrue(ob.BooleanField is True) - self.assertTrue(ob.BooleanField is True) - self.assertTrue(ob.BooleanField == 1) - - def test_sbyte_conversion(self): - """Test sbyte conversion.""" - self.assertTrue(System.SByte.MaxValue == 127) - self.assertTrue(System.SByte.MinValue == -128) + ob.BooleanField = True + assert ob.BooleanField is True + assert ob.BooleanField is True + assert ob.BooleanField == 1 - ob = ConversionTest() - self.assertTrue(ob.SByteField == 0) + ob.BooleanField = False + assert ob.BooleanField is False + assert ob.BooleanField is False + assert ob.BooleanField == 0 - ob.SByteField = 127 - self.assertTrue(ob.SByteField == 127) + ob.BooleanField = 1 + assert ob.BooleanField is True + assert ob.BooleanField is True + assert ob.BooleanField == 1 - ob.SByteField = -128 - self.assertTrue(ob.SByteField == -128) + ob.BooleanField = 0 + assert ob.BooleanField is False + assert ob.BooleanField is False + assert ob.BooleanField == 0 - ob.SByteField = System.SByte(127) - self.assertTrue(ob.SByteField == 127) + ob.BooleanField = System.Boolean(None) + assert ob.BooleanField is False + assert ob.BooleanField is False + assert ob.BooleanField == 0 - ob.SByteField = System.SByte(-128) - self.assertTrue(ob.SByteField == -128) + ob.BooleanField = System.Boolean('') + assert ob.BooleanField is False + assert ob.BooleanField is False + assert ob.BooleanField == 0 - with self.assertRaises(TypeError): - ConversionTest().SByteField = "spam" + ob.BooleanField = System.Boolean(0) + assert ob.BooleanField is False + assert ob.BooleanField is False + assert ob.BooleanField == 0 - with self.assertRaises(TypeError): - ConversionTest().SByteField = None + ob.BooleanField = System.Boolean(1) + assert ob.BooleanField is True + assert ob.BooleanField is True + assert ob.BooleanField == 1 - with self.assertRaises(OverflowError): - ConversionTest().SByteField = 128 + ob.BooleanField = System.Boolean('a') + assert ob.BooleanField is True + assert ob.BooleanField is True + assert ob.BooleanField == 1 - with self.assertRaises(OverflowError): - ConversionTest().SByteField = -129 - with self.assertRaises(OverflowError): - _ = System.SByte(128) +def test_sbyte_conversion(): + """Test sbyte conversion.""" + assert System.SByte.MaxValue == 127 + assert System.SByte.MinValue == -128 - with self.assertRaises(OverflowError): - _ = System.SByte(-129) + ob = ConversionTest() + assert ob.SByteField == 0 - def test_byte_conversion(self): - """Test byte conversion.""" - self.assertTrue(System.Byte.MaxValue == 255) - self.assertTrue(System.Byte.MinValue == 0) + ob.SByteField = 127 + assert ob.SByteField == 127 - ob = ConversionTest() - self.assertTrue(ob.ByteField == 0) + ob.SByteField = -128 + assert ob.SByteField == -128 - ob.ByteField = 255 - self.assertTrue(ob.ByteField == 255) + ob.SByteField = System.SByte(127) + assert ob.SByteField == 127 - ob.ByteField = 0 - self.assertTrue(ob.ByteField == 0) + ob.SByteField = System.SByte(-128) + assert ob.SByteField == -128 - ob.ByteField = System.Byte(255) - self.assertTrue(ob.ByteField == 255) + with pytest.raises(TypeError): + ConversionTest().SByteField = "spam" - ob.ByteField = System.Byte(0) - self.assertTrue(ob.ByteField == 0) + with pytest.raises(TypeError): + ConversionTest().SByteField = None - with self.assertRaises(TypeError): - ConversionTest().ByteField = "spam" + with pytest.raises(OverflowError): + ConversionTest().SByteField = 128 - with self.assertRaises(TypeError): - ConversionTest().ByteField = None + with pytest.raises(OverflowError): + ConversionTest().SByteField = -129 - with self.assertRaises(OverflowError): - ConversionTest().ByteField = 256 + with pytest.raises(OverflowError): + _ = System.SByte(128) - with self.assertRaises(OverflowError): - ConversionTest().ByteField = -1 + with pytest.raises(OverflowError): + _ = System.SByte(-129) - with self.assertRaises(OverflowError): - _ = System.Byte(256) - with self.assertRaises(OverflowError): - _ = System.Byte(-1) +def test_byte_conversion(): + """Test byte conversion.""" + assert System.Byte.MaxValue == 255 + assert System.Byte.MinValue == 0 - def test_char_conversion(self): - """Test char conversion.""" - self.assertTrue(System.Char.MaxValue == unichr(65535)) - self.assertTrue(System.Char.MinValue == unichr(0)) + ob = ConversionTest() + assert ob.ByteField == 0 - ob = ConversionTest() - self.assertTrue(ob.CharField == u'A') + ob.ByteField = 255 + assert ob.ByteField == 255 - ob.CharField = 'B' - self.assertTrue(ob.CharField == u'B') + ob.ByteField = 0 + assert ob.ByteField == 0 - ob.CharField = u'B' - self.assertTrue(ob.CharField == u'B') + ob.ByteField = System.Byte(255) + assert ob.ByteField == 255 - ob.CharField = 67 - self.assertTrue(ob.CharField == u'C') + ob.ByteField = System.Byte(0) + assert ob.ByteField == 0 - with self.assertRaises(OverflowError): - ConversionTest().CharField = 65536 + with pytest.raises(TypeError): + ConversionTest().ByteField = "spam" - with self.assertRaises(OverflowError): - ConversionTest().CharField = -1 + with pytest.raises(TypeError): + ConversionTest().ByteField = None - with self.assertRaises(TypeError): - ConversionTest().CharField = None + with pytest.raises(OverflowError): + ConversionTest().ByteField = 256 - def test_int16_conversion(self): - """Test int16 conversion.""" - self.assertTrue(System.Int16.MaxValue == 32767) - self.assertTrue(System.Int16.MinValue == -32768) + with pytest.raises(OverflowError): + ConversionTest().ByteField = -1 - ob = ConversionTest() - self.assertTrue(ob.Int16Field == 0) + with pytest.raises(OverflowError): + _ = System.Byte(256) - ob.Int16Field = 32767 - self.assertTrue(ob.Int16Field == 32767) + with pytest.raises(OverflowError): + _ = System.Byte(-1) - ob.Int16Field = -32768 - self.assertTrue(ob.Int16Field == -32768) - ob.Int16Field = System.Int16(32767) - self.assertTrue(ob.Int16Field == 32767) +def test_char_conversion(): + """Test char conversion.""" + assert System.Char.MaxValue == unichr(65535) + assert System.Char.MinValue == unichr(0) - ob.Int16Field = System.Int16(-32768) - self.assertTrue(ob.Int16Field == -32768) + ob = ConversionTest() + assert ob.CharField == u'A' - with self.assertRaises(TypeError): - ConversionTest().Int16Field = "spam" + ob.CharField = 'B' + assert ob.CharField == u'B' - with self.assertRaises(TypeError): - ConversionTest().Int16Field = None + ob.CharField = u'B' + assert ob.CharField == u'B' - with self.assertRaises(OverflowError): - ConversionTest().Int16Field = 32768 + ob.CharField = 67 + assert ob.CharField == u'C' - with self.assertRaises(OverflowError): - ConversionTest().Int16Field = -32769 + with pytest.raises(OverflowError): + ConversionTest().CharField = 65536 - with self.assertRaises(OverflowError): - _ = System.Int16(32768) + with pytest.raises(OverflowError): + ConversionTest().CharField = -1 - with self.assertRaises(OverflowError): - _ = System.Int16(-32769) + with pytest.raises(TypeError): + ConversionTest().CharField = None - def test_int32_conversion(self): - """Test int32 conversion.""" - self.assertTrue(System.Int32.MaxValue == 2147483647) - self.assertTrue(System.Int32.MinValue == -2147483648) - ob = ConversionTest() - self.assertTrue(ob.Int32Field == 0) +def test_int16_conversion(): + """Test int16 conversion.""" + assert System.Int16.MaxValue == 32767 + assert System.Int16.MinValue == -32768 - ob.Int32Field = 2147483647 - self.assertTrue(ob.Int32Field == 2147483647) + ob = ConversionTest() + assert ob.Int16Field == 0 - ob.Int32Field = -2147483648 - self.assertTrue(ob.Int32Field == -2147483648) + ob.Int16Field = 32767 + assert ob.Int16Field == 32767 - ob.Int32Field = System.Int32(2147483647) - self.assertTrue(ob.Int32Field == 2147483647) + ob.Int16Field = -32768 + assert ob.Int16Field == -32768 - ob.Int32Field = System.Int32(-2147483648) - self.assertTrue(ob.Int32Field == -2147483648) + ob.Int16Field = System.Int16(32767) + assert ob.Int16Field == 32767 - with self.assertRaises(TypeError): - ConversionTest().Int32Field = "spam" + ob.Int16Field = System.Int16(-32768) + assert ob.Int16Field == -32768 - with self.assertRaises(TypeError): - ConversionTest().Int32Field = None + with pytest.raises(TypeError): + ConversionTest().Int16Field = "spam" - with self.assertRaises(OverflowError): - ConversionTest().Int32Field = 2147483648 + with pytest.raises(TypeError): + ConversionTest().Int16Field = None - with self.assertRaises(OverflowError): - ConversionTest().Int32Field = -2147483649 + with pytest.raises(OverflowError): + ConversionTest().Int16Field = 32768 - with self.assertRaises(OverflowError): - _ = System.Int32(2147483648) + with pytest.raises(OverflowError): + ConversionTest().Int16Field = -32769 - with self.assertRaises(OverflowError): - _ = System.Int32(-2147483649) + with pytest.raises(OverflowError): + _ = System.Int16(32768) - def test_int64_conversion(self): - """Test int64 conversion.""" - self.assertTrue(System.Int64.MaxValue == long(9223372036854775807)) - self.assertTrue(System.Int64.MinValue == long(-9223372036854775808)) + with pytest.raises(OverflowError): + _ = System.Int16(-32769) - ob = ConversionTest() - self.assertTrue(ob.Int64Field == 0) - ob.Int64Field = long(9223372036854775807) - self.assertTrue(ob.Int64Field == long(9223372036854775807)) +def test_int32_conversion(): + """Test int32 conversion.""" + assert System.Int32.MaxValue == 2147483647 + assert System.Int32.MinValue == -2147483648 - ob.Int64Field = long(-9223372036854775808) - self.assertTrue(ob.Int64Field == long(-9223372036854775808)) + ob = ConversionTest() + assert ob.Int32Field == 0 - ob.Int64Field = System.Int64(long(9223372036854775807)) - self.assertTrue(ob.Int64Field == long(9223372036854775807)) + ob.Int32Field = 2147483647 + assert ob.Int32Field == 2147483647 - ob.Int64Field = System.Int64(long(-9223372036854775808)) - self.assertTrue(ob.Int64Field == long(-9223372036854775808)) + ob.Int32Field = -2147483648 + assert ob.Int32Field == -2147483648 - with self.assertRaises(TypeError): - ConversionTest().Int64Field = "spam" + ob.Int32Field = System.Int32(2147483647) + assert ob.Int32Field == 2147483647 - with self.assertRaises(TypeError): - ConversionTest().Int64Field = None + ob.Int32Field = System.Int32(-2147483648) + assert ob.Int32Field == -2147483648 - with self.assertRaises(OverflowError): - ConversionTest().Int64Field = long(9223372036854775808) + with pytest.raises(TypeError): + ConversionTest().Int32Field = "spam" - with self.assertRaises(OverflowError): - ConversionTest().Int64Field = long(-9223372036854775809) + with pytest.raises(TypeError): + ConversionTest().Int32Field = None - with self.assertRaises(OverflowError): - _ = System.Int64(long(9223372036854775808)) + with pytest.raises(OverflowError): + ConversionTest().Int32Field = 2147483648 - with self.assertRaises(OverflowError): - _ = System.Int64(long(-9223372036854775809)) + with pytest.raises(OverflowError): + ConversionTest().Int32Field = -2147483649 - def test_uint16_conversion(self): - """Test uint16 conversion.""" - self.assertTrue(System.UInt16.MaxValue == 65535) - self.assertTrue(System.UInt16.MinValue == 0) + with pytest.raises(OverflowError): + _ = System.Int32(2147483648) - ob = ConversionTest() - self.assertTrue(ob.UInt16Field == 0) + with pytest.raises(OverflowError): + _ = System.Int32(-2147483649) - ob.UInt16Field = 65535 - self.assertTrue(ob.UInt16Field == 65535) - ob.UInt16Field = -0 - self.assertTrue(ob.UInt16Field == 0) +def test_int64_conversion(): + """Test int64 conversion.""" + assert System.Int64.MaxValue == long(9223372036854775807) + assert System.Int64.MinValue == long(-9223372036854775808) - ob.UInt16Field = System.UInt16(65535) - self.assertTrue(ob.UInt16Field == 65535) + ob = ConversionTest() + assert ob.Int64Field == 0 - ob.UInt16Field = System.UInt16(0) - self.assertTrue(ob.UInt16Field == 0) + ob.Int64Field = long(9223372036854775807) + assert ob.Int64Field == long(9223372036854775807) - with self.assertRaises(TypeError): - ConversionTest().UInt16Field = "spam" + ob.Int64Field = long(-9223372036854775808) + assert ob.Int64Field == long(-9223372036854775808) - with self.assertRaises(TypeError): - ConversionTest().UInt16Field = None + ob.Int64Field = System.Int64(long(9223372036854775807)) + assert ob.Int64Field == long(9223372036854775807) - with self.assertRaises(OverflowError): - ConversionTest().UInt16Field = 65536 + ob.Int64Field = System.Int64(long(-9223372036854775808)) + assert ob.Int64Field == long(-9223372036854775808) - with self.assertRaises(OverflowError): - ConversionTest().UInt16Field = -1 + with pytest.raises(TypeError): + ConversionTest().Int64Field = "spam" - with self.assertRaises(OverflowError): - _ = System.UInt16(65536) + with pytest.raises(TypeError): + ConversionTest().Int64Field = None - with self.assertRaises(OverflowError): - _ = System.UInt16(-1) + with pytest.raises(OverflowError): + ConversionTest().Int64Field = long(9223372036854775808) - def test_uint32_conversion(self): - """Test uint32 conversion.""" - self.assertTrue(System.UInt32.MaxValue == long(4294967295)) - self.assertTrue(System.UInt32.MinValue == 0) + with pytest.raises(OverflowError): + ConversionTest().Int64Field = long(-9223372036854775809) - ob = ConversionTest() - self.assertTrue(ob.UInt32Field == 0) + with pytest.raises(OverflowError): + _ = System.Int64(long(9223372036854775808)) - ob.UInt32Field = long(4294967295) - self.assertTrue(ob.UInt32Field == long(4294967295)) + with pytest.raises(OverflowError): + _ = System.Int64(long(-9223372036854775809)) - ob.UInt32Field = -0 - self.assertTrue(ob.UInt32Field == 0) - ob.UInt32Field = System.UInt32(long(4294967295)) - self.assertTrue(ob.UInt32Field == long(4294967295)) +def test_uint16_conversion(): + """Test uint16 conversion.""" + assert System.UInt16.MaxValue == 65535 + assert System.UInt16.MinValue == 0 - ob.UInt32Field = System.UInt32(0) - self.assertTrue(ob.UInt32Field == 0) + ob = ConversionTest() + assert ob.UInt16Field == 0 - with self.assertRaises(TypeError): - ConversionTest().UInt32Field = "spam" + ob.UInt16Field = 65535 + assert ob.UInt16Field == 65535 - with self.assertRaises(TypeError): - ConversionTest().UInt32Field = None + ob.UInt16Field = -0 + assert ob.UInt16Field == 0 - with self.assertRaises(OverflowError): - ConversionTest().UInt32Field = long(4294967296) + ob.UInt16Field = System.UInt16(65535) + assert ob.UInt16Field == 65535 - with self.assertRaises(OverflowError): - ConversionTest().UInt32Field = -1 + ob.UInt16Field = System.UInt16(0) + assert ob.UInt16Field == 0 - with self.assertRaises(OverflowError): - _ = System.UInt32(long(4294967296)) + with pytest.raises(TypeError): + ConversionTest().UInt16Field = "spam" - with self.assertRaises(OverflowError): - _ = System.UInt32(-1) + with pytest.raises(TypeError): + ConversionTest().UInt16Field = None - def test_uint64_conversion(self): - """Test uint64 conversion.""" - self.assertTrue(System.UInt64.MaxValue == long(18446744073709551615)) - self.assertTrue(System.UInt64.MinValue == 0) + with pytest.raises(OverflowError): + ConversionTest().UInt16Field = 65536 - ob = ConversionTest() - self.assertTrue(ob.UInt64Field == 0) + with pytest.raises(OverflowError): + ConversionTest().UInt16Field = -1 - ob.UInt64Field = long(18446744073709551615) - self.assertTrue(ob.UInt64Field == long(18446744073709551615)) + with pytest.raises(OverflowError): + _ = System.UInt16(65536) - ob.UInt64Field = -0 - self.assertTrue(ob.UInt64Field == 0) + with pytest.raises(OverflowError): + _ = System.UInt16(-1) - ob.UInt64Field = System.UInt64(long(18446744073709551615)) - self.assertTrue(ob.UInt64Field == long(18446744073709551615)) - ob.UInt64Field = System.UInt64(0) - self.assertTrue(ob.UInt64Field == 0) +def test_uint32_conversion(): + """Test uint32 conversion.""" + assert System.UInt32.MaxValue == long(4294967295) + assert System.UInt32.MinValue == 0 - with self.assertRaises(TypeError): - ConversionTest().UInt64Field = "spam" + ob = ConversionTest() + assert ob.UInt32Field == 0 - with self.assertRaises(TypeError): - ConversionTest().UInt64Field = None + ob.UInt32Field = long(4294967295) + assert ob.UInt32Field == long(4294967295) - with self.assertRaises(OverflowError): - ConversionTest().UInt64Field = long(18446744073709551616) + ob.UInt32Field = -0 + assert ob.UInt32Field == 0 - with self.assertRaises(OverflowError): - ConversionTest().UInt64Field = -1 + ob.UInt32Field = System.UInt32(long(4294967295)) + assert ob.UInt32Field == long(4294967295) - with self.assertRaises(OverflowError): - _ = System.UInt64(long(18446744073709551616)) + ob.UInt32Field = System.UInt32(0) + assert ob.UInt32Field == 0 - with self.assertRaises(OverflowError): - _ = System.UInt64(-1) + with pytest.raises(TypeError): + ConversionTest().UInt32Field = "spam" - def test_single_conversion(self): - """Test single conversion.""" - self.assertTrue(System.Single.MaxValue == 3.402823e38) - self.assertTrue(System.Single.MinValue == -3.402823e38) + with pytest.raises(TypeError): + ConversionTest().UInt32Field = None - ob = ConversionTest() - self.assertTrue(ob.SingleField == 0.0) + with pytest.raises(OverflowError): + ConversionTest().UInt32Field = long(4294967296) - ob.SingleField = 3.402823e38 - self.assertTrue(ob.SingleField == 3.402823e38) + with pytest.raises(OverflowError): + ConversionTest().UInt32Field = -1 - ob.SingleField = -3.402823e38 - self.assertTrue(ob.SingleField == -3.402823e38) + with pytest.raises(OverflowError): + _ = System.UInt32(long(4294967296)) - ob.SingleField = System.Single(3.402823e38) - self.assertTrue(ob.SingleField == 3.402823e38) + with pytest.raises(OverflowError): + _ = System.UInt32(-1) - ob.SingleField = System.Single(-3.402823e38) - self.assertTrue(ob.SingleField == -3.402823e38) - with self.assertRaises(TypeError): - ConversionTest().SingleField = "spam" +def test_uint64_conversion(): + """Test uint64 conversion.""" + assert System.UInt64.MaxValue == long(18446744073709551615) + assert System.UInt64.MinValue == 0 - with self.assertRaises(TypeError): - ConversionTest().SingleField = None + ob = ConversionTest() + assert ob.UInt64Field == 0 - with self.assertRaises(OverflowError): - ConversionTest().SingleField = 3.402824e38 + ob.UInt64Field = long(18446744073709551615) + assert ob.UInt64Field == long(18446744073709551615) - with self.assertRaises(OverflowError): - ConversionTest().SingleField = -3.402824e38 + ob.UInt64Field = -0 + assert ob.UInt64Field == 0 - with self.assertRaises(OverflowError): - _ = System.Single(3.402824e38) + ob.UInt64Field = System.UInt64(long(18446744073709551615)) + assert ob.UInt64Field == long(18446744073709551615) - with self.assertRaises(OverflowError): - _ = System.Single(-3.402824e38) + ob.UInt64Field = System.UInt64(0) + assert ob.UInt64Field == 0 - def test_double_conversion(self): - """Test double conversion.""" - self.assertTrue(System.Double.MaxValue == 1.7976931348623157e308) - self.assertTrue(System.Double.MinValue == -1.7976931348623157e308) + with pytest.raises(TypeError): + ConversionTest().UInt64Field = "spam" - ob = ConversionTest() - self.assertTrue(ob.DoubleField == 0.0) + with pytest.raises(TypeError): + ConversionTest().UInt64Field = None - ob.DoubleField = 1.7976931348623157e308 - self.assertTrue(ob.DoubleField == 1.7976931348623157e308) + with pytest.raises(OverflowError): + ConversionTest().UInt64Field = long(18446744073709551616) - ob.DoubleField = -1.7976931348623157e308 - self.assertTrue(ob.DoubleField == -1.7976931348623157e308) + with pytest.raises(OverflowError): + ConversionTest().UInt64Field = -1 - ob.DoubleField = System.Double(1.7976931348623157e308) - self.assertTrue(ob.DoubleField == 1.7976931348623157e308) + with pytest.raises(OverflowError): + _ = System.UInt64(long(18446744073709551616)) - ob.DoubleField = System.Double(-1.7976931348623157e308) - self.assertTrue(ob.DoubleField == -1.7976931348623157e308) + with pytest.raises(OverflowError): + _ = System.UInt64(-1) - with self.assertRaises(TypeError): - ConversionTest().DoubleField = "spam" - with self.assertRaises(TypeError): - ConversionTest().DoubleField = None +def test_single_conversion(): + """Test single conversion.""" + assert System.Single.MaxValue == 3.402823e38 + assert System.Single.MinValue == -3.402823e38 - with self.assertRaises(OverflowError): - ConversionTest().DoubleField = 1.7976931348623159e308 + ob = ConversionTest() + assert ob.SingleField == 0.0 - with self.assertRaises(OverflowError): - ConversionTest().DoubleField = -1.7976931348623159e308 + ob.SingleField = 3.402823e38 + assert ob.SingleField == 3.402823e38 - with self.assertRaises(OverflowError): - _ = System.Double(1.7976931348623159e308) + ob.SingleField = -3.402823e38 + assert ob.SingleField == -3.402823e38 - with self.assertRaises(OverflowError): - _ = System.Double(-1.7976931348623159e308) + ob.SingleField = System.Single(3.402823e38) + assert ob.SingleField == 3.402823e38 - def test_decimal_conversion(self): - """Test decimal conversion.""" - from System import Decimal + ob.SingleField = System.Single(-3.402823e38) + assert ob.SingleField == -3.402823e38 - max_d = Decimal.Parse("79228162514264337593543950335") - min_d = Decimal.Parse("-79228162514264337593543950335") + with pytest.raises(TypeError): + ConversionTest().SingleField = "spam" - self.assertTrue(Decimal.ToInt64(Decimal(10)) == long(10)) + with pytest.raises(TypeError): + ConversionTest().SingleField = None - ob = ConversionTest() - self.assertTrue(ob.DecimalField == Decimal(0)) + with pytest.raises(OverflowError): + ConversionTest().SingleField = 3.402824e38 - ob.DecimalField = Decimal(10) - self.assertTrue(ob.DecimalField == Decimal(10)) + with pytest.raises(OverflowError): + ConversionTest().SingleField = -3.402824e38 - ob.DecimalField = Decimal.One - self.assertTrue(ob.DecimalField == Decimal.One) + with pytest.raises(OverflowError): + _ = System.Single(3.402824e38) - ob.DecimalField = Decimal.Zero - self.assertTrue(ob.DecimalField == Decimal.Zero) + with pytest.raises(OverflowError): + _ = System.Single(-3.402824e38) - ob.DecimalField = max_d - self.assertTrue(ob.DecimalField == max_d) - ob.DecimalField = min_d - self.assertTrue(ob.DecimalField == min_d) +def test_double_conversion(): + """Test double conversion.""" + assert System.Double.MaxValue == 1.7976931348623157e308 + assert System.Double.MinValue == -1.7976931348623157e308 - with self.assertRaises(TypeError): - ConversionTest().DecimalField = None + ob = ConversionTest() + assert ob.DoubleField == 0.0 - with self.assertRaises(TypeError): - ConversionTest().DecimalField = "spam" + ob.DoubleField = 1.7976931348623157e308 + assert ob.DoubleField == 1.7976931348623157e308 - with self.assertRaises(TypeError): - ConversionTest().DecimalField = 1 + ob.DoubleField = -1.7976931348623157e308 + assert ob.DoubleField == -1.7976931348623157e308 - def test_string_conversion(self): - """Test string / unicode conversion.""" - ob = ConversionTest() + ob.DoubleField = System.Double(1.7976931348623157e308) + assert ob.DoubleField == 1.7976931348623157e308 - self.assertTrue(ob.StringField == "spam") - self.assertTrue(ob.StringField == u"spam") + ob.DoubleField = System.Double(-1.7976931348623157e308) + assert ob.DoubleField == -1.7976931348623157e308 - ob.StringField = "eggs" - self.assertTrue(ob.StringField == "eggs") - self.assertTrue(ob.StringField == u"eggs") + with pytest.raises(TypeError): + ConversionTest().DoubleField = "spam" - ob.StringField = u"spam" - self.assertTrue(ob.StringField == "spam") - self.assertTrue(ob.StringField == u"spam") + with pytest.raises(TypeError): + ConversionTest().DoubleField = None - ob.StringField = u'\uffff\uffff' - self.assertTrue(ob.StringField == u'\uffff\uffff') + with pytest.raises(OverflowError): + ConversionTest().DoubleField = 1.7976931348623159e308 - ob.StringField = System.String("spam") - self.assertTrue(ob.StringField == "spam") - self.assertTrue(ob.StringField == u"spam") + with pytest.raises(OverflowError): + ConversionTest().DoubleField = -1.7976931348623159e308 - ob.StringField = System.String(u'\uffff\uffff') - self.assertTrue(ob.StringField == u'\uffff\uffff') + with pytest.raises(OverflowError): + _ = System.Double(1.7976931348623159e308) - ob.StringField = None - self.assertTrue(ob.StringField is None) + with pytest.raises(OverflowError): + _ = System.Double(-1.7976931348623159e308) - with self.assertRaises(TypeError): - ConversionTest().StringField = 1 - def test_interface_conversion(self): - """Test interface conversion.""" - from Python.Test import Spam, ISpam +def test_decimal_conversion(): + """Test decimal conversion.""" + from System import Decimal - ob = ConversionTest() + max_d = Decimal.Parse("79228162514264337593543950335") + min_d = Decimal.Parse("-79228162514264337593543950335") - self.assertTrue(ISpam(ob.SpamField).GetValue() == "spam") - self.assertTrue(ob.SpamField.GetValue() == "spam") + assert Decimal.ToInt64(Decimal(10)) == long(10) - ob.SpamField = Spam("eggs") - self.assertTrue(ISpam(ob.SpamField).GetValue() == "eggs") - self.assertTrue(ob.SpamField.GetValue() == "eggs") + ob = ConversionTest() + assert ob.DecimalField == Decimal(0) - # need to test spam subclass here. + ob.DecimalField = Decimal(10) + assert ob.DecimalField == Decimal(10) - ob.SpamField = None - self.assertTrue(ob.SpamField is None) + ob.DecimalField = Decimal.One + assert ob.DecimalField == Decimal.One - with self.assertRaises(TypeError): - ob = ConversionTest() - ob.SpamField = System.String("bad") + ob.DecimalField = Decimal.Zero + assert ob.DecimalField == Decimal.Zero - with self.assertRaises(TypeError): - ob = ConversionTest() - ob.SpamField = System.Int32(1) + ob.DecimalField = max_d + assert ob.DecimalField == max_d - def test_object_conversion(self): - """Test ob conversion.""" - from Python.Test import Spam + ob.DecimalField = min_d + assert ob.DecimalField == min_d - ob = ConversionTest() - self.assertTrue(ob.ObjectField is None) + with pytest.raises(TypeError): + ConversionTest().DecimalField = None - ob.ObjectField = Spam("eggs") - self.assertTrue(ob.ObjectField.__class__.__name__ == "Spam") - self.assertTrue(ob.ObjectField.GetValue() == "eggs") + with pytest.raises(TypeError): + ConversionTest().DecimalField = "spam" - ob.ObjectField = None - self.assertTrue(ob.ObjectField is None) + with pytest.raises(TypeError): + ConversionTest().DecimalField = 1 - ob.ObjectField = System.String("spam") - self.assertTrue(ob.ObjectField == "spam") - ob.ObjectField = System.Int32(1) - self.assertTrue(ob.ObjectField == 1) +def test_string_conversion(): + """Test string / unicode conversion.""" + ob = ConversionTest() - # need to test subclass here + assert ob.StringField == "spam" + assert ob.StringField == u"spam" - with self.assertRaises(TypeError): - ob = ConversionTest() - ob.ObjectField = self + ob.StringField = "eggs" + assert ob.StringField == "eggs" + assert ob.StringField == u"eggs" - def test_enum_conversion(self): - """Test enum conversion.""" - from Python.Test import ShortEnum + ob.StringField = u"spam" + assert ob.StringField == "spam" + assert ob.StringField == u"spam" - ob = ConversionTest() - self.assertTrue(ob.EnumField == ShortEnum.Zero) + ob.StringField = u'\uffff\uffff' + assert ob.StringField == u'\uffff\uffff' + + ob.StringField = System.String("spam") + assert ob.StringField == "spam" + assert ob.StringField == u"spam" - ob.EnumField = ShortEnum.One - self.assertTrue(ob.EnumField == ShortEnum.One) + ob.StringField = System.String(u'\uffff\uffff') + assert ob.StringField == u'\uffff\uffff' - ob.EnumField = 0 - self.assertTrue(ob.EnumField == ShortEnum.Zero) - self.assertTrue(ob.EnumField == 0) + ob.StringField = None + assert ob.StringField is None - ob.EnumField = 1 - self.assertTrue(ob.EnumField == ShortEnum.One) - self.assertTrue(ob.EnumField == 1) + with pytest.raises(TypeError): + ConversionTest().StringField = 1 - with self.assertRaises(ValueError): - ob = ConversionTest() - ob.EnumField = 10 - with self.assertRaises(ValueError): - ob = ConversionTest() - ob.EnumField = 255 +def test_interface_conversion(): + """Test interface conversion.""" + from Python.Test import Spam, ISpam - with self.assertRaises(OverflowError): - ob = ConversionTest() - ob.EnumField = 1000000 + ob = ConversionTest() - with self.assertRaises(TypeError): - ob = ConversionTest() - ob.EnumField = "spam" + assert ISpam(ob.SpamField).GetValue() == "spam" + assert ob.SpamField.GetValue() == "spam" - def test_null_conversion(self): - """Test null conversion.""" + ob.SpamField = Spam("eggs") + assert ISpam(ob.SpamField).GetValue() == "eggs" + assert ob.SpamField.GetValue() == "eggs" + + # need to test spam subclass here. + + ob.SpamField = None + assert ob.SpamField is None + + with pytest.raises(TypeError): ob = ConversionTest() + ob.SpamField = System.String("bad") + + with pytest.raises(TypeError): + ob = ConversionTest() + ob.SpamField = System.Int32(1) + - ob.StringField = None - self.assertTrue(ob.StringField is None) +def test_object_conversion(): + """Test ob conversion.""" + from Python.Test import Spam - ob.ObjectField = None - self.assertTrue(ob.ObjectField is None) + ob = ConversionTest() + assert ob.ObjectField is None - ob.SpamField = None - self.assertTrue(ob.SpamField is None) + ob.ObjectField = Spam("eggs") + assert ob.ObjectField.__class__.__name__ == "Spam" + assert ob.ObjectField.GetValue() == "eggs" - # Primitive types and enums should not be set to null. + ob.ObjectField = None + assert ob.ObjectField is None - with self.assertRaises(TypeError): - ConversionTest().Int32Field = None + ob.ObjectField = System.String("spam") + assert ob.ObjectField == "spam" - with self.assertRaises(TypeError): - ConversionTest().EnumField = None + ob.ObjectField = System.Int32(1) + assert ob.ObjectField == 1 - def test_byte_array_conversion(self): - """Test byte array conversion.""" + # need to test subclass here + + with pytest.raises(TypeError): + class Foo(object): + pass ob = ConversionTest() + ob.ObjectField = Foo + + +def test_enum_conversion(): + """Test enum conversion.""" + from Python.Test import ShortEnum + + ob = ConversionTest() + assert ob.EnumField == ShortEnum.Zero + + ob.EnumField = ShortEnum.One + assert ob.EnumField == ShortEnum.One + + ob.EnumField = 0 + assert ob.EnumField == ShortEnum.Zero + assert ob.EnumField == 0 - self.assertTrue(ob.ByteArrayField is None) + ob.EnumField = 1 + assert ob.EnumField == ShortEnum.One + assert ob.EnumField == 1 - ob.ByteArrayField = [0, 1, 2, 3, 4] - array = ob.ByteArrayField - self.assertTrue(len(array) == 5) - self.assertTrue(array[0] == 0) - self.assertTrue(array[4] == 4) + with pytest.raises(ValueError): + ob = ConversionTest() + ob.EnumField = 10 + + with pytest.raises(ValueError): + ob = ConversionTest() + ob.EnumField = 255 - value = b"testing" - ob.ByteArrayField = value - array = ob.ByteArrayField - for i, _ in enumerate(value): - self.assertTrue(array[i] == indexbytes(value, i)) + with pytest.raises(OverflowError): + ob = ConversionTest() + ob.EnumField = 1000000 - def test_sbyte_array_conversion(self): - """Test sbyte array conversion.""" + with pytest.raises(TypeError): ob = ConversionTest() + ob.EnumField = "spam" + + +def test_null_conversion(): + """Test null conversion.""" + ob = ConversionTest() + + ob.StringField = None + assert ob.StringField is None + + ob.ObjectField = None + assert ob.ObjectField is None + + ob.SpamField = None + assert ob.SpamField is None + + # Primitive types and enums should not be set to null. + + with pytest.raises(TypeError): + ConversionTest().Int32Field = None + + with pytest.raises(TypeError): + ConversionTest().EnumField = None + + +def test_byte_array_conversion(): + """Test byte array conversion.""" + ob = ConversionTest() + + assert ob.ByteArrayField is None + + ob.ByteArrayField = [0, 1, 2, 3, 4] + array = ob.ByteArrayField + assert len(array) == 5 + assert array[0] == 0 + assert array[4] == 4 + + value = b"testing" + ob.ByteArrayField = value + array = ob.ByteArrayField + for i, _ in enumerate(value): + assert array[i] == indexbytes(value, i) - self.assertTrue(ob.SByteArrayField is None) - ob.SByteArrayField = [0, 1, 2, 3, 4] - array = ob.SByteArrayField - self.assertTrue(len(array) == 5) - self.assertTrue(array[0] == 0) - self.assertTrue(array[4] == 4) +def test_sbyte_array_conversion(): + """Test sbyte array conversion.""" + ob = ConversionTest() - value = b"testing" - ob.SByteArrayField = value - array = ob.SByteArrayField - for i, _ in enumerate(value): - self.assertTrue(array[i] == indexbytes(value, i)) + assert ob.SByteArrayField is None + ob.SByteArrayField = [0, 1, 2, 3, 4] + array = ob.SByteArrayField + assert len(array) == 5 + assert array[0] == 0 + assert array[4] == 4 -def test_suite(): - return unittest.makeSuite(ConversionTests) + value = b"testing" + ob.SByteArrayField = value + array = ob.SByteArrayField + for i, _ in enumerate(value): + assert array[i] == indexbytes(value, i) diff --git a/src/tests/test_delegate.py b/src/tests/test_delegate.py index 4963a09b8..33aca43b3 100644 --- a/src/tests/test_delegate.py +++ b/src/tests/test_delegate.py @@ -1,258 +1,269 @@ # -*- coding: utf-8 -*- # TODO: Add test for ObjectDelegate -import unittest +"""Test CLR delegate support.""" import Python.Test as Test import System +import pytest from Python.Test import DelegateTest, StringDelegate -from _compat import DictProxyType -from utils import HelloClass, hello_func, MultipleHandler +from ._compat import DictProxyType +from .utils import HelloClass, hello_func, MultipleHandler -class DelegateTests(unittest.TestCase): - """Test CLR delegate support.""" +def test_delegate_standard_attrs(): + """Test standard delegate attributes.""" + from Python.Test import PublicDelegate - def test_delegate_standard_attrs(self): - """Test standard delegate attributes.""" - from Python.Test import PublicDelegate + assert PublicDelegate.__name__ == 'PublicDelegate' + assert PublicDelegate.__module__ == 'Python.Test' + assert isinstance(PublicDelegate.__dict__, DictProxyType) + assert PublicDelegate.__doc__ is None - self.assertTrue(PublicDelegate.__name__ == 'PublicDelegate') - self.assertTrue(PublicDelegate.__module__ == 'Python.Test') - self.assertTrue(isinstance(PublicDelegate.__dict__, DictProxyType)) - self.assertTrue(PublicDelegate.__doc__ is None) - def test_global_delegate_visibility(self): - """Test visibility of module-level delegates.""" - from Python.Test import PublicDelegate +def test_global_delegate_visibility(): + """Test visibility of module-level delegates.""" + from Python.Test import PublicDelegate - self.assertTrue(PublicDelegate.__name__ == 'PublicDelegate') - self.assertTrue(Test.PublicDelegate.__name__ == 'PublicDelegate') + assert PublicDelegate.__name__ == 'PublicDelegate' + assert Test.PublicDelegate.__name__ == 'PublicDelegate' - with self.assertRaises(ImportError): - from Python.Test import InternalDelegate - _ = InternalDelegate + with pytest.raises(ImportError): + from Python.Test import InternalDelegate + _ = InternalDelegate - with self.assertRaises(AttributeError): - _ = Test.InternalDelegate + with pytest.raises(AttributeError): + _ = Test.InternalDelegate - def test_nested_delegate_visibility(self): - """Test visibility of nested delegates.""" - ob = DelegateTest.PublicDelegate - self.assertTrue(ob.__name__ == 'PublicDelegate') - ob = DelegateTest.ProtectedDelegate - self.assertTrue(ob.__name__ == 'ProtectedDelegate') +def test_nested_delegate_visibility(): + """Test visibility of nested delegates.""" + ob = DelegateTest.PublicDelegate + assert ob.__name__ == 'PublicDelegate' - with self.assertRaises(AttributeError): - _ = DelegateTest.InternalDelegate + ob = DelegateTest.ProtectedDelegate + assert ob.__name__ == 'ProtectedDelegate' - with self.assertRaises(AttributeError): - _ = DelegateTest.PrivateDelegate + with pytest.raises(AttributeError): + _ = DelegateTest.InternalDelegate - def test_delegate_from_function(self): - """Test delegate implemented with a Python function.""" + with pytest.raises(AttributeError): + _ = DelegateTest.PrivateDelegate - d = StringDelegate(hello_func) - ob = DelegateTest() - self.assertTrue(ob.CallStringDelegate(d) == "hello") - self.assertTrue(d() == "hello") +def test_delegate_from_function(): + """Test delegate implemented with a Python function.""" - ob.stringDelegate = d - self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") - self.assertTrue(ob.stringDelegate() == "hello") + d = StringDelegate(hello_func) + ob = DelegateTest() - def test_delegate_from_method(self): - """Test delegate implemented with a Python instance method.""" + assert ob.CallStringDelegate(d) == "hello" + assert d() == "hello" - inst = HelloClass() - d = StringDelegate(inst.hello) - ob = DelegateTest() + ob.stringDelegate = d + assert ob.CallStringDelegate(ob.stringDelegate) == "hello" + assert ob.stringDelegate() == "hello" - self.assertTrue(ob.CallStringDelegate(d) == "hello") - self.assertTrue(d() == "hello") - ob.stringDelegate = d - self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") - self.assertTrue(ob.stringDelegate() == "hello") +def test_delegate_from_method(): + """Test delegate implemented with a Python instance method.""" - def test_delegate_from_unbound_method(self): - """Test failure mode for unbound methods.""" + inst = HelloClass() + d = StringDelegate(inst.hello) + ob = DelegateTest() - with self.assertRaises(TypeError): - d = StringDelegate(HelloClass.hello) - d() + assert ob.CallStringDelegate(d) == "hello" + assert d() == "hello" - def test_delegate_from_static_method(self): - """Test delegate implemented with a Python static method.""" + ob.stringDelegate = d + assert ob.CallStringDelegate(ob.stringDelegate) == "hello" + assert ob.stringDelegate() == "hello" - d = StringDelegate(HelloClass.s_hello) - ob = DelegateTest() - self.assertTrue(ob.CallStringDelegate(d) == "hello") - self.assertTrue(d() == "hello") +def test_delegate_from_unbound_method(): + """Test failure mode for unbound methods.""" - ob.stringDelegate = d - self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") - self.assertTrue(ob.stringDelegate() == "hello") + with pytest.raises(TypeError): + d = StringDelegate(HelloClass.hello) + d() - inst = HelloClass() - d = StringDelegate(inst.s_hello) - ob = DelegateTest() - self.assertTrue(ob.CallStringDelegate(d) == "hello") - self.assertTrue(d() == "hello") +def test_delegate_from_static_method(): + """Test delegate implemented with a Python static method.""" - ob.stringDelegate = d - self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") - self.assertTrue(ob.stringDelegate() == "hello") + d = StringDelegate(HelloClass.s_hello) + ob = DelegateTest() - def test_delegate_from_class_method(self): - """Test delegate implemented with a Python class method.""" + assert ob.CallStringDelegate(d) == "hello" + assert d() == "hello" - d = StringDelegate(HelloClass.c_hello) - ob = DelegateTest() + ob.stringDelegate = d + assert ob.CallStringDelegate(ob.stringDelegate) == "hello" + assert ob.stringDelegate() == "hello" - self.assertTrue(ob.CallStringDelegate(d) == "hello") - self.assertTrue(d() == "hello") + inst = HelloClass() + d = StringDelegate(inst.s_hello) + ob = DelegateTest() - ob.stringDelegate = d - self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") - self.assertTrue(ob.stringDelegate() == "hello") + assert ob.CallStringDelegate(d) == "hello" + assert d() == "hello" - inst = HelloClass() - d = StringDelegate(inst.c_hello) - ob = DelegateTest() + ob.stringDelegate = d + assert ob.CallStringDelegate(ob.stringDelegate) == "hello" + assert ob.stringDelegate() == "hello" - self.assertTrue(ob.CallStringDelegate(d) == "hello") - self.assertTrue(d() == "hello") - ob.stringDelegate = d - self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") - self.assertTrue(ob.stringDelegate() == "hello") +def test_delegate_from_class_method(): + """Test delegate implemented with a Python class method.""" - def test_delegate_from_callable(self): - """Test delegate implemented with a Python callable object.""" + d = StringDelegate(HelloClass.c_hello) + ob = DelegateTest() - inst = HelloClass() - d = StringDelegate(inst) - ob = DelegateTest() + assert ob.CallStringDelegate(d) == "hello" + assert d() == "hello" - self.assertTrue(ob.CallStringDelegate(d) == "hello") - self.assertTrue(d() == "hello") + ob.stringDelegate = d + assert ob.CallStringDelegate(ob.stringDelegate) == "hello" + assert ob.stringDelegate() == "hello" - ob.stringDelegate = d - self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") - self.assertTrue(ob.stringDelegate() == "hello") + inst = HelloClass() + d = StringDelegate(inst.c_hello) + ob = DelegateTest() - def test_delegate_from_managed_instance_method(self): - """Test delegate implemented with a managed instance method.""" - ob = DelegateTest() - d = StringDelegate(ob.SayHello) + assert ob.CallStringDelegate(d) == "hello" + assert d() == "hello" - self.assertTrue(ob.CallStringDelegate(d) == "hello") - self.assertTrue(d() == "hello") + ob.stringDelegate = d + assert ob.CallStringDelegate(ob.stringDelegate) == "hello" + assert ob.stringDelegate() == "hello" - ob.stringDelegate = d - self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") - self.assertTrue(ob.stringDelegate() == "hello") - def test_delegate_from_managed_static_method(self): - """Test delegate implemented with a managed static method.""" - d = StringDelegate(DelegateTest.StaticSayHello) - ob = DelegateTest() +def test_delegate_from_callable(): + """Test delegate implemented with a Python callable object.""" - self.assertTrue(ob.CallStringDelegate(d) == "hello") - self.assertTrue(d() == "hello") + inst = HelloClass() + d = StringDelegate(inst) + ob = DelegateTest() - ob.stringDelegate = d - self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") - self.assertTrue(ob.stringDelegate() == "hello") + assert ob.CallStringDelegate(d) == "hello" + assert d() == "hello" - def test_delegate_from_delegate(self): - """Test delegate implemented with another delegate.""" - d1 = StringDelegate(hello_func) - d2 = StringDelegate(d1) - ob = DelegateTest() + ob.stringDelegate = d + assert ob.CallStringDelegate(ob.stringDelegate) == "hello" + assert ob.stringDelegate() == "hello" - self.assertTrue(ob.CallStringDelegate(d2) == "hello") - self.assertTrue(d2() == "hello") - ob.stringDelegate = d2 - self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") - self.assertTrue(ob.stringDelegate() == "hello") +def test_delegate_from_managed_instance_method(): + """Test delegate implemented with a managed instance method.""" + ob = DelegateTest() + d = StringDelegate(ob.SayHello) - def test_delegate_with_invalid_args(self): - """Test delegate instantiation with invalid (non-callable) args.""" + assert ob.CallStringDelegate(d) == "hello" + assert d() == "hello" - with self.assertRaises(TypeError): - _ = StringDelegate(None) + ob.stringDelegate = d + assert ob.CallStringDelegate(ob.stringDelegate) == "hello" + assert ob.stringDelegate() == "hello" - with self.assertRaises(TypeError): - _ = StringDelegate("spam") - with self.assertRaises(TypeError): - _ = StringDelegate(1) +def test_delegate_from_managed_static_method(): + """Test delegate implemented with a managed static method.""" + d = StringDelegate(DelegateTest.StaticSayHello) + ob = DelegateTest() - def test_multicast_delegate(self): - """Test multicast delegates.""" + assert ob.CallStringDelegate(d) == "hello" + assert d() == "hello" - inst = MultipleHandler() - d1 = StringDelegate(inst.count) - d2 = StringDelegate(inst.count) + ob.stringDelegate = d + assert ob.CallStringDelegate(ob.stringDelegate) == "hello" + assert ob.stringDelegate() == "hello" - md = System.Delegate.Combine(d1, d2) - ob = DelegateTest() - self.assertTrue(ob.CallStringDelegate(md) == "ok") - self.assertTrue(inst.value == 2) +def test_delegate_from_delegate(): + """Test delegate implemented with another delegate.""" + d1 = StringDelegate(hello_func) + d2 = StringDelegate(d1) + ob = DelegateTest() - self.assertTrue(md() == "ok") - self.assertTrue(inst.value == 4) + assert ob.CallStringDelegate(d2) == "hello" + assert d2() == "hello" - def test_subclass_delegate_fails(self): - """Test that subclassing of a delegate type fails.""" - from Python.Test import PublicDelegate + ob.stringDelegate = d2 + assert ob.CallStringDelegate(ob.stringDelegate) == "hello" + assert ob.stringDelegate() == "hello" - with self.assertRaises(TypeError): - class Boom(PublicDelegate): - pass - _ = Boom - def test_delegate_equality(self): - """Test delegate equality.""" +def test_delegate_with_invalid_args(): + """Test delegate instantiation with invalid (non-callable) args.""" - d = StringDelegate(hello_func) - ob = DelegateTest() - ob.stringDelegate = d - self.assertTrue(ob.stringDelegate == d) + with pytest.raises(TypeError): + _ = StringDelegate(None) - def test_bool_delegate(self): - """Test boolean delegate.""" - from Python.Test import BoolDelegate + with pytest.raises(TypeError): + _ = StringDelegate("spam") - def always_so_negative(): - return 0 + with pytest.raises(TypeError): + _ = StringDelegate(1) - d = BoolDelegate(always_so_negative) - ob = DelegateTest() - ob.CallBoolDelegate(d) - self.assertTrue(not d()) - self.assertTrue(not ob.CallBoolDelegate(d)) +def test_multicast_delegate(): + """Test multicast delegates.""" - # test async delegates + inst = MultipleHandler() + d1 = StringDelegate(inst.count) + d2 = StringDelegate(inst.count) - # test multicast delegates + md = System.Delegate.Combine(d1, d2) + ob = DelegateTest() - # test explicit op_ + assert ob.CallStringDelegate(md) == "ok" + assert inst.value == 2 - # test sig mismatch, both on managed and Python side + assert md() == "ok" + assert inst.value == 4 - # test return wrong type +def test_subclass_delegate_fails(): + """Test that subclassing of a delegate type fails.""" + from Python.Test import PublicDelegate -def test_suite(): - return unittest.makeSuite(DelegateTests) + with pytest.raises(TypeError): + class Boom(PublicDelegate): + pass + + _ = Boom + + +def test_delegate_equality(): + """Test delegate equality.""" + + d = StringDelegate(hello_func) + ob = DelegateTest() + ob.stringDelegate = d + assert ob.stringDelegate == d + + +def test_bool_delegate(): + """Test boolean delegate.""" + from Python.Test import BoolDelegate + + def always_so_negative(): + return 0 + + d = BoolDelegate(always_so_negative) + ob = DelegateTest() + ob.CallBoolDelegate(d) + + assert not d() + assert not ob.CallBoolDelegate(d) + + # test async delegates + + # test multicast delegates + + # test explicit op_ + + # test sig mismatch, both on managed and Python side + + # test return wrong type diff --git a/src/tests/test_docstring.py b/src/tests/test_docstring.py index f2bc3302b..640a61915 100644 --- a/src/tests/test_docstring.py +++ b/src/tests/test_docstring.py @@ -1,32 +1,27 @@ # -*- coding: utf-8 -*- -import unittest +"""Test doc strings support.""" -class DocStringTests(unittest.TestCase): - """Test doc strings support.""" +def test_doc_with_ctor(): + from Python.Test import DocWithCtorTest - def test_doc_with_ctor(self): - from Python.Test import DocWithCtorTest + assert DocWithCtorTest.__doc__ == 'DocWithCtorTest Class' + assert DocWithCtorTest.TestMethod.__doc__ == 'DocWithCtorTest TestMethod' + assert DocWithCtorTest.StaticTestMethod.__doc__ == 'DocWithCtorTest StaticTestMethod' - self.assertEqual(DocWithCtorTest.__doc__, 'DocWithCtorTest Class') - self.assertEqual(DocWithCtorTest.TestMethod.__doc__, 'DocWithCtorTest TestMethod') - self.assertEqual(DocWithCtorTest.StaticTestMethod.__doc__, 'DocWithCtorTest StaticTestMethod') - def test_doc_with_ctor_no_doc(self): - from Python.Test import DocWithCtorNoDocTest +def test_doc_with_ctor_no_doc(): + from Python.Test import DocWithCtorNoDocTest - self.assertEqual(DocWithCtorNoDocTest.__doc__, 'Void .ctor(Boolean)') - self.assertEqual(DocWithCtorNoDocTest.TestMethod.__doc__, 'Void TestMethod(Double, Int32)') - self.assertEqual(DocWithCtorNoDocTest.StaticTestMethod.__doc__, 'Void StaticTestMethod(Double, Int32)') + assert DocWithCtorNoDocTest.__doc__ == 'Void .ctor(Boolean)' + assert DocWithCtorNoDocTest.TestMethod.__doc__ == 'Void TestMethod(Double, Int32)' + assert DocWithCtorNoDocTest.StaticTestMethod.__doc__ == 'Void StaticTestMethod(Double, Int32)' - def test_doc_without_ctor(self): - from Python.Test import DocWithoutCtorTest - self.assertEqual(DocWithoutCtorTest.__doc__, 'DocWithoutCtorTest Class') - self.assertEqual(DocWithoutCtorTest.TestMethod.__doc__, 'DocWithoutCtorTest TestMethod') - self.assertEqual(DocWithoutCtorTest.StaticTestMethod.__doc__, 'DocWithoutCtorTest StaticTestMethod') +def test_doc_without_ctor(): + from Python.Test import DocWithoutCtorTest - -def test_suite(): - return unittest.makeSuite(DocStringTests) + assert DocWithoutCtorTest.__doc__ == 'DocWithoutCtorTest Class' + assert DocWithoutCtorTest.TestMethod.__doc__ == 'DocWithoutCtorTest TestMethod' + assert DocWithoutCtorTest.StaticTestMethod.__doc__ == 'DocWithoutCtorTest StaticTestMethod' diff --git a/src/tests/test_engine.py b/src/tests/test_engine.py index b605a3796..cca08a4d2 100644 --- a/src/tests/test_engine.py +++ b/src/tests/test_engine.py @@ -1,46 +1,43 @@ # -*- coding: utf-8 -*- +"""Test PythonEngine embedding APIs.""" + import sys -import unittest import System +import pytest from Python.Runtime import PythonEngine -class EngineTests(unittest.TestCase): - """Test PythonEngine embedding APIs.""" - - def test_multiple_calls_to_initialize(self): - """Test that multiple initialize calls are harmless.""" - try: - PythonEngine.Initialize() - PythonEngine.Initialize() - PythonEngine.Initialize() - except BaseException: - self.fail("Initialize() raise an exception.") +def test_multiple_calls_to_initialize(): + """Test that multiple initialize calls are harmless.""" + try: + PythonEngine.Initialize() + PythonEngine.Initialize() + PythonEngine.Initialize() + except BaseException: + self.fail("Initialize() raise an exception.") - @unittest.skip(reason="FIXME: test crashes") - def test_import_module(self): - """Test module import.""" - m = PythonEngine.ImportModule("sys") - n = m.GetAttr("__name__") - self.assertTrue(n.AsManagedObject(System.String) == "sys") - @unittest.skip(reason="FIXME: test freezes") - def test_run_string(self): - """Test the RunString method.""" - PythonEngine.AcquireLock() +@pytest.mark.skip(reason="FIXME: test crashes") +def test_import_module(): + """Test module import.""" + m = PythonEngine.ImportModule("sys") + n = m.GetAttr("__name__") + assert n.AsManagedObject(System.String) == "sys" - code = "import sys; sys.singleline_worked = 1" - PythonEngine.RunString(code) - self.assertTrue(sys.singleline_worked == 1) - code = "import sys\nsys.multiline_worked = 1" - PythonEngine.RunString(code) - self.assertTrue(sys.multiline_worked == 1) +@pytest.mark.skip(reason="FIXME: test freezes") +def test_run_string(): + """Test the RunString method.""" + PythonEngine.AcquireLock() - PythonEngine.ReleaseLock() + code = "import sys; sys.singleline_worked = 1" + PythonEngine.RunString(code) + assert sys.singleline_worked == 1 + code = "import sys\nsys.multiline_worked = 1" + PythonEngine.RunString(code) + assert sys.multiline_worked == 1 -def test_suite(): - return unittest.makeSuite(EngineTests) + PythonEngine.ReleaseLock() diff --git a/src/tests/test_enum.py b/src/tests/test_enum.py index e7147e69c..b31ce4ec5 100644 --- a/src/tests/test_enum.py +++ b/src/tests/test_enum.py @@ -1,136 +1,145 @@ # -*- coding: utf-8 -*- -import unittest +"""Test clr enum support.""" +import pytest import Python.Test as Test -from _compat import DictProxyType, long - - -class EnumTests(unittest.TestCase): - """Test CLR enum support.""" - - def test_enum_standard_attrs(self): - """Test standard enum attributes.""" - from System import DayOfWeek - - self.assertTrue(DayOfWeek.__name__ == 'DayOfWeek') - self.assertTrue(DayOfWeek.__module__ == 'System') - self.assertTrue(isinstance(DayOfWeek.__dict__, DictProxyType)) - self.assertTrue(DayOfWeek.__doc__ is None) - - def test_enum_get_member(self): - """Test access to enum members.""" - from System import DayOfWeek - - self.assertTrue(DayOfWeek.Sunday == 0) - self.assertTrue(DayOfWeek.Monday == 1) - self.assertTrue(DayOfWeek.Tuesday == 2) - self.assertTrue(DayOfWeek.Wednesday == 3) - self.assertTrue(DayOfWeek.Thursday == 4) - self.assertTrue(DayOfWeek.Friday == 5) - self.assertTrue(DayOfWeek.Saturday == 6) - - def test_byte_enum(self): - """Test byte enum.""" - self.assertTrue(Test.ByteEnum.Zero == 0) - self.assertTrue(Test.ByteEnum.One == 1) - self.assertTrue(Test.ByteEnum.Two == 2) - - def test_sbyte_enum(self): - """Test sbyte enum.""" - self.assertTrue(Test.SByteEnum.Zero == 0) - self.assertTrue(Test.SByteEnum.One == 1) - self.assertTrue(Test.SByteEnum.Two == 2) - - def test_short_enum(self): - """Test short enum.""" - self.assertTrue(Test.ShortEnum.Zero == 0) - self.assertTrue(Test.ShortEnum.One == 1) - self.assertTrue(Test.ShortEnum.Two == 2) - - def test_ushort_enum(self): - """Test ushort enum.""" - self.assertTrue(Test.UShortEnum.Zero == 0) - self.assertTrue(Test.UShortEnum.One == 1) - self.assertTrue(Test.UShortEnum.Two == 2) - - def test_int_enum(self): - """Test int enum.""" - self.assertTrue(Test.IntEnum.Zero == 0) - self.assertTrue(Test.IntEnum.One == 1) - self.assertTrue(Test.IntEnum.Two == 2) - - def test_uint_enum(self): - """Test uint enum.""" - self.assertTrue(Test.UIntEnum.Zero == long(0)) - self.assertTrue(Test.UIntEnum.One == long(1)) - self.assertTrue(Test.UIntEnum.Two == long(2)) - - def test_long_enum(self): - """Test long enum.""" - self.assertTrue(Test.LongEnum.Zero == long(0)) - self.assertTrue(Test.LongEnum.One == long(1)) - self.assertTrue(Test.LongEnum.Two == long(2)) - - def test_ulong_enum(self): - """Test ulong enum.""" - self.assertTrue(Test.ULongEnum.Zero == long(0)) - self.assertTrue(Test.ULongEnum.One == long(1)) - self.assertTrue(Test.ULongEnum.Two == long(2)) - - def test_instantiate_enum_fails(self): - """Test that instantiation of an enum class fails.""" - from System import DayOfWeek - - with self.assertRaises(TypeError): - _ = DayOfWeek() - - def test_subclass_enum_fails(self): - """Test that subclassing of an enumeration fails.""" - from System import DayOfWeek - - with self.assertRaises(TypeError): - class Boom(DayOfWeek): - pass - _ = Boom - - def test_enum_set_member_fails(self): - """Test that setattr operations on enumerations fail.""" - from System import DayOfWeek - - with self.assertRaises(TypeError): - DayOfWeek.Sunday = 13 - - with self.assertRaises(TypeError): - del DayOfWeek.Sunday - - def test_enum_with_flags_attr_conversion(self): - """Test enumeration conversion with FlagsAttribute set.""" - # This works because the FlagsField enum has FlagsAttribute. - Test.FieldTest().FlagsField = 99 - - # This should fail because our test enum doesn't have it. - with self.assertRaises(ValueError): - Test.FieldTest().EnumField = 99 - - def test_enum_conversion(self): - """Test enumeration conversion.""" - ob = Test.FieldTest() - self.assertTrue(ob.EnumField == 0) - - ob.EnumField = Test.ShortEnum.One - self.assertTrue(ob.EnumField == 1) - - with self.assertRaises(ValueError): - Test.FieldTest().EnumField = 20 - - with self.assertRaises(OverflowError): - Test.FieldTest().EnumField = 100000 - - with self.assertRaises(TypeError): - Test.FieldTest().EnumField = "str" - - -def test_suite(): - return unittest.makeSuite(EnumTests) +from ._compat import DictProxyType, long + + +def test_enum_standard_attrs(): + """Test standard enum attributes.""" + from System import DayOfWeek + + assert DayOfWeek.__name__ == 'DayOfWeek' + assert DayOfWeek.__module__ == 'System' + assert isinstance(DayOfWeek.__dict__, DictProxyType) + assert DayOfWeek.__doc__ is None + + +def test_enum_get_member(): + """Test access to enum members.""" + from System import DayOfWeek + + assert DayOfWeek.Sunday == 0 + assert DayOfWeek.Monday == 1 + assert DayOfWeek.Tuesday == 2 + assert DayOfWeek.Wednesday == 3 + assert DayOfWeek.Thursday == 4 + assert DayOfWeek.Friday == 5 + assert DayOfWeek.Saturday == 6 + + +def test_byte_enum(): + """Test byte enum.""" + assert Test.ByteEnum.Zero == 0 + assert Test.ByteEnum.One == 1 + assert Test.ByteEnum.Two == 2 + + +def test_sbyte_enum(): + """Test sbyte enum.""" + assert Test.SByteEnum.Zero == 0 + assert Test.SByteEnum.One == 1 + assert Test.SByteEnum.Two == 2 + + +def test_short_enum(): + """Test short enum.""" + assert Test.ShortEnum.Zero == 0 + assert Test.ShortEnum.One == 1 + assert Test.ShortEnum.Two == 2 + + +def test_ushort_enum(): + """Test ushort enum.""" + assert Test.UShortEnum.Zero == 0 + assert Test.UShortEnum.One == 1 + assert Test.UShortEnum.Two == 2 + + +def test_int_enum(): + """Test int enum.""" + assert Test.IntEnum.Zero == 0 + assert Test.IntEnum.One == 1 + assert Test.IntEnum.Two == 2 + + +def test_uint_enum(): + """Test uint enum.""" + assert Test.UIntEnum.Zero == long(0) + assert Test.UIntEnum.One == long(1) + assert Test.UIntEnum.Two == long(2) + + +def test_long_enum(): + """Test long enum.""" + assert Test.LongEnum.Zero == long(0) + assert Test.LongEnum.One == long(1) + assert Test.LongEnum.Two == long(2) + + +def test_ulong_enum(): + """Test ulong enum.""" + assert Test.ULongEnum.Zero == long(0) + assert Test.ULongEnum.One == long(1) + assert Test.ULongEnum.Two == long(2) + + +def test_instantiate_enum_fails(): + """Test that instantiation of an enum class fails.""" + from System import DayOfWeek + + with pytest.raises(TypeError): + _ = DayOfWeek() + + +def test_subclass_enum_fails(): + """Test that subclassing of an enumeration fails.""" + from System import DayOfWeek + + with pytest.raises(TypeError): + class Boom(DayOfWeek): + pass + + _ = Boom + + +def test_enum_set_member_fails(): + """Test that setattr operations on enumerations fail.""" + from System import DayOfWeek + + with pytest.raises(TypeError): + DayOfWeek.Sunday = 13 + + with pytest.raises(TypeError): + del DayOfWeek.Sunday + + +def test_enum_with_flags_attr_conversion(): + """Test enumeration conversion with FlagsAttribute set.""" + # This works because the FlagsField enum has FlagsAttribute. + Test.FieldTest().FlagsField = 99 + + # This should fail because our test enum doesn't have it. + with pytest.raises(ValueError): + Test.FieldTest().EnumField = 99 + + +def test_enum_conversion(): + """Test enumeration conversion.""" + ob = Test.FieldTest() + assert ob.EnumField == 0 + + ob.EnumField = Test.ShortEnum.One + assert ob.EnumField == 1 + + with pytest.raises(ValueError): + Test.FieldTest().EnumField = 20 + + with pytest.raises(OverflowError): + Test.FieldTest().EnumField = 100000 + + with pytest.raises(TypeError): + Test.FieldTest().EnumField = "str" diff --git a/src/tests/test_event.py b/src/tests/test_event.py index 047af47f3..624b83d44 100644 --- a/src/tests/test_event.py +++ b/src/tests/test_event.py @@ -1,563 +1,584 @@ # -*- coding: utf-8 -*- -import unittest +"""Test CLR event support.""" +import pytest from Python.Test import EventTest, EventArgsTest -from _compat import range -from utils import (CallableHandler, ClassMethodHandler, GenericHandler, - MultipleHandler, StaticMethodHandler, VarCallableHandler, - VariableArgsHandler) +from ._compat import range +from .utils import (CallableHandler, ClassMethodHandler, GenericHandler, + MultipleHandler, StaticMethodHandler, VarCallableHandler, + VariableArgsHandler) -class EventTests(unittest.TestCase): - """Test CLR event support.""" +def test_public_instance_event(): + """Test public instance events.""" + ob = EventTest() - def test_public_instance_event(self): - """Test public instance events.""" - ob = EventTest() + handler = GenericHandler() + assert handler.value is None - handler = GenericHandler() - self.assertTrue(handler.value is None) + ob.PublicEvent += handler.handler - ob.PublicEvent += handler.handler + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 10 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) + ob.PublicEvent -= handler.handler - ob.PublicEvent -= handler.handler - def test_public_static_event(self): - """Test public static events.""" - handler = GenericHandler() - self.assertTrue(handler.value is None) +def test_public_static_event(): + """Test public static events.""" + handler = GenericHandler() + assert handler.value is None - EventTest.PublicStaticEvent += handler.handler + EventTest.PublicStaticEvent += handler.handler - EventTest.OnPublicStaticEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) + EventTest.OnPublicStaticEvent(EventArgsTest(10)) + assert handler.value == 10 - def test_protected_instance_event(self): - """Test protected instance events.""" - ob = EventTest() - handler = GenericHandler() - self.assertTrue(handler.value is None) +def test_protected_instance_event(): + """Test protected instance events.""" + ob = EventTest() - ob.ProtectedEvent += handler.handler + handler = GenericHandler() + assert handler.value is None - ob.OnProtectedEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) + ob.ProtectedEvent += handler.handler - ob.ProtectedEvent -= handler.handler + ob.OnProtectedEvent(EventArgsTest(10)) + assert handler.value == 10 - def test_protected_static_event(self): - """Test protected static events.""" - handler = GenericHandler() - self.assertTrue(handler.value is None) + ob.ProtectedEvent -= handler.handler - EventTest.ProtectedStaticEvent += handler.handler - EventTest.OnProtectedStaticEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) +def test_protected_static_event(): + """Test protected static events.""" + handler = GenericHandler() + assert handler.value is None - EventTest.ProtectedStaticEvent -= handler.handler + EventTest.ProtectedStaticEvent += handler.handler - def test_internal_events(self): - """Test internal events.""" + EventTest.OnProtectedStaticEvent(EventArgsTest(10)) + assert handler.value == 10 - with self.assertRaises(AttributeError): - _ = EventTest().InternalEvent + EventTest.ProtectedStaticEvent -= handler.handler - with self.assertRaises(AttributeError): - _ = EventTest().InternalStaticEvent - with self.assertRaises(AttributeError): - _ = EventTest.InternalStaticEvent +def test_internal_events(): + """Test internal events.""" - def test_private_events(self): - """Test private events.""" + with pytest.raises(AttributeError): + _ = EventTest().InternalEvent - with self.assertRaises(AttributeError): - _ = EventTest().PrivateEvent + with pytest.raises(AttributeError): + _ = EventTest().InternalStaticEvent - with self.assertRaises(AttributeError): - _ = EventTest().PrivateStaticEvent + with pytest.raises(AttributeError): + _ = EventTest.InternalStaticEvent - with self.assertRaises(AttributeError): - _ = EventTest.PrivateStaticEvent - def test_multicast_event(self): - """Test multicast events.""" - ob = EventTest() +def test_private_events(): + """Test private events.""" - handler1 = GenericHandler() - handler2 = GenericHandler() - handler3 = GenericHandler() + with pytest.raises(AttributeError): + _ = EventTest().PrivateEvent - ob.PublicEvent += handler1.handler - ob.PublicEvent += handler2.handler - ob.PublicEvent += handler3.handler + with pytest.raises(AttributeError): + _ = EventTest().PrivateStaticEvent - ob.OnPublicEvent(EventArgsTest(10)) + with pytest.raises(AttributeError): + _ = EventTest.PrivateStaticEvent - self.assertTrue(handler1.value == 10) - self.assertTrue(handler2.value == 10) - self.assertTrue(handler3.value == 10) - ob.OnPublicEvent(EventArgsTest(20)) +def test_multicast_event(): + """Test multicast events.""" + ob = EventTest() - self.assertTrue(handler1.value == 20) - self.assertTrue(handler2.value == 20) - self.assertTrue(handler3.value == 20) + handler1 = GenericHandler() + handler2 = GenericHandler() + handler3 = GenericHandler() - ob.PublicEvent -= handler1.handler - ob.PublicEvent -= handler2.handler - ob.PublicEvent -= handler3.handler + ob.PublicEvent += handler1.handler + ob.PublicEvent += handler2.handler + ob.PublicEvent += handler3.handler - def test_instance_method_handler(self): - """Test instance method handlers.""" - ob = EventTest() - handler = GenericHandler() + ob.OnPublicEvent(EventArgsTest(10)) - ob.PublicEvent += handler.handler - self.assertTrue(handler.value is None) + assert handler1.value == 10 + assert handler2.value == 10 + assert handler3.value == 10 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) + ob.OnPublicEvent(EventArgsTest(20)) - ob.PublicEvent -= handler.handler - self.assertTrue(handler.value == 10) + assert handler1.value == 20 + assert handler2.value == 20 + assert handler3.value == 20 - ob.OnPublicEvent(EventArgsTest(20)) - self.assertTrue(handler.value == 10) + ob.PublicEvent -= handler1.handler + ob.PublicEvent -= handler2.handler + ob.PublicEvent -= handler3.handler - def test_var_args_instance_method_handler(self): - """Test vararg instance method handlers.""" - ob = EventTest() - handler = VariableArgsHandler() - ob.PublicEvent += handler.handler - self.assertTrue(handler.value is None) +def test_instance_method_handler(): + """Test instance method handlers.""" + ob = EventTest() + handler = GenericHandler() - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) + ob.PublicEvent += handler.handler + assert handler.value is None - ob.PublicEvent -= handler.handler - self.assertTrue(handler.value == 10) + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 10 - ob.OnPublicEvent(EventArgsTest(20)) - self.assertTrue(handler.value == 10) + ob.PublicEvent -= handler.handler + assert handler.value == 10 - def test_callableob_handler(self): - """Test callable ob handlers.""" - ob = EventTest() - handler = CallableHandler() + ob.OnPublicEvent(EventArgsTest(20)) + assert handler.value == 10 - ob.PublicEvent += handler - self.assertTrue(handler.value is None) - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) +def test_var_args_instance_method_handler(): + """Test vararg instance method handlers.""" + ob = EventTest() + handler = VariableArgsHandler() - ob.PublicEvent -= handler - self.assertTrue(handler.value == 10) + ob.PublicEvent += handler.handler + assert handler.value is None - ob.OnPublicEvent(EventArgsTest(20)) - self.assertTrue(handler.value == 10) + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 10 - def test_var_args_callable_handler(self): - """Test varargs callable handlers.""" - ob = EventTest() - handler = VarCallableHandler() + ob.PublicEvent -= handler.handler + assert handler.value == 10 - ob.PublicEvent += handler - self.assertTrue(handler.value is None) + ob.OnPublicEvent(EventArgsTest(20)) + assert handler.value == 10 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) - ob.PublicEvent -= handler - self.assertTrue(handler.value == 10) +def test_callableob_handler(): + """Test callable ob handlers.""" + ob = EventTest() + handler = CallableHandler() - ob.OnPublicEvent(EventArgsTest(20)) - self.assertTrue(handler.value == 10) + ob.PublicEvent += handler + assert handler.value is None - def test_static_method_handler(self): - """Test static method handlers.""" - ob = EventTest() - handler = StaticMethodHandler() - StaticMethodHandler.value = None + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 10 - ob.PublicEvent += handler.handler - self.assertTrue(handler.value is None) + ob.PublicEvent -= handler + assert handler.value == 10 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) + ob.OnPublicEvent(EventArgsTest(20)) + assert handler.value == 10 - ob.PublicEvent -= handler.handler - self.assertTrue(handler.value == 10) - ob.OnPublicEvent(EventArgsTest(20)) - self.assertTrue(handler.value == 10) +def test_var_args_callable_handler(): + """Test varargs callable handlers.""" + ob = EventTest() + handler = VarCallableHandler() - def test_class_method_handler(self): - """Test class method handlers.""" - ob = EventTest() - handler = ClassMethodHandler() - ClassMethodHandler.value = None + ob.PublicEvent += handler + assert handler.value is None - ob.PublicEvent += handler.handler - self.assertTrue(handler.value is None) + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 10 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) + ob.PublicEvent -= handler + assert handler.value == 10 - ob.PublicEvent -= handler.handler - self.assertTrue(handler.value == 10) + ob.OnPublicEvent(EventArgsTest(20)) + assert handler.value == 10 - ob.OnPublicEvent(EventArgsTest(20)) - self.assertTrue(handler.value == 10) - def test_managed_instance_method_handler(self): - """Test managed instance method handlers.""" - ob = EventTest() +def test_static_method_handler(): + """Test static method handlers.""" + ob = EventTest() + handler = StaticMethodHandler() + StaticMethodHandler.value = None - ob.PublicEvent += ob.GenericHandler - self.assertTrue(ob.value == 0) + ob.PublicEvent += handler.handler + assert handler.value is None - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(ob.value == 10) + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 10 - ob.PublicEvent -= ob.GenericHandler - self.assertTrue(ob.value == 10) + ob.PublicEvent -= handler.handler + assert handler.value == 10 - ob.OnPublicEvent(EventArgsTest(20)) - self.assertTrue(ob.value == 10) + ob.OnPublicEvent(EventArgsTest(20)) + assert handler.value == 10 - def test_managed_static_method_handler(self): - """Test managed static method handlers.""" - ob = EventTest() - EventTest.s_value = 0 - ob.PublicEvent += ob.StaticHandler - self.assertTrue(EventTest.s_value == 0) +def test_class_method_handler(): + """Test class method handlers.""" + ob = EventTest() + handler = ClassMethodHandler() + ClassMethodHandler.value = None - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(EventTest.s_value == 10) + ob.PublicEvent += handler.handler + assert handler.value is None - ob.PublicEvent -= ob.StaticHandler - self.assertTrue(EventTest.s_value == 10) + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 10 - ob.OnPublicEvent(EventArgsTest(20)) - self.assertTrue(EventTest.s_value == 10) + ob.PublicEvent -= handler.handler + assert handler.value == 10 - def test_unbound_method_handler(self): - """Test failure mode for unbound method handlers.""" - ob = EventTest() - ob.PublicEvent += GenericHandler.handler + ob.OnPublicEvent(EventArgsTest(20)) + assert handler.value == 10 - with self.assertRaises(TypeError): - ob.OnPublicEvent(EventArgsTest(10)) - ob.PublicEvent -= GenericHandler.handler +def test_managed_instance_method_handler(): + """Test managed instance method handlers.""" + ob = EventTest() - def test_function_handler(self): - """Test function handlers.""" - ob = EventTest() - dict_ = {'value': None} + ob.PublicEvent += ob.GenericHandler + assert ob.value == 0 + + ob.OnPublicEvent(EventArgsTest(10)) + assert ob.value == 10 - def handler(sender, args, dict_=dict_): - dict_['value'] = args.value + ob.PublicEvent -= ob.GenericHandler + assert ob.value == 10 - ob.PublicEvent += handler - self.assertTrue(dict_['value'] is None) + ob.OnPublicEvent(EventArgsTest(20)) + assert ob.value == 10 + +def test_managed_static_method_handler(): + """Test managed static method handlers.""" + ob = EventTest() + EventTest.s_value = 0 + + ob.PublicEvent += ob.StaticHandler + assert EventTest.s_value == 0 + + ob.OnPublicEvent(EventArgsTest(10)) + assert EventTest.s_value == 10 + + ob.PublicEvent -= ob.StaticHandler + assert EventTest.s_value == 10 + + ob.OnPublicEvent(EventArgsTest(20)) + assert EventTest.s_value == 10 + + +def test_unbound_method_handler(): + """Test failure mode for unbound method handlers.""" + ob = EventTest() + ob.PublicEvent += GenericHandler.handler + + with pytest.raises(TypeError): ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(dict_['value'] == 10) - ob.PublicEvent -= handler - self.assertTrue(dict_['value'] == 10) + ob.PublicEvent -= GenericHandler.handler + - ob.OnPublicEvent(EventArgsTest(20)) - self.assertTrue(dict_['value'] == 10) +def test_function_handler(): + """Test function handlers.""" + ob = EventTest() + dict_ = {'value': None} - def test_add_non_callable_handler(self): - """Test handling of attempts to add non-callable handlers.""" + def handler(sender, args, dict_=dict_): + dict_['value'] = args.value - with self.assertRaises(TypeError): - ob = EventTest() - ob.PublicEvent += 10 + ob.PublicEvent += handler + assert dict_['value'] is None - with self.assertRaises(TypeError): - ob = EventTest() - ob.PublicEvent += "spam" + ob.OnPublicEvent(EventArgsTest(10)) + assert dict_['value'] == 10 - with self.assertRaises(TypeError): - class Spam(object): - pass + ob.PublicEvent -= handler + assert dict_['value'] == 10 - ob = EventTest() - ob.PublicEvent += Spam() + ob.OnPublicEvent(EventArgsTest(20)) + assert dict_['value'] == 10 - def test_remove_multiple_handlers(self): - """Test removing multiple instances of the same handler.""" + +def test_add_non_callable_handler(): + """Test handling of attempts to add non-callable handlers.""" + + with pytest.raises(TypeError): ob = EventTest() - handler = MultipleHandler() + ob.PublicEvent += 10 - h1 = handler.handler - ob.PublicEvent += h1 + with pytest.raises(TypeError): + ob = EventTest() + ob.PublicEvent += "spam" - h2 = handler.handler - ob.PublicEvent += h2 + with pytest.raises(TypeError): + class Spam(object): + pass - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 20) + ob = EventTest() + ob.PublicEvent += Spam() - ob.PublicEvent -= h1 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 30) +def test_remove_multiple_handlers(): + """Test removing multiple instances of the same handler.""" + ob = EventTest() + handler = MultipleHandler() - ob.PublicEvent -= h2 + h1 = handler.handler + ob.PublicEvent += h1 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 30) + h2 = handler.handler + ob.PublicEvent += h2 - # try again, removing in a different order. + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 20 - ob = EventTest() - handler = MultipleHandler() + ob.PublicEvent -= h1 - h1 = handler.handler - ob.PublicEvent += h1 + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 30 - h2 = handler.handler - ob.PublicEvent += h2 + ob.PublicEvent -= h2 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 20) + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 30 - ob.PublicEvent -= h2 + # try again, removing in a different order. - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 30) + ob = EventTest() + handler = MultipleHandler() - ob.PublicEvent -= h1 + h1 = handler.handler + ob.PublicEvent += h1 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 30) + h2 = handler.handler + ob.PublicEvent += h2 - def test_remove_multiple_static_handlers(self): - """Test removing multiple instances of a static handler.""" - ob = EventTest() - handler = MultipleHandler() + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 20 - h1 = handler.handler - ob.PublicStaticEvent += h1 + ob.PublicEvent -= h2 - h2 = handler.handler - ob.PublicStaticEvent += h2 + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 30 - ob.OnPublicStaticEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 20) + ob.PublicEvent -= h1 - ob.PublicStaticEvent -= h1 + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 30 - ob.OnPublicStaticEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 30) - ob.PublicStaticEvent -= h2 +def test_remove_multiple_static_handlers(): + """Test removing multiple instances of a static handler.""" + ob = EventTest() + handler = MultipleHandler() - ob.OnPublicStaticEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 30) + h1 = handler.handler + ob.PublicStaticEvent += h1 - # try again, removing in a different order. + h2 = handler.handler + ob.PublicStaticEvent += h2 - ob = EventTest() - handler = MultipleHandler() + ob.OnPublicStaticEvent(EventArgsTest(10)) + assert handler.value == 20 - h1 = handler.handler - ob.PublicStaticEvent += h1 + ob.PublicStaticEvent -= h1 - h2 = handler.handler - ob.PublicStaticEvent += h2 + ob.OnPublicStaticEvent(EventArgsTest(10)) + assert handler.value == 30 - ob.OnPublicStaticEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 20) + ob.PublicStaticEvent -= h2 - ob.PublicStaticEvent -= h2 + ob.OnPublicStaticEvent(EventArgsTest(10)) + assert handler.value == 30 - ob.OnPublicStaticEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 30) + # try again, removing in a different order. - ob.PublicStaticEvent -= h1 + ob = EventTest() + handler = MultipleHandler() - ob.OnPublicStaticEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 30) + h1 = handler.handler + ob.PublicStaticEvent += h1 - def test_random_multiple_handlers(self): - """Test random subscribe / unsubscribe of the same handlers.""" - import random - ob = EventTest() - handler = MultipleHandler() - handler2 = MultipleHandler() + h2 = handler.handler + ob.PublicStaticEvent += h2 - ob.PublicEvent += handler2.handler - ob.PublicEvent += handler2.handler + ob.OnPublicStaticEvent(EventArgsTest(10)) + assert handler.value == 20 - handlers = [] - for _ in range(30): - method = handler.handler - ob.PublicEvent += method - handlers.append(method) + ob.PublicStaticEvent -= h2 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 300) - self.assertTrue(handler2.value == 20) - handler.value = 0 - handler2.value = 0 - - for i in range(30): - item = random.choice(handlers) - handlers.remove(item) - ob.PublicEvent -= item - handler.value = 0 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == (len(handlers) * 10)) - self.assertTrue(handler2.value == ((i + 1) * 20)) - - handler2.value = 0 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler2.value == 20) + ob.OnPublicStaticEvent(EventArgsTest(10)) + assert handler.value == 30 - ob.PublicEvent -= handler2.handler + ob.PublicStaticEvent -= h1 - handler2.value = 0 - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler2.value == 10) + ob.OnPublicStaticEvent(EventArgsTest(10)) + assert handler.value == 30 + + +def test_random_multiple_handlers(): + """Test random subscribe / unsubscribe of the same handlers.""" + import random + ob = EventTest() + handler = MultipleHandler() + handler2 = MultipleHandler() + + ob.PublicEvent += handler2.handler + ob.PublicEvent += handler2.handler - ob.PublicEvent -= handler2.handler + handlers = [] + for _ in range(30): + method = handler.handler + ob.PublicEvent += method + handlers.append(method) - handler2.value = 0 + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 300 + assert handler2.value == 20 + handler.value = 0 + handler2.value = 0 + + for i in range(30): + item = random.choice(handlers) + handlers.remove(item) + ob.PublicEvent -= item + handler.value = 0 ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler2.value == 0) + assert handler.value == (len(handlers) * 10) + assert handler2.value == ((i + 1) * 20) - def test_remove_internal_call_handler(self): - """Test remove on an event sink implemented w/internalcall.""" - ob = EventTest() + handler2.value = 0 + ob.OnPublicEvent(EventArgsTest(10)) + assert handler2.value == 20 - def h(sender, args): - pass + ob.PublicEvent -= handler2.handler - ob.PublicEvent += h - ob.PublicEvent -= h + handler2.value = 0 + ob.OnPublicEvent(EventArgsTest(10)) + assert handler2.value == 10 - def test_remove_unknown_handler(self): - """Test removing an event handler that was never added.""" + ob.PublicEvent -= handler2.handler - with self.assertRaises(ValueError): - ob = EventTest() - handler = GenericHandler() + handler2.value = 0 + ob.OnPublicEvent(EventArgsTest(10)) + assert handler2.value == 0 - ob.PublicEvent -= handler.handler - def test_handler_callback_failure(self): - """Test failure mode for inappropriate handlers.""" +def test_remove_internal_call_handler(): + """Test remove on an event sink implemented w/internalcall.""" + ob = EventTest() - class BadHandler(object): - def handler(self, one): - return 'too many' + def h(sender, args): + pass + + ob.PublicEvent += h + ob.PublicEvent -= h - ob = EventTest() - handler = BadHandler() - with self.assertRaises(TypeError): - ob.PublicEvent += handler.handler - ob.OnPublicEvent(EventArgsTest(10)) +def test_remove_unknown_handler(): + """Test removing an event handler that was never added.""" + + with pytest.raises(ValueError): + ob = EventTest() + handler = GenericHandler() ob.PublicEvent -= handler.handler - class BadHandler(object): - def handler(self, one, two, three, four, five): - return 'not enough' - ob = EventTest() - handler = BadHandler() +def test_handler_callback_failure(): + """Test failure mode for inappropriate handlers.""" - with self.assertRaises(TypeError): - ob.PublicEvent += handler.handler - ob.OnPublicEvent(EventArgsTest(10)) + class BadHandler(object): + def handler(self, one): + return 'too many' - ob.PublicEvent -= handler.handler + ob = EventTest() + handler = BadHandler() - def test_incorrect_invokation(self): - """Test incorrect invocation of events.""" - ob = EventTest() + with pytest.raises(TypeError): + ob.PublicEvent += handler.handler + ob.OnPublicEvent(EventArgsTest(10)) - handler = GenericHandler() + ob.PublicEvent -= handler.handler + + class BadHandler(object): + def handler(self, one, two, three, four, five): + return 'not enough' + + ob = EventTest() + handler = BadHandler() + + with pytest.raises(TypeError): ob.PublicEvent += handler.handler + ob.OnPublicEvent(EventArgsTest(10)) - with self.assertRaises(TypeError): - ob.OnPublicEvent() + ob.PublicEvent -= handler.handler - with self.assertRaises(TypeError): - ob.OnPublicEvent(32) - ob.PublicEvent -= handler.handler +def test_incorrect_invokation(): + """Test incorrect invocation of events.""" + ob = EventTest() - def test_explicit_cls_event_registration(self): - """Test explicit CLS event registration.""" - from Python.Test import EventHandlerTest + handler = GenericHandler() + ob.PublicEvent += handler.handler - ob = EventTest() - handler = GenericHandler() + with pytest.raises(TypeError): + ob.OnPublicEvent() - delegate = EventHandlerTest(handler.handler) - ob.add_PublicEvent(delegate) - self.assertTrue(handler.value is None) + with pytest.raises(TypeError): + ob.OnPublicEvent(32) - ob.OnPublicEvent(EventArgsTest(10)) - self.assertTrue(handler.value == 10) + ob.PublicEvent -= handler.handler + + +def test_explicit_cls_event_registration(): + """Test explicit CLS event registration.""" + from Python.Test import EventHandlerTest - ob.remove_PublicEvent(delegate) - self.assertTrue(handler.value == 10) + ob = EventTest() + handler = GenericHandler() - ob.OnPublicEvent(EventArgsTest(20)) - self.assertTrue(handler.value == 10) + delegate = EventHandlerTest(handler.handler) + ob.add_PublicEvent(delegate) + assert handler.value is None - def test_implicit_cls_event_registration(self): - """Test implicit CLS event registration.""" + ob.OnPublicEvent(EventArgsTest(10)) + assert handler.value == 10 - with self.assertRaises(TypeError): - ob = EventTest() - handler = GenericHandler() - ob.add_PublicEvent(handler.handler) + ob.remove_PublicEvent(delegate) + assert handler.value == 10 - def test_event_descriptor_abuse(self): - """Test event descriptor abuse.""" + ob.OnPublicEvent(EventArgsTest(20)) + assert handler.value == 10 - with self.assertRaises(TypeError): - del EventTest.PublicEvent - with self.assertRaises(TypeError): - del EventTest.__dict__['PublicEvent'] +def test_implicit_cls_event_registration(): + """Test implicit CLS event registration.""" + + with pytest.raises(TypeError): + ob = EventTest() + handler = GenericHandler() + ob.add_PublicEvent(handler.handler) - desc = EventTest.__dict__['PublicEvent'] - with self.assertRaises(TypeError): - desc.__get__(0, 0) +def test_event_descriptor_abuse(): + """Test event descriptor abuse.""" - with self.assertRaises(TypeError): - desc.__set__(0, 0) + with pytest.raises(TypeError): + del EventTest.PublicEvent - with self.assertRaises(TypeError): - ob = EventTest() - ob.PublicEvent = 0 + with pytest.raises(TypeError): + del EventTest.__dict__['PublicEvent'] - with self.assertRaises(TypeError): - EventTest.PublicStaticEvent = 0 + desc = EventTest.__dict__['PublicEvent'] + with pytest.raises(TypeError): + desc.__get__(0, 0) + + with pytest.raises(TypeError): + desc.__set__(0, 0) + + with pytest.raises(TypeError): + ob = EventTest() + ob.PublicEvent = 0 -def test_suite(): - return unittest.makeSuite(EventTests) + with pytest.raises(TypeError): + EventTest.PublicStaticEvent = 0 diff --git a/src/tests/test_exceptions.py b/src/tests/test_exceptions.py index 2fb55589c..f47209f6d 100644 --- a/src/tests/test_exceptions.py +++ b/src/tests/test_exceptions.py @@ -1,328 +1,347 @@ # -*- coding: utf-8 -*- +"""Test exception support.""" + import sys -import unittest import System +import pytest + +from ._compat import PY2, PY3, pickle, text_type + + +def test_unified_exception_semantics(): + """Test unified exception semantics.""" + e = System.Exception('Something bad happened') + assert isinstance(e, Exception) + assert isinstance(e, System.Exception) + + +def test_standard_exception_attributes(): + """Test accessing standard exception attributes.""" + from System import OverflowException + from Python.Test import ExceptionTest + + e = ExceptionTest.GetExplicitException() + assert isinstance(e, OverflowException) + + assert e.Message == 'error' + + e.Source = 'Test Suite' + assert e.Source == 'Test Suite' + + v = e.ToString() + assert len(v) > 0 + + +def test_extended_exception_attributes(): + """Test accessing extended exception attributes.""" + from Python.Test import ExceptionTest, ExtendedException + from System import OverflowException + + e = ExceptionTest.GetExtendedException() + assert isinstance(e, ExtendedException) + assert isinstance(e, OverflowException) + assert isinstance(e, System.Exception) + + assert e.Message == 'error' + + e.Source = 'Test Suite' + assert e.Source == 'Test Suite' + + v = e.ToString() + assert len(v) > 0 + + assert e.ExtraProperty == 'extra' + e.ExtraProperty = 'changed' + assert e.ExtraProperty == 'changed' + + assert e.GetExtraInfo() == 'changed' + + +def test_raise_class_exception(): + """Test class exception propagation.""" + from System import NullReferenceException + + with pytest.raises(NullReferenceException) as cm: + raise NullReferenceException + + exc = cm.value + assert isinstance(exc, NullReferenceException) + + +def test_exc_info(): + """Test class exception propagation. + Behavior of exc_info changed in Py3. Refactoring its test""" + from System import NullReferenceException + try: + raise NullReferenceException("message") + except Exception as exc: + type_, value, tb = sys.exc_info() + assert type_ is NullReferenceException + assert value.Message == "message" + assert exc.Message == "message" + # FIXME: Lower-case message isn't implemented + # self.assertTrue(exc.message == "message") + assert value is exc + + +def test_raise_class_exception_with_value(): + """Test class exception propagation with associated value.""" + from System import NullReferenceException + + with pytest.raises(NullReferenceException) as cm: + raise NullReferenceException('Aiiieee!') + + exc = cm.value + assert isinstance(exc, NullReferenceException) + assert exc.Message == 'Aiiieee!' + + +def test_raise_instance_exception(): + """Test instance exception propagation.""" + from System import NullReferenceException + + with pytest.raises(NullReferenceException) as cm: + raise NullReferenceException() + + exc = cm.value + assert isinstance(exc, NullReferenceException) + assert len(exc.Message) > 0 + + +def test_raise_instance_exception_with_args(): + """Test instance exception propagation with args.""" + from System import NullReferenceException -from _compat import PY2, PY3, pickle, text_type + with pytest.raises(NullReferenceException) as cm: + raise NullReferenceException("Aiiieee!") + exc = cm.value + assert isinstance(exc, NullReferenceException) + assert exc.Message == 'Aiiieee!' -class ExceptionTests(unittest.TestCase): - """Test exception support.""" - def test_unified_exception_semantics(self): - """Test unified exception semantics.""" - e = System.Exception('Something bad happened') - self.assertTrue(isinstance(e, Exception)) - self.assertTrue(isinstance(e, System.Exception)) +def test_managed_exception_propagation(): + """Test propagation of exceptions raised in managed code.""" + from System import Decimal, OverflowException - def test_standard_exception_attributes(self): - """Test accessing standard exception attributes.""" - from System import OverflowException - from Python.Test import ExceptionTest + with pytest.raises(OverflowException): + Decimal.ToInt64(Decimal.MaxValue) - e = ExceptionTest.GetExplicitException() - self.assertTrue(isinstance(e, OverflowException)) - self.assertTrue(e.Message == 'error') +def test_managed_exception_conversion(): + """Test conversion of managed exceptions.""" + from System import OverflowException + from Python.Test import ExceptionTest - e.Source = 'Test Suite' - self.assertTrue(e.Source == 'Test Suite') + e = ExceptionTest.GetBaseException() + assert isinstance(e, System.Exception) - v = e.ToString() - self.assertTrue(len(v) > 0) + e = ExceptionTest.GetExplicitException() + assert isinstance(e, OverflowException) + assert isinstance(e, System.Exception) - def test_extended_exception_attributes(self): - """Test accessing extended exception attributes.""" - from Python.Test import ExceptionTest, ExtendedException - from System import OverflowException + e = ExceptionTest.GetWidenedException() + assert isinstance(e, OverflowException) + assert isinstance(e, System.Exception) - e = ExceptionTest.GetExtendedException() - self.assertTrue(isinstance(e, ExtendedException)) - self.assertTrue(isinstance(e, OverflowException)) - self.assertTrue(isinstance(e, System.Exception)) + v = ExceptionTest.SetBaseException(System.Exception('error')) + assert v - self.assertTrue(e.Message == 'error') + v = ExceptionTest.SetExplicitException(OverflowException('error')) + assert v - e.Source = 'Test Suite' - self.assertTrue(e.Source == 'Test Suite') + v = ExceptionTest.SetWidenedException(OverflowException('error')) + assert v - v = e.ToString() - self.assertTrue(len(v) > 0) - self.assertTrue(e.ExtraProperty == 'extra') - e.ExtraProperty = 'changed' - self.assertTrue(e.ExtraProperty == 'changed') +def test_catch_exception_from_managed_method(): + """Test catching an exception from a managed method.""" + from Python.Test import ExceptionTest + from System import OverflowException - self.assertTrue(e.GetExtraInfo() == 'changed') + with pytest.raises(OverflowException) as cm: + ExceptionTest().ThrowException() - def test_raise_class_exception(self): - """Test class exception propagation.""" - from System import NullReferenceException + e = cm.value + assert isinstance(e, OverflowException) - with self.assertRaises(NullReferenceException) as cm: - raise NullReferenceException - exc = cm.exception - self.assertTrue(isinstance(exc, NullReferenceException)) +def test_catch_exception_from_managed_property(): + """Test catching an exception from a managed property.""" + from Python.Test import ExceptionTest + from System import OverflowException - def test_exc_info(self): - """Test class exception propagation. - Behavior of exc_info changed in Py3. Refactoring its test""" - from System import NullReferenceException - try: - raise NullReferenceException("message") - except Exception as exc: - type_, value, tb = sys.exc_info() - self.assertTrue(type_ is NullReferenceException) - self.assertTrue(value.Message == "message") - self.assertTrue(exc.Message == "message") - # FIXME: Lower-case message isn't implemented - # self.assertTrue(exc.message == "message") - self.assertTrue(value is exc) + with pytest.raises(OverflowException) as cm: + _ = ExceptionTest().ThrowProperty - def test_raise_class_exception_with_value(self): - """Test class exception propagation with associated value.""" - from System import NullReferenceException + e = cm.value + assert isinstance(e, OverflowException) - with self.assertRaises(NullReferenceException) as cm: - raise NullReferenceException('Aiiieee!') + with pytest.raises(OverflowException) as cm: + ExceptionTest().ThrowProperty = 1 - exc = cm.exception - self.assertTrue(isinstance(exc, NullReferenceException)) - self.assertTrue(exc.Message == 'Aiiieee!') + e = cm.value + assert isinstance(e, OverflowException) - def test_raise_instance_exception(self): - """Test instance exception propagation.""" - from System import NullReferenceException - with self.assertRaises(NullReferenceException) as cm: - raise NullReferenceException() +def test_catch_exception_managed_class(): + """Test catching the managed class of an exception.""" + from System import OverflowException - exc = cm.exception - self.assertTrue(isinstance(exc, NullReferenceException)) - self.assertTrue(len(exc.Message) > 0) + with pytest.raises(OverflowException): + raise OverflowException('overflow') - def test_raise_instance_exception_with_args(self): - """Test instance exception propagation with args.""" - from System import NullReferenceException - with self.assertRaises(NullReferenceException) as cm: - raise NullReferenceException("Aiiieee!") +def test_catch_exception_python_class(): + """Test catching the python class of an exception.""" + from System import OverflowException - exc = cm.exception - self.assertTrue(isinstance(exc, NullReferenceException)) - self.assertTrue(exc.Message == 'Aiiieee!') + with pytest.raises(Exception): + raise OverflowException('overflow') - def test_managed_exception_propagation(self): - """Test propagation of exceptions raised in managed code.""" - from System import Decimal, OverflowException - with self.assertRaises(OverflowException): - Decimal.ToInt64(Decimal.MaxValue) +def test_catch_exception_base_class(): + """Test catching the base of an exception.""" + from System import OverflowException, ArithmeticException - def test_managed_exception_conversion(self): - """Test conversion of managed exceptions.""" - from System import OverflowException - from Python.Test import ExceptionTest + with pytest.raises(ArithmeticException): + raise OverflowException('overflow') - e = ExceptionTest.GetBaseException() - self.assertTrue(isinstance(e, System.Exception)) - e = ExceptionTest.GetExplicitException() - self.assertTrue(isinstance(e, OverflowException)) - self.assertTrue(isinstance(e, System.Exception)) +def test_catch_exception_nested_base_class(): + """Test catching the nested base of an exception.""" + from System import OverflowException, SystemException - e = ExceptionTest.GetWidenedException() - self.assertTrue(isinstance(e, OverflowException)) - self.assertTrue(isinstance(e, System.Exception)) + with pytest.raises(SystemException): + raise OverflowException('overflow') - v = ExceptionTest.SetBaseException(System.Exception('error')) - self.assertTrue(v) - v = ExceptionTest.SetExplicitException(OverflowException('error')) - self.assertTrue(v) +def test_catch_exception_with_assignment(): + """Test catching an exception with assignment.""" + from System import OverflowException - v = ExceptionTest.SetWidenedException(OverflowException('error')) - self.assertTrue(v) + with pytest.raises(OverflowException) as cm: + raise OverflowException('overflow') - def test_catch_exception_from_managed_method(self): - """Test catching an exception from a managed method.""" - from Python.Test import ExceptionTest - from System import OverflowException + e = cm.value + assert isinstance(e, OverflowException) - with self.assertRaises(OverflowException) as cm: - ExceptionTest().ThrowException() - e = cm.exception - self.assertTrue(isinstance(e, OverflowException)) +def test_catch_exception_unqualified(): + """Test catching an unqualified exception.""" + from System import OverflowException - def test_catch_exception_from_managed_property(self): - """Test catching an exception from a managed property.""" - from Python.Test import ExceptionTest - from System import OverflowException + try: + raise OverflowException('overflow') + except: + pass + else: + self.fail("failed to catch unqualified exception") - with self.assertRaises(OverflowException) as cm: - _ = ExceptionTest().ThrowProperty - e = cm.exception - self.assertTrue(isinstance(e, OverflowException)) +def test_catch_baseexception(): + """Test catching an unqualified exception with BaseException.""" + from System import OverflowException - with self.assertRaises(OverflowException) as cm: - ExceptionTest().ThrowProperty = 1 + with pytest.raises(BaseException): + raise OverflowException('overflow') - e = cm.exception - self.assertTrue(isinstance(e, OverflowException)) - def test_catch_exception_managed_class(self): - """Test catching the managed class of an exception.""" - from System import OverflowException +def test_apparent_module_of_exception(): + """Test the apparent module of an exception.""" + from System import OverflowException - with self.assertRaises(OverflowException): - raise OverflowException('overflow') + assert System.Exception.__module__ == 'System' + assert OverflowException.__module__ == 'System' - def test_catch_exception_python_class(self): - """Test catching the python class of an exception.""" - from System import OverflowException - with self.assertRaises(Exception): - raise OverflowException('overflow') +def test_str_of_exception(): + """Test the str() representation of an exception.""" + from System import NullReferenceException, Convert, FormatException - def test_catch_exception_base_class(self): - """Test catching the base of an exception.""" - from System import OverflowException, ArithmeticException + e = NullReferenceException('') + assert str(e) == '' - with self.assertRaises(ArithmeticException): - raise OverflowException('overflow') + e = NullReferenceException('Something bad happened') + assert str(e).startswith('Something bad happened') - def test_catch_exception_nested_base_class(self): - """Test catching the nested base of an exception.""" - from System import OverflowException, SystemException + with pytest.raises(FormatException) as cm: + Convert.ToDateTime('this will fail') - with self.assertRaises(SystemException): - raise OverflowException('overflow') + e = cm.value + # fix for international installation + msg = text_type(e).encode("utf8") + fnd = text_type('System.Convert.ToDateTime').encode("utf8") + assert msg.find(fnd) > -1, msg - def test_catch_exception_with_assignment(self): - """Test catching an exception with assignment.""" - from System import OverflowException - with self.assertRaises(OverflowException) as cm: - raise OverflowException('overflow') +def test_python_compat_of_managed_exceptions(): + """Test managed exceptions compatible with Python's implementation""" + from System import OverflowException + msg = "Simple message" - e = cm.exception - self.assertTrue(isinstance(e, OverflowException)) + e = OverflowException(msg) + assert str(e) == msg + assert text_type(e) == msg - def test_catch_exception_unqualified(self): - """Test catching an unqualified exception.""" - from System import OverflowException + assert e.args == (msg,) + assert isinstance(e.args, tuple) + if PY3: + assert repr(e) == "OverflowException('Simple message',)" + elif PY2: + assert repr(e) == "OverflowException(u'Simple message',)" - try: - raise OverflowException('overflow') - except: - pass - else: - self.fail("failed to catch unqualified exception") - def test_catch_baseexception(self): - """Test catching an unqualified exception with BaseException.""" - from System import OverflowException +def test_exception_is_instance_of_system_object(): + """Test behavior of isinstance(, System.Object).""" + # This is an anti-test, in that this is a caveat of the current + # implementation. Because exceptions are not allowed to be new-style + # classes, we wrap managed exceptions in a general-purpose old-style + # class that delegates to the wrapped object. This makes _almost_ + # everything work as expected, except that an isinstance check against + # CLR.System.Object will fail for a managed exception (because a new + # style class cannot appear in the __bases__ of an old-style class + # without causing a crash in the CPython interpreter). This test is + # here mainly to remind me to update the caveat in the documentation + # one day when when exceptions can be new-style classes. - with self.assertRaises(BaseException): - raise OverflowException('overflow') + # This behavior is now over-shadowed by the implementation of + # __instancecheck__ (i.e., overloading isinstance), so for all Python + # version >= 2.6 we expect isinstance(, Object) to + # be true, even though it does not really subclass Object. + from System import OverflowException, Object - def test_apparent_module_of_exception(self): - """Test the apparent module of an exception.""" - from System import OverflowException + o = OverflowException('error') - self.assertTrue(System.Exception.__module__ == 'System') - self.assertTrue(OverflowException.__module__ == 'System') + if sys.version_info >= (2, 6): + assert isinstance(o, Object) + else: + assert not isinstance(o, Object) - def test_str_of_exception(self): - """Test the str() representation of an exception.""" - from System import NullReferenceException, Convert, FormatException - e = NullReferenceException('') - self.assertEqual(str(e), '') +def test_pickling_exceptions(): + exc = System.Exception("test") + dumped = pickle.dumps(exc) + loaded = pickle.loads(dumped) - e = NullReferenceException('Something bad happened') - self.assertTrue(str(e).startswith('Something bad happened')) + assert exc.args == loaded.args - with self.assertRaises(FormatException) as cm: - Convert.ToDateTime('this will fail') - e = cm.exception - # fix for international installation - msg = text_type(e).encode("utf8") - fnd = text_type('System.Convert.ToDateTime').encode("utf8") - self.assertTrue(msg.find(fnd) > -1, msg) +@pytest.mark.skipif(PY2, reason="__cause__ isn't implemented in PY2") +def test_chained_exceptions(): + from Python.Test import ExceptionTest - def test_python_compat_of_managed_exceptions(self): - """Test managed exceptions compatible with Python's implementation""" - from System import OverflowException - msg = "Simple message" + with pytest.raises(Exception) as cm: + ExceptionTest.ThrowChainedExceptions() - e = OverflowException(msg) - self.assertEqual(str(e), msg) - self.assertEqual(text_type(e), msg) + exc = cm.value - self.assertEqual(e.args, (msg,)) - self.assertTrue(isinstance(e.args, tuple)) - if PY3: - self.assertEqual(repr(e), "OverflowException('Simple message',)") - elif PY2: - self.assertEqual(repr(e), "OverflowException(u'Simple message',)") - - def test_exception_is_instance_of_system_object(self): - """Test behavior of isinstance(, System.Object).""" - # This is an anti-test, in that this is a caveat of the current - # implementation. Because exceptions are not allowed to be new-style - # classes, we wrap managed exceptions in a general-purpose old-style - # class that delegates to the wrapped object. This makes _almost_ - # everything work as expected, except that an isinstance check against - # CLR.System.Object will fail for a managed exception (because a new - # style class cannot appear in the __bases__ of an old-style class - # without causing a crash in the CPython interpreter). This test is - # here mainly to remind me to update the caveat in the documentation - # one day when when exceptions can be new-style classes. - - # This behavior is now over-shadowed by the implementation of - # __instancecheck__ (i.e., overloading isinstance), so for all Python - # version >= 2.6 we expect isinstance(, Object) to - # be true, even though it does not really subclass Object. - from System import OverflowException, Object - - o = OverflowException('error') - - if sys.version_info >= (2, 6): - self.assertTrue(isinstance(o, Object)) - else: - self.assertFalse(isinstance(o, Object)) - - def test_pickling_exceptions(self): - exc = System.Exception("test") - dumped = pickle.dumps(exc) - loaded = pickle.loads(dumped) - - self.assertEqual(exc.args, loaded.args) - - @unittest.skipIf(PY2, "__cause__ isn't implemented in PY2") - def test_chained_exceptions(self): - from Python.Test import ExceptionTest - - with self.assertRaises(Exception) as cm: - ExceptionTest.ThrowChainedExceptions() - - exc = cm.exception - - msgs = ("Outer exception", - "Inner exception", - "Innermost exception",) - for msg in msgs: - self.assertEqual(exc.Message, msg) - self.assertEqual(exc.__cause__, exc.InnerException) - exc = exc.__cause__ - - -def test_suite(): - return unittest.makeSuite(ExceptionTests) + msgs = ("Outer exception", + "Inner exception", + "Innermost exception",) + for msg in msgs: + assert exc.Message == msg + assert exc.__cause__ == exc.InnerException + exc = exc.__cause__ diff --git a/src/tests/test_field.py b/src/tests/test_field.py index b1d596fea..d187de5d2 100644 --- a/src/tests/test_field.py +++ b/src/tests/test_field.py @@ -1,369 +1,392 @@ # -*- coding: utf-8 -*- -import unittest +"""Test CLR field support.""" import System +import pytest from Python.Test import FieldTest -class FieldTests(unittest.TestCase): - """Test CLR field support.""" +def test_public_instance_field(): + """Test public instance fields.""" + ob = FieldTest() + assert ob.PublicField == 0 - def test_public_instance_field(self): - """Test public instance fields.""" - ob = FieldTest() - self.assertTrue(ob.PublicField == 0) + ob.PublicField = 1 + assert ob.PublicField == 1 - ob.PublicField = 1 - self.assertTrue(ob.PublicField == 1) + with pytest.raises(TypeError): + del FieldTest().PublicField - with self.assertRaises(TypeError): - del FieldTest().PublicField - def test_public_static_field(self): - """Test public static fields.""" - ob = FieldTest() - self.assertTrue(FieldTest.PublicStaticField == 0) +def test_public_static_field(): + """Test public static fields.""" + ob = FieldTest() + assert FieldTest.PublicStaticField == 0 - FieldTest.PublicStaticField = 1 - self.assertTrue(FieldTest.PublicStaticField == 1) + FieldTest.PublicStaticField = 1 + assert FieldTest.PublicStaticField == 1 - self.assertTrue(ob.PublicStaticField == 1) - ob.PublicStaticField = 0 - self.assertTrue(ob.PublicStaticField == 0) + assert ob.PublicStaticField == 1 + ob.PublicStaticField = 0 + assert ob.PublicStaticField == 0 - with self.assertRaises(TypeError): - del FieldTest.PublicStaticField + with pytest.raises(TypeError): + del FieldTest.PublicStaticField - with self.assertRaises(TypeError): - del FieldTest().PublicStaticField + with pytest.raises(TypeError): + del FieldTest().PublicStaticField - def test_protected_instance_field(self): - """Test protected instance fields.""" - ob = FieldTest() - self.assertTrue(ob.ProtectedField == 0) - ob.ProtectedField = 1 - self.assertTrue(ob.ProtectedField == 1) +def test_protected_instance_field(): + """Test protected instance fields.""" + ob = FieldTest() + assert ob.ProtectedField == 0 - with self.assertRaises(TypeError): - del FieldTest().ProtectedField + ob.ProtectedField = 1 + assert ob.ProtectedField == 1 - def test_protected_static_field(self): - """Test protected static fields.""" - ob = FieldTest() - self.assertTrue(FieldTest.ProtectedStaticField == 0) + with pytest.raises(TypeError): + del FieldTest().ProtectedField - FieldTest.ProtectedStaticField = 1 - self.assertTrue(FieldTest.ProtectedStaticField == 1) - self.assertTrue(ob.ProtectedStaticField == 1) - ob.ProtectedStaticField = 0 - self.assertTrue(ob.ProtectedStaticField == 0) +def test_protected_static_field(): + """Test protected static fields.""" + ob = FieldTest() + assert FieldTest.ProtectedStaticField == 0 - with self.assertRaises(TypeError): - del FieldTest.ProtectedStaticField + FieldTest.ProtectedStaticField = 1 + assert FieldTest.ProtectedStaticField == 1 - with self.assertRaises(TypeError): - del FieldTest().ProtectedStaticField + assert ob.ProtectedStaticField == 1 + ob.ProtectedStaticField = 0 + assert ob.ProtectedStaticField == 0 - def test_read_only_instance_field(self): - """Test readonly instance fields.""" - self.assertTrue(FieldTest().ReadOnlyField == 0) + with pytest.raises(TypeError): + del FieldTest.ProtectedStaticField - with self.assertRaises(TypeError): - FieldTest().ReadOnlyField = 1 + with pytest.raises(TypeError): + del FieldTest().ProtectedStaticField - with self.assertRaises(TypeError): - del FieldTest().ReadOnlyField - def test_read_only_static_field(self): - """Test readonly static fields.""" - ob = FieldTest() +def test_read_only_instance_field(): + """Test readonly instance fields.""" + assert FieldTest().ReadOnlyField == 0 - self.assertTrue(FieldTest.ReadOnlyStaticField == 0) - self.assertTrue(ob.ReadOnlyStaticField == 0) + with pytest.raises(TypeError): + FieldTest().ReadOnlyField = 1 - with self.assertRaises(TypeError): - FieldTest.ReadOnlyStaticField = 1 + with pytest.raises(TypeError): + del FieldTest().ReadOnlyField - with self.assertRaises(TypeError): - FieldTest().ReadOnlyStaticField = 1 - with self.assertRaises(TypeError): - del FieldTest.ReadOnlyStaticField +def test_read_only_static_field(): + """Test readonly static fields.""" + ob = FieldTest() - with self.assertRaises(TypeError): - del FieldTest().ReadOnlyStaticField + assert FieldTest.ReadOnlyStaticField == 0 + assert ob.ReadOnlyStaticField == 0 - def test_constant_field(self): - """Test const fields.""" - ob = FieldTest() + with pytest.raises(TypeError): + FieldTest.ReadOnlyStaticField = 1 - self.assertTrue(FieldTest.ConstField == 0) - self.assertTrue(ob.ConstField == 0) + with pytest.raises(TypeError): + FieldTest().ReadOnlyStaticField = 1 - with self.assertRaises(TypeError): - FieldTest().ConstField = 1 + with pytest.raises(TypeError): + del FieldTest.ReadOnlyStaticField - with self.assertRaises(TypeError): - FieldTest.ConstField = 1 + with pytest.raises(TypeError): + del FieldTest().ReadOnlyStaticField - with self.assertRaises(TypeError): - del FieldTest().ConstField - with self.assertRaises(TypeError): - del FieldTest.ConstField +def test_constant_field(): + """Test const fields.""" + ob = FieldTest() - def test_internal_field(self): - """Test internal fields.""" + assert FieldTest.ConstField == 0 + assert ob.ConstField == 0 - with self.assertRaises(AttributeError): - _ = FieldTest().InternalField + with pytest.raises(TypeError): + FieldTest().ConstField = 1 - with self.assertRaises(AttributeError): - _ = FieldTest().InternalStaticField + with pytest.raises(TypeError): + FieldTest.ConstField = 1 - with self.assertRaises(AttributeError): - _ = FieldTest.InternalStaticField + with pytest.raises(TypeError): + del FieldTest().ConstField - def test_private_field(self): - """Test private fields.""" + with pytest.raises(TypeError): + del FieldTest.ConstField - with self.assertRaises(AttributeError): - _ = FieldTest().PrivateField - with self.assertRaises(AttributeError): - _ = FieldTest().PrivateStaticField +def test_internal_field(): + """Test internal fields.""" - with self.assertRaises(AttributeError): - _ = FieldTest.PrivateStaticField + with pytest.raises(AttributeError): + _ = FieldTest().InternalField - def test_field_descriptor_get_set(self): - """Test field descriptor get / set.""" + with pytest.raises(AttributeError): + _ = FieldTest().InternalStaticField - # This test ensures that setting an attribute implemented with - # a descriptor actually goes through the descriptor (rather than - # silently replacing the descriptor in the instance or type dict. + with pytest.raises(AttributeError): + _ = FieldTest.InternalStaticField - ob = FieldTest() - self.assertTrue(FieldTest.PublicStaticField == 0) - self.assertTrue(ob.PublicStaticField == 0) +def test_private_field(): + """Test private fields.""" - descriptor = FieldTest.__dict__['PublicStaticField'] - self.assertTrue(type(descriptor) != int) + with pytest.raises(AttributeError): + _ = FieldTest().PrivateField - ob.PublicStaticField = 0 - descriptor = FieldTest.__dict__['PublicStaticField'] - self.assertTrue(type(descriptor) != int) + with pytest.raises(AttributeError): + _ = FieldTest().PrivateStaticField - FieldTest.PublicStaticField = 0 - descriptor = FieldTest.__dict__['PublicStaticField'] - self.assertTrue(type(descriptor) != int) + with pytest.raises(AttributeError): + _ = FieldTest.PrivateStaticField - def test_field_descriptor_wrong_type(self): - """Test setting a field using a value of the wrong type.""" - with self.assertRaises(TypeError): - FieldTest().PublicField = "spam" +def test_field_descriptor_get_set(): + """Test field descriptor get / set.""" - def test_field_descriptor_abuse(self): - """Test field descriptor abuse.""" - desc = FieldTest.__dict__['PublicField'] + # This test ensures that setting an attribute implemented with + # a descriptor actually goes through the descriptor (rather than + # silently replacing the descriptor in the instance or type dict. - with self.assertRaises(TypeError): - desc.__get__(0, 0) + ob = FieldTest() - with self.assertRaises(TypeError): - desc.__set__(0, 0) + assert FieldTest.PublicStaticField == 0 + assert ob.PublicStaticField == 0 - def test_boolean_field(self): - """Test boolean fields.""" - # change this to true / false later for Python 2.3? - ob = FieldTest() - self.assertTrue(ob.BooleanField is False) + descriptor = FieldTest.__dict__['PublicStaticField'] + assert type(descriptor) != int - ob.BooleanField = True - self.assertTrue(ob.BooleanField is True) + ob.PublicStaticField = 0 + descriptor = FieldTest.__dict__['PublicStaticField'] + assert type(descriptor) != int - ob.BooleanField = False - self.assertTrue(ob.BooleanField is False) + FieldTest.PublicStaticField = 0 + descriptor = FieldTest.__dict__['PublicStaticField'] + assert type(descriptor) != int - ob.BooleanField = 1 - self.assertTrue(ob.BooleanField is True) - ob.BooleanField = 0 - self.assertTrue(ob.BooleanField is False) +def test_field_descriptor_wrong_type(): + """Test setting a field using a value of the wrong type.""" - def test_sbyte_field(self): - """Test sbyte fields.""" - ob = FieldTest() - self.assertTrue(ob.SByteField == 0) + with pytest.raises(TypeError): + FieldTest().PublicField = "spam" - ob.SByteField = 1 - self.assertTrue(ob.SByteField == 1) - def test_byte_field(self): - """Test byte fields.""" - ob = FieldTest() - self.assertTrue(ob.ByteField == 0) +def test_field_descriptor_abuse(): + """Test field descriptor abuse.""" + desc = FieldTest.__dict__['PublicField'] - ob.ByteField = 1 - self.assertTrue(ob.ByteField == 1) + with pytest.raises(TypeError): + desc.__get__(0, 0) - def test_char_field(self): - """Test char fields.""" - ob = FieldTest() - self.assertTrue(ob.CharField == u'A') - self.assertTrue(ob.CharField == 'A') + with pytest.raises(TypeError): + desc.__set__(0, 0) - ob.CharField = 'B' - self.assertTrue(ob.CharField == u'B') - self.assertTrue(ob.CharField == 'B') - ob.CharField = u'C' - self.assertTrue(ob.CharField == u'C') - self.assertTrue(ob.CharField == 'C') +def test_boolean_field(): + """Test boolean fields.""" + # change this to true / false later for Python 2.3? + ob = FieldTest() + assert ob.BooleanField is False - def test_int16_field(self): - """Test int16 fields.""" - ob = FieldTest() - self.assertTrue(ob.Int16Field == 0) + ob.BooleanField = True + assert ob.BooleanField is True - ob.Int16Field = 1 - self.assertTrue(ob.Int16Field == 1) + ob.BooleanField = False + assert ob.BooleanField is False - def test_int32_field(self): - """Test int32 fields.""" - ob = FieldTest() - self.assertTrue(ob.Int32Field == 0) + ob.BooleanField = 1 + assert ob.BooleanField is True - ob.Int32Field = 1 - self.assertTrue(ob.Int32Field == 1) + ob.BooleanField = 0 + assert ob.BooleanField is False - def test_int64_field(self): - """Test int64 fields.""" - ob = FieldTest() - self.assertTrue(ob.Int64Field == 0) - ob.Int64Field = 1 - self.assertTrue(ob.Int64Field == 1) +def test_sbyte_field(): + """Test sbyte fields.""" + ob = FieldTest() + assert ob.SByteField == 0 - def test_uint16_field(self): - """Test uint16 fields.""" - ob = FieldTest() - self.assertTrue(ob.UInt16Field == 0) + ob.SByteField = 1 + assert ob.SByteField == 1 - ob.UInt16Field = 1 - self.assertTrue(ob.UInt16Field == 1) - def test_uint32_field(self): - """Test uint32 fields.""" - ob = FieldTest() - self.assertTrue(ob.UInt32Field == 0) +def test_byte_field(): + """Test byte fields.""" + ob = FieldTest() + assert ob.ByteField == 0 - ob.UInt32Field = 1 - self.assertTrue(ob.UInt32Field == 1) + ob.ByteField = 1 + assert ob.ByteField == 1 - def test_uint64_field(self): - """Test uint64 fields.""" - ob = FieldTest() - self.assertTrue(ob.UInt64Field == 0) - ob.UInt64Field = 1 - self.assertTrue(ob.UInt64Field == 1) +def test_char_field(): + """Test char fields.""" + ob = FieldTest() + assert ob.CharField == u'A' + assert ob.CharField == 'A' - def test_single_field(self): - """Test single fields.""" - ob = FieldTest() - self.assertTrue(ob.SingleField == 0.0) + ob.CharField = 'B' + assert ob.CharField == u'B' + assert ob.CharField == 'B' - ob.SingleField = 1.1 - self.assertTrue(ob.SingleField == 1.1) + ob.CharField = u'C' + assert ob.CharField == u'C' + assert ob.CharField == 'C' - def test_double_field(self): - """Test double fields.""" - ob = FieldTest() - self.assertTrue(ob.DoubleField == 0.0) - ob.DoubleField = 1.1 - self.assertTrue(ob.DoubleField == 1.1) +def test_int16_field(): + """Test int16 fields.""" + ob = FieldTest() + assert ob.Int16Field == 0 - def test_decimal_field(self): - """Test decimal fields.""" - ob = FieldTest() - self.assertTrue(ob.DecimalField == System.Decimal(0)) + ob.Int16Field = 1 + assert ob.Int16Field == 1 - ob.DecimalField = System.Decimal(1) - self.assertTrue(ob.DecimalField == System.Decimal(1)) - def test_string_field(self): - """Test string fields.""" - ob = FieldTest() - self.assertTrue(ob.StringField == "spam") +def test_int32_field(): + """Test int32 fields.""" + ob = FieldTest() + assert ob.Int32Field == 0 - ob.StringField = "eggs" - self.assertTrue(ob.StringField == "eggs") + ob.Int32Field = 1 + assert ob.Int32Field == 1 - def test_interface_field(self): - """Test interface fields.""" - from Python.Test import Spam, ISpam - ob = FieldTest() +def test_int64_field(): + """Test int64 fields.""" + ob = FieldTest() + assert ob.Int64Field == 0 - self.assertTrue(ISpam(ob.SpamField).GetValue() == "spam") - self.assertTrue(ob.SpamField.GetValue() == "spam") + ob.Int64Field = 1 + assert ob.Int64Field == 1 - ob.SpamField = Spam("eggs") - self.assertTrue(ISpam(ob.SpamField).GetValue() == "eggs") - self.assertTrue(ob.SpamField.GetValue() == "eggs") - def test_object_field(self): - """Test ob fields.""" - ob = FieldTest() - self.assertTrue(ob.ObjectField is None) +def test_uint16_field(): + """Test uint16 fields.""" + ob = FieldTest() + assert ob.UInt16Field == 0 - ob.ObjectField = System.String("spam") - self.assertTrue(ob.ObjectField == "spam") + ob.UInt16Field = 1 + assert ob.UInt16Field == 1 - ob.ObjectField = System.Int32(1) - self.assertTrue(ob.ObjectField == 1) - ob.ObjectField = None - self.assertTrue(ob.ObjectField is None) +def test_uint32_field(): + """Test uint32 fields.""" + ob = FieldTest() + assert ob.UInt32Field == 0 - def test_enum_field(self): - """Test enum fields.""" - from Python.Test import ShortEnum + ob.UInt32Field = 1 + assert ob.UInt32Field == 1 - ob = FieldTest() - self.assertTrue(ob.EnumField == ShortEnum.Zero) - ob.EnumField = ShortEnum.One - self.assertTrue(ob.EnumField == ShortEnum.One) +def test_uint64_field(): + """Test uint64 fields.""" + ob = FieldTest() + assert ob.UInt64Field == 0 - def test_nullable_field(self): - """Test nullable fields.""" - ob = FieldTest() + ob.UInt64Field = 1 + assert ob.UInt64Field == 1 - ob.StringField = None - self.assertTrue(ob.StringField is None) - ob.ObjectField = None - self.assertTrue(ob.ObjectField is None) +def test_single_field(): + """Test single fields.""" + ob = FieldTest() + assert ob.SingleField == 0.0 - ob.SpamField = None - self.assertTrue(ob.SpamField is None) + ob.SingleField = 1.1 + assert ob.SingleField == 1.1 - # Primitive types and enums should not be set to null. - with self.assertRaises(TypeError): - FieldTest().Int32Field = None +def test_double_field(): + """Test double fields.""" + ob = FieldTest() + assert ob.DoubleField == 0.0 - with self.assertRaises(TypeError): - FieldTest().EnumField = None + ob.DoubleField = 1.1 + assert ob.DoubleField == 1.1 -def test_suite(): - return unittest.makeSuite(FieldTests) +def test_decimal_field(): + """Test decimal fields.""" + ob = FieldTest() + assert ob.DecimalField == System.Decimal(0) + + ob.DecimalField = System.Decimal(1) + assert ob.DecimalField == System.Decimal(1) + + +def test_string_field(): + """Test string fields.""" + ob = FieldTest() + assert ob.StringField == "spam" + + ob.StringField = "eggs" + assert ob.StringField == "eggs" + + +def test_interface_field(): + """Test interface fields.""" + from Python.Test import Spam, ISpam + + ob = FieldTest() + + assert ISpam(ob.SpamField).GetValue() == "spam" + assert ob.SpamField.GetValue() == "spam" + + ob.SpamField = Spam("eggs") + assert ISpam(ob.SpamField).GetValue() == "eggs" + assert ob.SpamField.GetValue() == "eggs" + + +def test_object_field(): + """Test ob fields.""" + ob = FieldTest() + assert ob.ObjectField is None + + ob.ObjectField = System.String("spam") + assert ob.ObjectField == "spam" + + ob.ObjectField = System.Int32(1) + assert ob.ObjectField == 1 + + ob.ObjectField = None + assert ob.ObjectField is None + + +def test_enum_field(): + """Test enum fields.""" + from Python.Test import ShortEnum + + ob = FieldTest() + assert ob.EnumField == ShortEnum.Zero + + ob.EnumField = ShortEnum.One + assert ob.EnumField == ShortEnum.One + + +def test_nullable_field(): + """Test nullable fields.""" + ob = FieldTest() + + ob.StringField = None + assert ob.StringField is None + + ob.ObjectField = None + assert ob.ObjectField is None + + ob.SpamField = None + assert ob.SpamField is None + + # Primitive types and enums should not be set to null. + + with pytest.raises(TypeError): + FieldTest().Int32Field = None + + with pytest.raises(TypeError): + FieldTest().EnumField = None diff --git a/src/tests/test_generic.py b/src/tests/test_generic.py index 8d5ea4c4c..69cd4ee7f 100644 --- a/src/tests/test_generic.py +++ b/src/tests/test_generic.py @@ -1,767 +1,778 @@ # -*- coding: utf-8 -*- +"""Test CLR generics support.""" + import clr -import unittest import System +import pytest + +from ._compat import PY2, long, unicode, unichr, zip + + +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[long, long]() + assert dict_.Count == 0 + dict_.Add(long(1), long(1)) + assert dict_[long(1)] == long(1) + + dict_ = Dictionary[System.Int64, System.Int64]() + assert dict_.Count == 0 + dict_.Add(long(1), long(1)) + assert dict_[long(1)] == long(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.""" + inst = System.Nullable[System.Int32](10) + assert inst.HasValue + assert inst.Value == 10 + + +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, long(9223372036854775807)) + # Python 3 has no explicit long type, use System.Int64 instead + if PY2: + assert_generic_wrapper_by_type(long, long(9223372036854775807)) + assert_generic_wrapper_by_type(System.UInt16, 65000) + assert_generic_wrapper_by_type(System.UInt32, long(4294967295)) + assert_generic_wrapper_by_type(System.UInt64, long(18446744073709551615)) + assert_generic_wrapper_by_type(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(unicode, "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: The value doesn't fit into Int64 and PythonNet doesn't + # recognize it as UInt64 for unknown reasons. + # assert_generic_method_by_type(System.UInt64, 18446744073709551615L) + 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) + # Python 3 has no explicit long type, use System.Int64 instead + if PY2: + assert_generic_method_by_type(System.Int64, long(9223372036854775807)) + assert_generic_method_by_type(long, long(9223372036854775807)) + assert_generic_method_by_type(System.UInt32, long(4294967295)) + assert_generic_method_by_type(System.Int64, long(1844674407370955161)) + assert_generic_method_by_type(System.UInt16, 65000) + assert_generic_method_by_type(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(unicode, "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) + assert_generic_method_by_type(ISayHello1, 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)) + if PY2 and atype is Int64: + value2 = long(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 -from _compat import PY2, long, unicode, unichr, zip - - -class GenericTests(unittest.TestCase): - """Test CLR generics support.""" - - def _assert_generic_wrapper_by_type(self, ptype, value): - """Test Helper""" - from Python.Test import GenericWrapper - import System - - inst = GenericWrapper[ptype](value) - self.assertTrue(inst.value == value) - - atype = System.Array[ptype] - items = atype([value, value, value]) - inst = GenericWrapper[atype](items) - self.assertTrue(len(inst.value) == 3) - self.assertTrue(inst.value[0] == value) - self.assertTrue(inst.value[1] == value) - - def _assert_generic_method_by_type(self, 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: - self.assertTrue(result.__class__ == value.__class__) - else: - self.assertTrue(result == value) - - # Type inference (static method) - result = stype.Overloaded(value) - self.assertTrue(result == value) - if test_type: - self.assertTrue(result.__class__ == value.__class__) - else: - self.assertTrue(result == value) - - # Explicit selection (instance method) - result = itype().Overloaded[ptype](value) - self.assertTrue(result == value) - if test_type: - self.assertTrue(result.__class__ == value.__class__) - else: - self.assertTrue(result == value) - - # Type inference (instance method) - result = itype().Overloaded(value) - self.assertTrue(result == value) - if test_type: - self.assertTrue(result.__class__ == value.__class__) - else: - self.assertTrue(result == value) - - atype = System.Array[ptype] - items = atype([value, value, value]) - - # Explicit selection (static method) - result = stype.Overloaded[atype](items) - if test_type: - self.assertTrue(len(result) == 3) - self.assertTrue(result[0].__class__ == value.__class__) - self.assertTrue(result[1].__class__ == value.__class__) - else: - self.assertTrue(len(result) == 3) - self.assertTrue(result[0] == value) - self.assertTrue(result[1] == value) - - # Type inference (static method) - result = stype.Overloaded(items) - if test_type: - self.assertTrue(len(result) == 3) - self.assertTrue(result[0].__class__ == value.__class__) - self.assertTrue(result[1].__class__ == value.__class__) - else: - self.assertTrue(len(result) == 3) - self.assertTrue(result[0] == value) - self.assertTrue(result[1] == value) - - # Explicit selection (instance method) - result = itype().Overloaded[atype](items) - if test_type: - self.assertTrue(len(result) == 3) - self.assertTrue(result[0].__class__ == value.__class__) - self.assertTrue(result[1].__class__ == value.__class__) - else: - self.assertTrue(len(result) == 3) - self.assertTrue(result[0] == value) - self.assertTrue(result[1] == value) - - # Type inference (instance method) - result = itype().Overloaded(items) - if test_type: - self.assertTrue(len(result) == 3) - self.assertTrue(result[0].__class__ == value.__class__) - self.assertTrue(result[1].__class__ == value.__class__) - else: - self.assertTrue(len(result) == 3) - self.assertTrue(result[0] == value) - self.assertTrue(result[1] == value) - - def test_python_type_aliasing(self): - """Test python type alias support with generics.""" - from System.Collections.Generic import Dictionary - - dict_ = Dictionary[str, str]() - self.assertEquals(dict_.Count, 0) - dict_.Add("one", "one") - self.assertTrue(dict_["one"] == "one") - - dict_ = Dictionary[System.String, System.String]() - self.assertEquals(dict_.Count, 0) - dict_.Add("one", "one") - self.assertTrue(dict_["one"] == "one") - - dict_ = Dictionary[int, int]() - self.assertEquals(dict_.Count, 0) - dict_.Add(1, 1) - self.assertTrue(dict_[1] == 1) - - dict_ = Dictionary[System.Int32, System.Int32]() - self.assertEquals(dict_.Count, 0) - dict_.Add(1, 1) - self.assertTrue(dict_[1] == 1) - - dict_ = Dictionary[long, long]() - self.assertEquals(dict_.Count, 0) - dict_.Add(long(1), long(1)) - self.assertTrue(dict_[long(1)] == long(1)) - - dict_ = Dictionary[System.Int64, System.Int64]() - self.assertEquals(dict_.Count, 0) - dict_.Add(long(1), long(1)) - self.assertTrue(dict_[long(1)] == long(1)) - - dict_ = Dictionary[float, float]() - self.assertEquals(dict_.Count, 0) - dict_.Add(1.5, 1.5) - self.assertTrue(dict_[1.5] == 1.5) - - dict_ = Dictionary[System.Double, System.Double]() - self.assertEquals(dict_.Count, 0) - dict_.Add(1.5, 1.5) - self.assertTrue(dict_[1.5] == 1.5) - - dict_ = Dictionary[bool, bool]() - self.assertEquals(dict_.Count, 0) - dict_.Add(True, False) - self.assertTrue(dict_[True] is False) - - dict_ = Dictionary[System.Boolean, System.Boolean]() - self.assertEquals(dict_.Count, 0) - dict_.Add(True, False) - self.assertTrue(dict_[True] is False) - - def test_generic_reference_type(self): - """Test usage of generic reference type definitions.""" - from Python.Test import GenericTypeDefinition - - inst = GenericTypeDefinition[System.String, System.Int32]("one", 2) - self.assertTrue(inst.value1 == "one") - self.assertTrue(inst.value2 == 2) - - def test_generic_value_type(self): - """Test usage of generic value type definitions.""" - inst = System.Nullable[System.Int32](10) - self.assertTrue(inst.HasValue) - self.assertTrue(inst.Value == 10) - - def test_generic_interface(self): - # TODO NotImplemented - pass - - def test_generic_delegate(self): - # TODO NotImplemented - pass - - def test_open_generic_type(self): - """Test behavior of reflected open constructed generic types.""" - from Python.Test import DerivedFromOpenGeneric - - open_generic_type = DerivedFromOpenGeneric.__bases__[0] - - with self.assertRaises(TypeError): - _ = open_generic_type() - - with self.assertRaises(TypeError): - _ = open_generic_type[System.String] - - def test_derived_from_open_generic_type(self): - """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') - - self.assertTrue(inst.value1 == 1) - self.assertTrue(inst.value2 == 'two') - self.assertTrue(inst.value3 == 'three') - - def test_generic_type_name_resolution(self): - """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 - self.assertTrue(_class().value == 0) - self.assertTrue(_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 self.assertRaises(TypeError): - _ = GenericNameTest2() - - _class = GenericNameTest2[int] - self.assertTrue(_class().value == 1) - self.assertTrue(_class.value == 1) - - _class = GenericNameTest2[int, int] - self.assertTrue(_class().value == 2) - self.assertTrue(_class.value == 2) - - def test_generic_type_binding(self): - """Test argument conversion / binding for generic methods.""" - from Python.Test import InterfaceTest, ISayHello1, ShortEnum - import System - - self._assert_generic_wrapper_by_type(System.Boolean, True) - self._assert_generic_wrapper_by_type(bool, True) - self._assert_generic_wrapper_by_type(System.Byte, 255) - self._assert_generic_wrapper_by_type(System.SByte, 127) - self._assert_generic_wrapper_by_type(System.Char, u'A') - self._assert_generic_wrapper_by_type(System.Int16, 32767) - self._assert_generic_wrapper_by_type(System.Int32, 2147483647) - self._assert_generic_wrapper_by_type(int, 2147483647) - self._assert_generic_wrapper_by_type(System.Int64, long(9223372036854775807)) - # Python 3 has no explicit long type, use System.Int64 instead - if PY2: - self._assert_generic_wrapper_by_type(long, long(9223372036854775807)) - self._assert_generic_wrapper_by_type(System.UInt16, 65000) - self._assert_generic_wrapper_by_type(System.UInt32, long(4294967295)) - self._assert_generic_wrapper_by_type(System.UInt64, long(18446744073709551615)) - self._assert_generic_wrapper_by_type(System.Single, 3.402823e38) - self._assert_generic_wrapper_by_type(System.Double, 1.7976931348623157e308) - self._assert_generic_wrapper_by_type(float, 1.7976931348623157e308) - self._assert_generic_wrapper_by_type(System.Decimal, System.Decimal.One) - self._assert_generic_wrapper_by_type(System.String, "test") - self._assert_generic_wrapper_by_type(unicode, "test") - self._assert_generic_wrapper_by_type(str, "test") - self._assert_generic_wrapper_by_type(ShortEnum, ShortEnum.Zero) - self._assert_generic_wrapper_by_type(System.Object, InterfaceTest()) - self._assert_generic_wrapper_by_type(InterfaceTest, InterfaceTest()) - self._assert_generic_wrapper_by_type(ISayHello1, InterfaceTest()) - - def test_generic_method_binding(self): - from Python.Test import GenericMethodTest, GenericStaticMethodTest - from System import InvalidOperationException - - # Can invoke a static member on a closed generic type. - value = GenericStaticMethodTest[str].Overloaded() - self.assertTrue(value == 1) - - with self.assertRaises(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() - self.assertTrue(value == 1) - - with self.assertRaises(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(self): - """Test argument conversion / binding for generic methods.""" - from Python.Test import InterfaceTest, ISayHello1, ShortEnum - import System - - # FIXME: The value doesn't fit into Int64 and PythonNet doesn't - # recognize it as UInt64 for unknown reasons. - # self._assert_generic_method_by_type(System.UInt64, 18446744073709551615L) - self._assert_generic_method_by_type(System.Boolean, True) - self._assert_generic_method_by_type(bool, True) - self._assert_generic_method_by_type(System.Byte, 255) - self._assert_generic_method_by_type(System.SByte, 127) - self._assert_generic_method_by_type(System.Char, u'A') - self._assert_generic_method_by_type(System.Int16, 32767) - self._assert_generic_method_by_type(System.Int32, 2147483647) - self._assert_generic_method_by_type(int, 2147483647) - # Python 3 has no explicit long type, use System.Int64 instead - if PY2: - self._assert_generic_method_by_type(System.Int64, long(9223372036854775807)) - self._assert_generic_method_by_type(long, long(9223372036854775807)) - self._assert_generic_method_by_type(System.UInt32, long(4294967295)) - self._assert_generic_method_by_type(System.Int64, long(1844674407370955161)) - self._assert_generic_method_by_type(System.UInt16, 65000) - self._assert_generic_method_by_type(System.Single, 3.402823e38) - self._assert_generic_method_by_type(System.Double, 1.7976931348623157e308) - self._assert_generic_method_by_type(float, 1.7976931348623157e308) - self._assert_generic_method_by_type(System.Decimal, System.Decimal.One) - self._assert_generic_method_by_type(System.String, "test") - self._assert_generic_method_by_type(unicode, "test") - self._assert_generic_method_by_type(str, "test") - self._assert_generic_method_by_type(ShortEnum, ShortEnum.Zero) - self._assert_generic_method_by_type(System.Object, InterfaceTest()) - self._assert_generic_method_by_type(InterfaceTest, InterfaceTest(), 1) - self._assert_generic_method_by_type(ISayHello1, InterfaceTest(), 1) - - def test_correct_overload_selection(self): - """Test correct overloading selection for common types.""" - from System import (String, Double, Single, - Int16, Int32, Int64) - from System import Math - - substr = String("substring") - self.assertTrue(substr.Substring(2) == substr.Substring.__overloads__[Int32]( - Int32(2))) - self.assertTrue(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]): - self.assertTrue(Math.Abs(atype(value1)) == Math.Abs.__overloads__[atype](atype(value1))) - self.assertTrue(Math.Abs(value1) == Math.Abs.__overloads__[atype](atype(value1))) - self.assertTrue( - Math.Max(atype(value1), - atype(value2)) == Math.Max.__overloads__[atype, atype]( - atype(value1), atype(value2))) - if PY2 and atype is Int64: - value2 = long(value2) - self.assertTrue( - 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(self): - """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() - self.assertTrue(value == 1) - - # public int Overloaded() - value = inst.Overloaded() - self.assertTrue(value == 1) - - # public static T Overloaded(T arg) (inferred) - value = type.Overloaded("test") - self.assertTrue(value == "test") - - # public T Overloaded(T arg) (inferred) - value = inst.Overloaded("test") - self.assertTrue(value == "test") - - # public static T Overloaded(T arg) (explicit) - value = type.Overloaded[str]("test") - self.assertTrue(value == "test") - - # public T Overloaded(T arg) (explicit) - value = inst.Overloaded[str]("test") - self.assertTrue(value == "test") - - # public static Q Overloaded(Q arg) - value = type.Overloaded[float](2.2) - self.assertTrue(value == 2.2) - - # public Q Overloaded(Q arg) - value = inst.Overloaded[float](2.2) - self.assertTrue(value == 2.2) - - # public static Q Overloaded(Q arg) - value = type.Overloaded[bool](True) - self.assertTrue(value is True) - - # public Q Overloaded(Q arg) - value = inst.Overloaded[bool](True) - self.assertTrue(value is True) - - # public static U Overloaded(Q arg1, U arg2) - value = type.Overloaded[bool, str](True, "true") - self.assertTrue(value == "true") - - # public U Overloaded(Q arg1, U arg2) - value = inst.Overloaded[bool, str](True, "true") - self.assertTrue(value == "true") - - # public static U Overloaded(Q arg1, U arg2) - value = type.Overloaded[str, bool]("true", True) - self.assertTrue(value is True) - - # public U Overloaded(Q arg1, U arg2) - value = inst.Overloaded[str, bool]("true", True) - self.assertTrue(value is True) - - # public static string Overloaded(int arg1, int arg2, string arg3) - value = type.Overloaded[str](123, 456, "success") - self.assertTrue(value == "success") - - # public string Overloaded(int arg1, int arg2, string arg3) - value = inst.Overloaded[str](123, 456, "success") - self.assertTrue(value == "success") - - with self.assertRaises(TypeError): - _ = type.Overloaded[str, bool, int]("true", True, 1) - - with self.assertRaises(TypeError): - _ = inst.Overloaded[str, bool, int]("true", True, 1) - - def test_method_overload_selection_with_generic_types(self): - """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_) - self.assertTrue(value.value is True) - - vtype = GenericWrapper[bool] - input_ = vtype(True) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value is True) - - vtype = GenericWrapper[System.Byte] - input_ = vtype(255) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == 255) - - vtype = GenericWrapper[System.SByte] - input_ = vtype(127) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == 127) - - vtype = GenericWrapper[System.Char] - input_ = vtype(u'A') - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == u'A') - - vtype = GenericWrapper[System.Char] - input_ = vtype(65535) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == unichr(65535)) - - vtype = GenericWrapper[System.Int16] - input_ = vtype(32767) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == 32767) - - vtype = GenericWrapper[System.Int32] - input_ = vtype(2147483647) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == 2147483647) - - vtype = GenericWrapper[int] - input_ = vtype(2147483647) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == 2147483647) - - vtype = GenericWrapper[System.Int64] + 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 == unichr(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(long(9223372036854775807)) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value.value == long(9223372036854775807) + + # Python 3 has no explicit long type, use System.Int64 instead + if PY2: + vtype = GenericWrapper[long] input_ = vtype(long(9223372036854775807)) value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == long(9223372036854775807)) - - # Python 3 has no explicit long type, use System.Int64 instead - if PY2: - vtype = GenericWrapper[long] - input_ = vtype(long(9223372036854775807)) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == long(9223372036854775807)) - - vtype = GenericWrapper[System.UInt16] - input_ = vtype(65000) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == 65000) - - vtype = GenericWrapper[System.UInt32] - input_ = vtype(long(4294967295)) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == long(4294967295)) - - vtype = GenericWrapper[System.UInt64] - input_ = vtype(long(18446744073709551615)) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == long(18446744073709551615)) - - vtype = GenericWrapper[System.Single] - input_ = vtype(3.402823e38) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == 3.402823e38) - - vtype = GenericWrapper[System.Double] - input_ = vtype(1.7976931348623157e308) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == 1.7976931348623157e308) - - vtype = GenericWrapper[float] - input_ = vtype(1.7976931348623157e308) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == 1.7976931348623157e308) - - vtype = GenericWrapper[System.Decimal] - input_ = vtype(System.Decimal.One) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == System.Decimal.One) - - vtype = GenericWrapper[System.String] - input_ = vtype("spam") - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == "spam") - - vtype = GenericWrapper[str] - input_ = vtype("spam") - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == "spam") - - vtype = GenericWrapper[ShortEnum] - input_ = vtype(ShortEnum.Zero) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value == ShortEnum.Zero) - - vtype = GenericWrapper[System.Object] - input_ = vtype(inst) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value.__class__ == inst.__class__) - - vtype = GenericWrapper[InterfaceTest] - input_ = vtype(inst) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value.__class__ == inst.__class__) - - vtype = GenericWrapper[ISayHello1] - input_ = vtype(inst) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value.value.__class__ == inst.__class__) - - vtype = System.Array[GenericWrapper[int]] - input_ = vtype([GenericWrapper[int](0), GenericWrapper[int](1)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == 0) - self.assertTrue(value[1].value == 1) - - def test_overload_selection_with_arrays_of_generic_types(self): - """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_) - self.assertTrue(value[0].value is True) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[bool] - vtype = System.Array[gtype] - input_ = vtype([gtype(True), gtype(True)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value is True) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.Byte] - vtype = System.Array[gtype] - input_ = vtype([gtype(255), gtype(255)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == 255) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.SByte] - vtype = System.Array[gtype] - input_ = vtype([gtype(127), gtype(127)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == 127) - self.assertTrue(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_) - self.assertTrue(value[0].value == u'A') - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.Char] - vtype = System.Array[gtype] - input_ = vtype([gtype(65535), gtype(65535)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == unichr(65535)) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.Int16] - vtype = System.Array[gtype] - input_ = vtype([gtype(32767), gtype(32767)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == 32767) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.Int32] - vtype = System.Array[gtype] - input_ = vtype([gtype(2147483647), gtype(2147483647)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == 2147483647) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[int] - vtype = System.Array[gtype] - input_ = vtype([gtype(2147483647), gtype(2147483647)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == 2147483647) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.Int64] + assert value.value == long(9223372036854775807) + + vtype = GenericWrapper[System.UInt16] + input_ = vtype(65000) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value.value == 65000 + + vtype = GenericWrapper[System.UInt32] + input_ = vtype(long(4294967295)) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value.value == long(4294967295) + + vtype = GenericWrapper[System.UInt64] + input_ = vtype(long(18446744073709551615)) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value.value == long(18446744073709551615) + + vtype = GenericWrapper[System.Single] + input_ = vtype(3.402823e38) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value.value == 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__ + + vtype = GenericWrapper[ISayHello1] + input_ = vtype(inst) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value.value.__class__ == inst.__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 == unichr(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(long(9223372036854775807)), + gtype(long(9223372036854775807))]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0].value == long(9223372036854775807) + assert value.Length == 2 + + # Python 3 has no explicit long type, use System.Int64 instead + if PY2: + gtype = GenericWrapper[long] vtype = System.Array[gtype] input_ = vtype([gtype(long(9223372036854775807)), - gtype(long(9223372036854775807))]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == long(9223372036854775807)) - self.assertTrue(value.Length == 2) - - # Python 3 has no explicit long type, use System.Int64 instead - if PY2: - gtype = GenericWrapper[long] - vtype = System.Array[gtype] - input_ = vtype([gtype(long(9223372036854775807)), - gtype(long(9223372036854775807))]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == long(9223372036854775807)) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.UInt16] - vtype = System.Array[gtype] - input_ = vtype([gtype(65000), gtype(65000)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == 65000) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.UInt32] - vtype = System.Array[gtype] - input_ = vtype([gtype(long(4294967295)), gtype(long(4294967295))]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == long(4294967295)) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.UInt64] - vtype = System.Array[gtype] - input_ = vtype([gtype(long(18446744073709551615)), - gtype(long(18446744073709551615))]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == long(18446744073709551615)) - self.assertTrue(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_) - self.assertTrue(value[0].value == 3.402823e38) - self.assertTrue(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_) - self.assertTrue(value[0].value == 1.7976931348623157e308) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[float] - vtype = System.Array[gtype] - input_ = vtype([gtype(1.7976931348623157e308), - gtype(1.7976931348623157e308)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == 1.7976931348623157e308) - self.assertTrue(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_) - self.assertTrue(value[0].value == System.Decimal.One) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.String] - vtype = System.Array[gtype] - input_ = vtype([gtype("spam"), gtype("spam")]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == "spam") - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[str] - vtype = System.Array[gtype] - input_ = vtype([gtype("spam"), gtype("spam")]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == "spam") - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[ShortEnum] - vtype = System.Array[gtype] - input_ = vtype([gtype(ShortEnum.Zero), gtype(ShortEnum.Zero)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value == ShortEnum.Zero) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[System.Object] - vtype = System.Array[gtype] - input_ = vtype([gtype(inst), gtype(inst)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value.__class__ == inst.__class__) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[InterfaceTest] - vtype = System.Array[gtype] - input_ = vtype([gtype(inst), gtype(inst)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value.__class__ == inst.__class__) - self.assertTrue(value.Length == 2) - - gtype = GenericWrapper[ISayHello1] - vtype = System.Array[gtype] - input_ = vtype([gtype(inst), gtype(inst)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].value.__class__ == inst.__class__) - self.assertTrue(value.Length == 2) - - def test_generic_overload_selection_magic_name_only(self): - """Test using only __overloads__ to select on type & sig""" - # TODO NotImplemented - pass - - def test_nested_generic_class(self): - """Check nested generic classes.""" - # TODO NotImplemented - pass - - -def test_suite(): - return unittest.makeSuite(GenericTests) + gtype(long(9223372036854775807))]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0].value == long(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(long(4294967295)), gtype(long(4294967295))]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0].value == long(4294967295) + assert value.Length == 2 + + gtype = GenericWrapper[System.UInt64] + vtype = System.Array[gtype] + input_ = vtype([gtype(long(18446744073709551615)), + gtype(long(18446744073709551615))]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0].value == long(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 == 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 + + gtype = GenericWrapper[ISayHello1] + 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 + + +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 diff --git a/src/tests/test_import.py b/src/tests/test_import.py new file mode 100644 index 000000000..42cafc4df --- /dev/null +++ b/src/tests/test_import.py @@ -0,0 +1,13 @@ +# -*- coding: utf-8 -*- + +"""Test the import statement.""" + +import pytest + + +def test_relative_missing_import(): + """Test that a relative missing import doesn't crash. + Some modules use this to check if a package is installed. + Relative import in the site-packages folder""" + with pytest.raises(ImportError): + from . import _missing_import diff --git a/src/tests/test_indexer.py b/src/tests/test_indexer.py index 422f7282e..6f18550d9 100644 --- a/src/tests/test_indexer.py +++ b/src/tests/test_indexer.py @@ -1,577 +1,599 @@ # -*- coding: utf-8 -*- -import unittest +"""Test support for indexer properties.""" import Python.Test as Test +import pytest -from _compat import long, unichr +from ._compat import long, unichr -class IndexerTests(unittest.TestCase): - """Test support for indexer properties.""" +def test_public_indexer(): + """Test public indexers.""" + ob = Test.PublicIndexerTest() - def test_public_indexer(self): - """Test public indexers.""" - ob = Test.PublicIndexerTest() + ob[0] = "zero" + assert ob[0] == "zero" - ob[0] = "zero" - self.assertTrue(ob[0] == "zero") + ob[1] = "one" + assert ob[1] == "one" + + assert ob[10] is None + + +def test_protected_indexer(): + """Test protected indexers.""" + ob = Test.ProtectedIndexerTest() + + ob[0] = "zero" + assert ob[0] == "zero" + + ob[1] = "one" + assert ob[1] == "one" - ob[1] = "one" - self.assertTrue(ob[1] == "one") + assert ob[10] is None - self.assertTrue(ob[10] is None) - def test_protected_indexer(self): - """Test protected indexers.""" - ob = Test.ProtectedIndexerTest() +def test_internal_indexer(): + """Test internal indexers.""" + ob = Test.InternalIndexerTest() + with pytest.raises(TypeError): ob[0] = "zero" - self.assertTrue(ob[0] == "zero") - ob[1] = "one" - self.assertTrue(ob[1] == "one") + with pytest.raises(TypeError): + Test.InternalIndexerTest.__getitem__(ob, 0) - self.assertTrue(ob[10] is None) + with pytest.raises(TypeError): + ob.__getitem__(0) - def test_internal_indexer(self): - """Test internal indexers.""" - ob = Test.InternalIndexerTest() - with self.assertRaises(TypeError): - ob[0] = "zero" +def test_private_indexer(): + """Test private indexers.""" + ob = Test.PrivateIndexerTest() + + with pytest.raises(TypeError): + ob[0] = "zero" + + with pytest.raises(TypeError): + Test.PrivateIndexerTest.__getitem__(ob, 0) + + with pytest.raises(TypeError): + ob.__getitem__(0) - with self.assertRaises(TypeError): - Test.InternalIndexerTest.__getitem__(ob, 0) - with self.assertRaises(TypeError): - ob.__getitem__(0) +def test_boolean_indexer(): + """Test boolean indexers.""" + ob = Test.BooleanIndexerTest() - def test_private_indexer(self): - """Test private indexers.""" - ob = Test.PrivateIndexerTest() + assert ob[True] is None + assert ob[1] is None - with self.assertRaises(TypeError): - ob[0] = "zero" + ob[0] = "false" + assert ob[0] == "false" - with self.assertRaises(TypeError): - Test.PrivateIndexerTest.__getitem__(ob, 0) + ob[1] = "true" + assert ob[1] == "true" - with self.assertRaises(TypeError): - ob.__getitem__(0) + ob[False] = "false" + assert ob[False] == "false" - def test_boolean_indexer(self): - """Test boolean indexers.""" - ob = Test.BooleanIndexerTest() + ob[True] = "true" + assert ob[True] == "true" - self.assertTrue(ob[True] is None) - self.assertTrue(ob[1] is None) - ob[0] = "false" - self.assertTrue(ob[0] == "false") +def test_byte_indexer(): + """Test byte indexers.""" + ob = Test.ByteIndexerTest() + max_ = 255 + min_ = 0 - ob[1] = "true" - self.assertTrue(ob[1] == "true") + assert ob[max_] is None - ob[False] = "false" - self.assertTrue(ob[False] == "false") + ob[max_] = str(max_) + assert ob[max_] == str(max_) - ob[True] = "true" - self.assertTrue(ob[True] == "true") + ob[min_] = str(min_) + assert ob[min_] == str(min_) - def test_byte_indexer(self): - """Test byte indexers.""" + with pytest.raises(TypeError): ob = Test.ByteIndexerTest() - max_ = 255 - min_ = 0 + ob["wrong"] + + with pytest.raises(TypeError): + ob = Test.ByteIndexerTest() + ob["wrong"] = "wrong" - self.assertTrue(ob[max_] is None) - ob[max_] = str(max_) - self.assertTrue(ob[max_] == str(max_)) +def test_sbyte_indexer(): + """Test sbyte indexers.""" + ob = Test.SByteIndexerTest() + max_ = 127 + min_ = -128 - ob[min_] = str(min_) - self.assertTrue(ob[min_] == str(min_)) + assert ob[max_] is None - with self.assertRaises(TypeError): - ob = Test.ByteIndexerTest() - ob["wrong"] + ob[max_] = str(max_) + assert ob[max_] == str(max_) - with self.assertRaises(TypeError): - ob = Test.ByteIndexerTest() - ob["wrong"] = "wrong" + ob[min_] = str(min_) + assert ob[min_] == str(min_) - def test_sbyte_indexer(self): - """Test sbyte indexers.""" + with pytest.raises(TypeError): ob = Test.SByteIndexerTest() - max_ = 127 - min_ = -128 + ob["wrong"] - self.assertTrue(ob[max_] is None) + with pytest.raises(TypeError): + ob = Test.SByteIndexerTest() + ob["wrong"] = "wrong" - ob[max_] = str(max_) - self.assertTrue(ob[max_] == str(max_)) - ob[min_] = str(min_) - self.assertTrue(ob[min_] == str(min_)) +def test_char_indexer(): + """Test char indexers.""" + ob = Test.CharIndexerTest() + max_ = unichr(65535) + min_ = unichr(0) - with self.assertRaises(TypeError): - ob = Test.SByteIndexerTest() - ob["wrong"] + assert ob[max_] is None - with self.assertRaises(TypeError): - ob = Test.SByteIndexerTest() - ob["wrong"] = "wrong" + ob[max_] = "max_" + assert ob[max_] == "max_" - def test_char_indexer(self): - """Test char indexers.""" + ob[min_] = "min_" + assert ob[min_] == "min_" + + with pytest.raises(TypeError): + ob = Test.CharIndexerTest() + ob["wrong"] + + with pytest.raises(TypeError): ob = Test.CharIndexerTest() - max_ = unichr(65535) - min_ = unichr(0) + ob["wrong"] = "wrong" - self.assertTrue(ob[max_] is None) - ob[max_] = "max_" - self.assertTrue(ob[max_] == "max_") +def test_int16_indexer(): + """Test Int16 indexers.""" + ob = Test.Int16IndexerTest() + max_ = 32767 + min_ = -32768 - ob[min_] = "min_" - self.assertTrue(ob[min_] == "min_") + assert ob[max_] is None - with self.assertRaises(TypeError): - ob = Test.CharIndexerTest() - ob["wrong"] + ob[max_] = str(max_) + assert ob[max_] == str(max_) - with self.assertRaises(TypeError): - ob = Test.CharIndexerTest() - ob["wrong"] = "wrong" + ob[min_] = str(min_) + assert ob[min_] == str(min_) - def test_int16_indexer(self): - """Test Int16 indexers.""" + with pytest.raises(TypeError): ob = Test.Int16IndexerTest() - max_ = 32767 - min_ = -32768 + ob["wrong"] - self.assertTrue(ob[max_] is None) + with pytest.raises(TypeError): + ob = Test.Int16IndexerTest() + ob["wrong"] = "wrong" - ob[max_] = str(max_) - self.assertTrue(ob[max_] == str(max_)) - ob[min_] = str(min_) - self.assertTrue(ob[min_] == str(min_)) +def test_int32_indexer(): + """Test Int32 indexers.""" + ob = Test.Int32IndexerTest() + max_ = 2147483647 + min_ = -2147483648 - with self.assertRaises(TypeError): - ob = Test.Int16IndexerTest() - ob["wrong"] + assert ob[max_] is None - with self.assertRaises(TypeError): - ob = Test.Int16IndexerTest() - ob["wrong"] = "wrong" + ob[max_] = str(max_) + assert ob[max_] == str(max_) + + ob[min_] = str(min_) + assert ob[min_] == str(min_) + + with pytest.raises(TypeError): + ob = Test.Int32IndexerTest() + ob["wrong"] - def test_int32_indexer(self): - """Test Int32 indexers.""" + with pytest.raises(TypeError): ob = Test.Int32IndexerTest() - max_ = 2147483647 - min_ = -2147483648 + ob["wrong"] = "wrong" - self.assertTrue(ob[max_] is None) - ob[max_] = str(max_) - self.assertTrue(ob[max_] == str(max_)) +def test_int64_indexer(): + """Test Int64 indexers.""" + ob = Test.Int64IndexerTest() + max_ = long(9223372036854775807) + min_ = long(-9223372036854775808) - ob[min_] = str(min_) - self.assertTrue(ob[min_] == str(min_)) + assert ob[max_] is None - with self.assertRaises(TypeError): - ob = Test.Int32IndexerTest() - ob["wrong"] + ob[max_] = str(max_) + assert ob[max_] == str(max_) - with self.assertRaises(TypeError): - ob = Test.Int32IndexerTest() - ob["wrong"] = "wrong" + ob[min_] = str(min_) + assert ob[min_] == str(min_) - def test_int64_indexer(self): - """Test Int64 indexers.""" + with pytest.raises(TypeError): ob = Test.Int64IndexerTest() - max_ = long(9223372036854775807) - min_ = long(-9223372036854775808) + ob["wrong"] - self.assertTrue(ob[max_] is None) + with pytest.raises(TypeError): + ob = Test.Int64IndexerTest() + ob["wrong"] = "wrong" + + +def test_uint16_indexer(): + """Test UInt16 indexers.""" + ob = Test.UInt16IndexerTest() + max_ = 65535 + min_ = 0 - ob[max_] = str(max_) - self.assertTrue(ob[max_] == str(max_)) + assert ob[max_] is None - ob[min_] = str(min_) - self.assertTrue(ob[min_] == str(min_)) + ob[max_] = str(max_) + assert ob[max_] == str(max_) - with self.assertRaises(TypeError): - ob = Test.Int64IndexerTest() - ob["wrong"] + ob[min_] = str(min_) + assert ob[min_] == str(min_) - with self.assertRaises(TypeError): - ob = Test.Int64IndexerTest() - ob["wrong"] = "wrong" + with pytest.raises(TypeError): + ob = Test.UInt16IndexerTest() + ob["wrong"] - def test_uint16_indexer(self): - """Test UInt16 indexers.""" + with pytest.raises(TypeError): ob = Test.UInt16IndexerTest() - max_ = 65535 - min_ = 0 + ob["wrong"] = "wrong" + - self.assertTrue(ob[max_] is None) +def test_uint32_indexer(): + """Test UInt32 indexers.""" + ob = Test.UInt32IndexerTest() + max_ = long(4294967295) + min_ = 0 - ob[max_] = str(max_) - self.assertTrue(ob[max_] == str(max_)) + assert ob[max_] is None - ob[min_] = str(min_) - self.assertTrue(ob[min_] == str(min_)) + ob[max_] = str(max_) + assert ob[max_] == str(max_) - with self.assertRaises(TypeError): - ob = Test.UInt16IndexerTest() - ob["wrong"] + ob[min_] = str(min_) + assert ob[min_] == str(min_) - with self.assertRaises(TypeError): - ob = Test.UInt16IndexerTest() - ob["wrong"] = "wrong" + with pytest.raises(TypeError): + ob = Test.UInt32IndexerTest() + ob["wrong"] - def test_uint32_indexer(self): - """Test UInt32 indexers.""" + with pytest.raises(TypeError): ob = Test.UInt32IndexerTest() - max_ = long(4294967295) - min_ = 0 + ob["wrong"] = "wrong" - self.assertTrue(ob[max_] is None) - ob[max_] = str(max_) - self.assertTrue(ob[max_] == str(max_)) +def test_uint64_indexer(): + """Test UInt64 indexers.""" + ob = Test.UInt64IndexerTest() + max_ = long(18446744073709551615) + min_ = 0 - ob[min_] = str(min_) - self.assertTrue(ob[min_] == str(min_)) + assert ob[max_] is None - with self.assertRaises(TypeError): - ob = Test.UInt32IndexerTest() - ob["wrong"] + ob[max_] = str(max_) + assert ob[max_] == str(max_) - with self.assertRaises(TypeError): - ob = Test.UInt32IndexerTest() - ob["wrong"] = "wrong" + ob[min_] = str(min_) + assert ob[min_] == str(min_) - def test_uint64_indexer(self): - """Test UInt64 indexers.""" + with pytest.raises(TypeError): ob = Test.UInt64IndexerTest() - max_ = long(18446744073709551615) - min_ = 0 + ob["wrong"] + + with pytest.raises(TypeError): + ob = Test.UInt64IndexerTest() + ob["wrong"] = "wrong" - self.assertTrue(ob[max_] is None) - ob[max_] = str(max_) - self.assertTrue(ob[max_] == str(max_)) +def test_single_indexer(): + """Test Single indexers.""" + ob = Test.SingleIndexerTest() + max_ = 3.402823e38 + min_ = -3.402823e38 - ob[min_] = str(min_) - self.assertTrue(ob[min_] == str(min_)) + assert ob[max_] is None - with self.assertRaises(TypeError): - ob = Test.UInt64IndexerTest() - ob["wrong"] + ob[max_] = "max_" + assert ob[max_] == "max_" - with self.assertRaises(TypeError): - ob = Test.UInt64IndexerTest() - ob["wrong"] = "wrong" + ob[min_] = "min_" + assert ob[min_] == "min_" + + with pytest.raises(TypeError): + ob = Test.SingleIndexerTest() + ob["wrong"] - def test_single_indexer(self): - """Test Single indexers.""" + with pytest.raises(TypeError): ob = Test.SingleIndexerTest() - max_ = 3.402823e38 - min_ = -3.402823e38 + ob["wrong"] = "wrong" - self.assertTrue(ob[max_] is None) - ob[max_] = "max_" - self.assertTrue(ob[max_] == "max_") +def test_double_indexer(): + """Test Double indexers.""" + ob = Test.DoubleIndexerTest() + max_ = 1.7976931348623157e308 + min_ = -1.7976931348623157e308 - ob[min_] = "min_" - self.assertTrue(ob[min_] == "min_") + assert ob[max_] is None - with self.assertRaises(TypeError): - ob = Test.SingleIndexerTest() - ob["wrong"] + ob[max_] = "max_" + assert ob[max_] == "max_" - with self.assertRaises(TypeError): - ob = Test.SingleIndexerTest() - ob["wrong"] = "wrong" + ob[min_] = "min_" + assert ob[min_] == "min_" - def test_double_indexer(self): - """Test Double indexers.""" + with pytest.raises(TypeError): ob = Test.DoubleIndexerTest() - max_ = 1.7976931348623157e308 - min_ = -1.7976931348623157e308 + ob["wrong"] + + with pytest.raises(TypeError): + ob = Test.DoubleIndexerTest() + ob["wrong"] = "wrong" + - self.assertTrue(ob[max_] is None) +def test_decimal_indexer(): + """Test Decimal indexers.""" + ob = Test.DecimalIndexerTest() - ob[max_] = "max_" - self.assertTrue(ob[max_] == "max_") + from System import Decimal + max_d = Decimal.Parse("79228162514264337593543950335") + min_d = Decimal.Parse("-79228162514264337593543950335") - ob[min_] = "min_" - self.assertTrue(ob[min_] == "min_") + assert ob[max_d] is None - with self.assertRaises(TypeError): - ob = Test.DoubleIndexerTest() - ob["wrong"] + ob[max_d] = "max_" + assert ob[max_d] == "max_" - with self.assertRaises(TypeError): - ob = Test.DoubleIndexerTest() - ob["wrong"] = "wrong" + ob[min_d] = "min_" + assert ob[min_d] == "min_" - def test_decimal_indexer(self): - """Test Decimal indexers.""" + with pytest.raises(TypeError): ob = Test.DecimalIndexerTest() + ob["wrong"] + + with pytest.raises(TypeError): + ob = Test.DecimalIndexerTest() + ob["wrong"] = "wrong" - from System import Decimal - max_d = Decimal.Parse("79228162514264337593543950335") - min_d = Decimal.Parse("-79228162514264337593543950335") - self.assertTrue(ob[max_d] is None) +def test_string_indexer(): + """Test String indexers.""" + ob = Test.StringIndexerTest() - ob[max_d] = "max_" - self.assertTrue(ob[max_d] == "max_") + assert ob["spam"] is None + assert ob[u"spam"] is None - ob[min_d] = "min_" - self.assertTrue(ob[min_d] == "min_") + ob["spam"] = "spam" + assert ob["spam"] == "spam" + assert ob["spam"] == u"spam" + assert ob[u"spam"] == "spam" + assert ob[u"spam"] == u"spam" - with self.assertRaises(TypeError): - ob = Test.DecimalIndexerTest() - ob["wrong"] + ob[u"eggs"] = u"eggs" + assert ob["eggs"] == "eggs" + assert ob["eggs"] == u"eggs" + assert ob[u"eggs"] == "eggs" + assert ob[u"eggs"] == u"eggs" - with self.assertRaises(TypeError): - ob = Test.DecimalIndexerTest() - ob["wrong"] = "wrong" + with pytest.raises(TypeError): + ob = Test.StringIndexerTest() + ob[1] - def test_string_indexer(self): - """Test String indexers.""" + with pytest.raises(TypeError): ob = Test.StringIndexerTest() + ob[1] = "wrong" + + +def test_enum_indexer(): + """Test enum indexers.""" + ob = Test.EnumIndexerTest() + + key = Test.ShortEnum.One - self.assertTrue(ob["spam"] is None) - self.assertTrue(ob[u"spam"] is None) + assert ob[key] is None - ob["spam"] = "spam" - self.assertTrue(ob["spam"] == "spam") - self.assertTrue(ob["spam"] == u"spam") - self.assertTrue(ob[u"spam"] == "spam") - self.assertTrue(ob[u"spam"] == u"spam") + ob[key] = "spam" + assert ob[key] == "spam" - ob[u"eggs"] = u"eggs" - self.assertTrue(ob["eggs"] == "eggs") - self.assertTrue(ob["eggs"] == u"eggs") - self.assertTrue(ob[u"eggs"] == "eggs") - self.assertTrue(ob[u"eggs"] == u"eggs") + ob[key] = "eggs" + assert ob[key] == "eggs" - with self.assertRaises(TypeError): - ob = Test.StringIndexerTest() - ob[1] + ob[1] = "spam" + assert ob[1] == "spam" - with self.assertRaises(TypeError): - ob = Test.StringIndexerTest() - ob[1] = "wrong" + with pytest.raises(TypeError): + ob = Test.EnumIndexerTest() + ob["wrong"] - def test_enum_indexer(self): - """Test enum indexers.""" + with pytest.raises(TypeError): ob = Test.EnumIndexerTest() + ob["wrong"] = "wrong" - key = Test.ShortEnum.One - self.assertTrue(ob[key] is None) +def test_object_indexer(): + """Test ob indexers.""" + ob = Test.ObjectIndexerTest() - ob[key] = "spam" - self.assertTrue(ob[key] == "spam") + from Python.Test import Spam + spam = Spam("spam") - ob[key] = "eggs" - self.assertTrue(ob[key] == "eggs") + assert ob[spam] is None + assert ob["spam"] is None + assert ob[1] is None + assert ob[None] is None - ob[1] = "spam" - self.assertTrue(ob[1] == "spam") + ob[spam] = "spam" + assert ob[spam] == "spam" - with self.assertRaises(TypeError): - ob = Test.EnumIndexerTest() - ob["wrong"] + ob["spam"] = "eggs" + assert ob["spam"] == "eggs" - with self.assertRaises(TypeError): - ob = Test.EnumIndexerTest() - ob["wrong"] = "wrong" + ob[1] = "one" + assert ob[1] == "one" - def test_object_indexer(self): - """Test ob indexers.""" - ob = Test.ObjectIndexerTest() + ob[long(1)] = "long" + assert ob[long(1)] == "long" - from Python.Test import Spam - spam = Spam("spam") + with pytest.raises(TypeError): + class Eggs(object): + pass - self.assertTrue(ob[spam] is None) - self.assertTrue(ob["spam"] is None) - self.assertTrue(ob[1] is None) - self.assertTrue(ob[None] is None) + key = Eggs() + ob = Test.ObjectIndexerTest() + ob[key] = "wrong" - ob[spam] = "spam" - self.assertTrue(ob[spam] == "spam") - ob["spam"] = "eggs" - self.assertTrue(ob["spam"] == "eggs") +def test_interface_indexer(): + """Test interface indexers.""" + ob = Test.InterfaceIndexerTest() - ob[1] = "one" - self.assertTrue(ob[1] == "one") + from Python.Test import Spam + spam = Spam("spam") - ob[long(1)] = "long" - self.assertTrue(ob[long(1)] == "long") + assert ob[spam] is None - with self.assertRaises(TypeError): - class Eggs(object): - pass + ob[spam] = "spam" + assert ob[spam] == "spam" - key = Eggs() - ob = Test.ObjectIndexerTest() - ob[key] = "wrong" + ob[spam] = "eggs" + assert ob[spam] == "eggs" - def test_interface_indexer(self): - """Test interface indexers.""" + with pytest.raises(TypeError): ob = Test.InterfaceIndexerTest() + ob["wrong"] - from Python.Test import Spam - spam = Spam("spam") + with pytest.raises(TypeError): + ob = Test.InterfaceIndexerTest() + ob["wrong"] = "wrong" - self.assertTrue(ob[spam] is None) - ob[spam] = "spam" - self.assertTrue(ob[spam] == "spam") +def test_typed_indexer(): + """Test typed indexers.""" + ob = Test.TypedIndexerTest() - ob[spam] = "eggs" - self.assertTrue(ob[spam] == "eggs") + from Python.Test import Spam + spam = Spam("spam") - with self.assertRaises(TypeError): - ob = Test.InterfaceIndexerTest() - ob["wrong"] + assert ob[spam] is None - with self.assertRaises(TypeError): - ob = Test.InterfaceIndexerTest() - ob["wrong"] = "wrong" + ob[spam] = "spam" + assert ob[spam] == "spam" - def test_typed_indexer(self): - """Test typed indexers.""" + ob[spam] = "eggs" + assert ob[spam] == "eggs" + + with pytest.raises(TypeError): ob = Test.TypedIndexerTest() + ob["wrong"] - from Python.Test import Spam - spam = Spam("spam") + with pytest.raises(TypeError): + ob = Test.TypedIndexerTest() + ob["wrong"] = "wrong" - self.assertTrue(ob[spam] is None) - ob[spam] = "spam" - self.assertTrue(ob[spam] == "spam") +def test_multi_arg_indexer(): + """Test indexers that take multiple index arguments.""" + ob = Test.MultiArgIndexerTest() - ob[spam] = "eggs" - self.assertTrue(ob[spam] == "eggs") + ob[0, 1] = "zero one" + assert ob[0, 1] == "zero one" - with self.assertRaises(TypeError): - ob = Test.TypedIndexerTest() - ob["wrong"] + ob[1, 9] = "one nine" + assert ob[1, 9] == "one nine" - with self.assertRaises(TypeError): - ob = Test.TypedIndexerTest() - ob["wrong"] = "wrong" + assert ob[10, 50] is None - def test_multi_arg_indexer(self): - """Test indexers that take multiple index arguments.""" + with pytest.raises(TypeError): ob = Test.MultiArgIndexerTest() + _ = ob[0, "one"] - ob[0, 1] = "zero one" - self.assertTrue(ob[0, 1] == "zero one") + with pytest.raises(TypeError): + ob = Test.MultiArgIndexerTest() + ob[0, "one"] = "wrong" - ob[1, 9] = "one nine" - self.assertTrue(ob[1, 9] == "one nine") - self.assertTrue(ob[10, 50] is None) +def test_multi_type_indexer(): + """Test indexers that take multiple indices of different types.""" + ob = Test.MultiTypeIndexerTest() + spam = Test.Spam("spam") - with self.assertRaises(TypeError): - ob = Test.MultiArgIndexerTest() - _ = ob[0, "one"] + ob[0, "one", spam] = "zero one spam" + assert ob[0, "one", spam] == "zero one spam" - with self.assertRaises(TypeError): - ob = Test.MultiArgIndexerTest() - ob[0, "one"] = "wrong" + ob[1, "nine", spam] = "one nine spam" + assert ob[1, "nine", spam] == "one nine spam" - def test_multi_type_indexer(self): - """Test indexers that take multiple indices of different types.""" + with pytest.raises(TypeError): ob = Test.MultiTypeIndexerTest() - spam = Test.Spam("spam") + _ = ob[0, 1, spam] - ob[0, "one", spam] = "zero one spam" - self.assertTrue(ob[0, "one", spam] == "zero one spam") - - ob[1, "nine", spam] = "one nine spam" - self.assertTrue(ob[1, "nine", spam] == "one nine spam") + with pytest.raises(TypeError): + ob = Test.MultiTypeIndexerTest() + ob[0, 1, spam] = "wrong" - with self.assertRaises(TypeError): - ob = Test.MultiTypeIndexerTest() - _ = ob[0, 1, spam] - with self.assertRaises(TypeError): - ob = Test.MultiTypeIndexerTest() - ob[0, 1, spam] = "wrong" +def test_multi_default_key_indexer(): + """Test indexers that take multiple indices with a default + key arguments.""" + # default argument is 2 in the MultiDefaultKeyIndexerTest object + ob = Test.MultiDefaultKeyIndexerTest() + ob[0, 2] = "zero one spam" + assert ob[0] == "zero one spam" - def test_multi_default_key_indexer(self): - """Test indexers that take multiple indices with a default - key arguments.""" - # default argument is 2 in the MultiDefaultKeyIndexerTest object - ob = Test.MultiDefaultKeyIndexerTest() - ob[0, 2] = "zero one spam" - self.assertTrue(ob[0] == "zero one spam") + ob[1] = "one nine spam" + assert ob[1, 2] == "one nine spam" - ob[1] = "one nine spam" - self.assertTrue(ob[1, 2] == "one nine spam") - def test_indexer_wrong_key_type(self): - """Test calling an indexer using a key of the wrong type.""" +def test_indexer_wrong_key_type(): + """Test calling an indexer using a key of the wrong type.""" - with self.assertRaises(TypeError): - ob = Test.PublicIndexerTest() - _ = ob["wrong"] + with pytest.raises(TypeError): + ob = Test.PublicIndexerTest() + _ = ob["wrong"] - with self.assertRaises(TypeError): - ob = Test.PublicIndexerTest() - ob["wrong"] = "spam" + with pytest.raises(TypeError): + ob = Test.PublicIndexerTest() + ob["wrong"] = "spam" - def test_indexer_wrong_value_type(self): - """Test calling an indexer using a value of the wrong type.""" - with self.assertRaises(TypeError): - ob = Test.PublicIndexerTest() - ob[1] = 9993.9 +def test_indexer_wrong_value_type(): + """Test calling an indexer using a value of the wrong type.""" - def test_unbound_indexer(self): - """Test calling an unbound indexer.""" + with pytest.raises(TypeError): ob = Test.PublicIndexerTest() + ob[1] = 9993.9 - Test.PublicIndexerTest.__setitem__(ob, 0, "zero") - self.assertTrue(ob[0] == "zero") - Test.PublicIndexerTest.__setitem__(ob, 1, "one") - self.assertTrue(ob[1] == "one") +def test_unbound_indexer(): + """Test calling an unbound indexer.""" + ob = Test.PublicIndexerTest() - self.assertTrue(ob[10] is None) + Test.PublicIndexerTest.__setitem__(ob, 0, "zero") + assert ob[0] == "zero" - def test_indexer_abuse(self): - """Test indexer abuse.""" - _class = Test.PublicIndexerTest - ob = Test.PublicIndexerTest() + Test.PublicIndexerTest.__setitem__(ob, 1, "one") + assert ob[1] == "one" + + assert ob[10] is None - with self.assertRaises(AttributeError): - del _class.__getitem__ - with self.assertRaises(AttributeError): - del ob.__getitem__ +def test_indexer_abuse(): + """Test indexer abuse.""" + _class = Test.PublicIndexerTest + ob = Test.PublicIndexerTest() - with self.assertRaises(AttributeError): - del _class.__setitem__ + with pytest.raises(AttributeError): + del _class.__getitem__ - with self.assertRaises(AttributeError): - del ob.__setitem__ + with pytest.raises(AttributeError): + del ob.__getitem__ + with pytest.raises(AttributeError): + del _class.__setitem__ -def test_suite(): - return unittest.makeSuite(IndexerTests) + with pytest.raises(AttributeError): + del ob.__setitem__ diff --git a/src/tests/test_interface.py b/src/tests/test_interface.py index 1fac36eb8..997f17264 100644 --- a/src/tests/test_interface.py +++ b/src/tests/test_interface.py @@ -1,72 +1,69 @@ # -*- coding: utf-8 -*- -import unittest +"""Test CLR interface support.""" import Python.Test as Test +import pytest -from _compat import DictProxyType +from ._compat import DictProxyType -class InterfaceTests(unittest.TestCase): - """Test CLR interface support.""" +def test_interface_standard_attrs(): + """Test standard class attributes.""" + from Python.Test import IPublicInterface - def test_interface_standard_attrs(self): - """Test standard class attributes.""" - from Python.Test import IPublicInterface + assert IPublicInterface.__name__ == 'IPublicInterface' + assert IPublicInterface.__module__ == 'Python.Test' + assert isinstance(IPublicInterface.__dict__, DictProxyType) - self.assertTrue(IPublicInterface.__name__ == 'IPublicInterface') - self.assertTrue(IPublicInterface.__module__ == 'Python.Test') - self.assertTrue(isinstance(IPublicInterface.__dict__, DictProxyType)) - def test_global_interface_visibility(self): - """Test visibility of module-level interfaces.""" - from Python.Test import IPublicInterface +def test_global_interface_visibility(): + """Test visibility of module-level interfaces.""" + from Python.Test import IPublicInterface - self.assertTrue(IPublicInterface.__name__ == 'IPublicInterface') + assert IPublicInterface.__name__ == 'IPublicInterface' - with self.assertRaises(ImportError): - from Python.Test import IInternalInterface - _ = IInternalInterface + with pytest.raises(ImportError): + from Python.Test import IInternalInterface + _ = IInternalInterface - with self.assertRaises(AttributeError): - _ = Test.IInternalInterface + with pytest.raises(AttributeError): + _ = Test.IInternalInterface - def test_nested_interface_visibility(self): - """Test visibility of nested interfaces.""" - from Python.Test import InterfaceTest - ob = InterfaceTest.IPublic - self.assertTrue(ob.__name__ == 'IPublic') +def test_nested_interface_visibility(): + """Test visibility of nested interfaces.""" + from Python.Test import InterfaceTest - ob = InterfaceTest.IProtected - self.assertTrue(ob.__name__ == 'IProtected') + ob = InterfaceTest.IPublic + assert ob.__name__ == 'IPublic' - with self.assertRaises(AttributeError): - _ = InterfaceTest.IInternal + ob = InterfaceTest.IProtected + assert ob.__name__ == 'IProtected' - with self.assertRaises(AttributeError): - _ = InterfaceTest.IPrivate + with pytest.raises(AttributeError): + _ = InterfaceTest.IInternal - def test_explicit_cast_to_interface(self): - """Test explicit cast to an interface.""" - from Python.Test import InterfaceTest + with pytest.raises(AttributeError): + _ = InterfaceTest.IPrivate - ob = InterfaceTest() - self.assertTrue(type(ob).__name__ == 'InterfaceTest') - self.assertTrue(hasattr(ob, 'HelloProperty')) - i1 = Test.ISayHello1(ob) - self.assertTrue(type(i1).__name__ == 'ISayHello1') - self.assertTrue(hasattr(i1, 'SayHello')) - self.assertTrue(i1.SayHello() == 'hello 1') - self.assertFalse(hasattr(i1, 'HelloProperty')) +def test_explicit_cast_to_interface(): + """Test explicit cast to an interface.""" + from Python.Test import InterfaceTest - i2 = Test.ISayHello2(ob) - self.assertTrue(type(i2).__name__ == 'ISayHello2') - self.assertTrue(i2.SayHello() == 'hello 2') - self.assertTrue(hasattr(i2, 'SayHello')) - self.assertFalse(hasattr(i2, 'HelloProperty')) + ob = InterfaceTest() + assert type(ob).__name__ == 'InterfaceTest' + assert hasattr(ob, 'HelloProperty') + i1 = Test.ISayHello1(ob) + assert type(i1).__name__ == 'ISayHello1' + assert hasattr(i1, 'SayHello') + assert i1.SayHello() == 'hello 1' + assert not hasattr(i1, 'HelloProperty') -def test_suite(): - return unittest.makeSuite(InterfaceTests) + i2 = Test.ISayHello2(ob) + assert type(i2).__name__ == 'ISayHello2' + assert i2.SayHello() == 'hello 2' + assert hasattr(i2, 'SayHello') + assert not hasattr(i2, 'HelloProperty') diff --git a/src/tests/test_method.py b/src/tests/test_method.py index 6c4454004..f8b2acf09 100644 --- a/src/tests/test_method.py +++ b/src/tests/test_method.py @@ -1,713 +1,745 @@ # -*- coding: utf-8 -*- -import unittest +"""Test CLR method support.""" import System +import pytest from Python.Test import MethodTest -from _compat import PY2, long, unichr +from ._compat import PY2, long, unichr -class MethodTests(unittest.TestCase): - """Test CLR method support.""" +def test_instance_method_descriptor(): + """Test instance method descriptor behavior.""" - def test_instance_method_descriptor(self): - """Test instance method descriptor behavior.""" + with pytest.raises(AttributeError): + MethodTest().PublicMethod = 0 - with self.assertRaises(AttributeError): - MethodTest().PublicMethod = 0 + with pytest.raises(AttributeError): + MethodTest.PublicMethod = 0 - with self.assertRaises(AttributeError): - MethodTest.PublicMethod = 0 + with pytest.raises(AttributeError): + del MethodTest().PublicMethod - with self.assertRaises(AttributeError): - del MethodTest().PublicMethod + with pytest.raises(AttributeError): + del MethodTest.PublicMethod - with self.assertRaises(AttributeError): - del MethodTest.PublicMethod - def test_static_method_descriptor(self): - """Test static method descriptor behavior.""" +def test_static_method_descriptor(): + """Test static method descriptor behavior.""" - with self.assertRaises(AttributeError): - MethodTest().PublicStaticMethod = 0 + with pytest.raises(AttributeError): + MethodTest().PublicStaticMethod = 0 - with self.assertRaises(AttributeError): - MethodTest.PublicStaticMethod = 0 + with pytest.raises(AttributeError): + MethodTest.PublicStaticMethod = 0 - with self.assertRaises(AttributeError): - del MethodTest().PublicStaticMethod + with pytest.raises(AttributeError): + del MethodTest().PublicStaticMethod - with self.assertRaises(AttributeError): - del MethodTest.PublicStaticMethod + with pytest.raises(AttributeError): + del MethodTest.PublicStaticMethod - def test_public_instance_method(self): - """Test public instance method visibility.""" - ob = MethodTest() - self.assertTrue(ob.PublicMethod() == "public") - def test_public_static_method(self): - """Test public static method visibility.""" - ob = MethodTest() - self.assertTrue(MethodTest.PublicStaticMethod() == "public static") - self.assertTrue(ob.PublicStaticMethod() == "public static") +def test_public_instance_method(): + """Test public instance method visibility.""" + ob = MethodTest() + assert ob.PublicMethod() == "public" - def test_protected_instance_method(self): - """Test protected instance method visibility.""" - ob = MethodTest() - self.assertTrue(ob.ProtectedMethod() == "protected") - def test_protected_static_method(self): - """Test protected static method visibility.""" - ob = MethodTest() - result = "protected static" - self.assertTrue(MethodTest.ProtectedStaticMethod() == result) - self.assertTrue(ob.ProtectedStaticMethod() == result) +def test_public_static_method(): + """Test public static method visibility.""" + ob = MethodTest() + assert MethodTest.PublicStaticMethod() == "public static" + assert ob.PublicStaticMethod() == "public static" - def test_internal_method(self): - """Test internal method visibility.""" - with self.assertRaises(AttributeError): - _ = MethodTest().InternalMethod +def test_protected_instance_method(): + """Test protected instance method visibility.""" + ob = MethodTest() + assert ob.ProtectedMethod() == "protected" - with self.assertRaises(AttributeError): - _ = MethodTest.InternalMethod - with self.assertRaises(AttributeError): - _ = MethodTest().InternalStaticMethod +def test_protected_static_method(): + """Test protected static method visibility.""" + ob = MethodTest() + result = "protected static" + assert MethodTest.ProtectedStaticMethod() == result + assert ob.ProtectedStaticMethod() == result - with self.assertRaises(AttributeError): - _ = MethodTest.InternalStaticMethod - def test_private_method(self): - """Test private method visibility.""" +def test_internal_method(): + """Test internal method visibility.""" - with self.assertRaises(AttributeError): - _ = MethodTest().PrivateMethod + with pytest.raises(AttributeError): + _ = MethodTest().InternalMethod - with self.assertRaises(AttributeError): - _ = MethodTest.PrivateMethod + with pytest.raises(AttributeError): + _ = MethodTest.InternalMethod - with self.assertRaises(AttributeError): - _ = MethodTest().PrivateStaticMethod + with pytest.raises(AttributeError): + _ = MethodTest().InternalStaticMethod - with self.assertRaises(AttributeError): - _ = MethodTest.PrivateStaticMethod + with pytest.raises(AttributeError): + _ = MethodTest.InternalStaticMethod - def test_unbound_managed_method_call(self): - """Test calling unbound managed methods.""" - from Python.Test import MethodTestSub - ob = MethodTest() - self.assertTrue(MethodTest.PublicMethod(ob) == "public") +def test_private_method(): + """Test private method visibility.""" - with self.assertRaises(TypeError): - MethodTest.PublicMethod() + with pytest.raises(AttributeError): + _ = MethodTest().PrivateMethod - ob = MethodTestSub() - self.assertTrue(MethodTestSub.PublicMethod(ob) == "public") - self.assertTrue(MethodTestSub.PublicMethod(ob, "echo") == "echo") + with pytest.raises(AttributeError): + _ = MethodTest.PrivateMethod - with self.assertRaises(TypeError): - MethodTestSub.PublicMethod("echo") + with pytest.raises(AttributeError): + _ = MethodTest().PrivateStaticMethod - def test_overloaded_method_inheritance(self): - """Test that overloads are inherited properly.""" - from Python.Test import MethodTestSub + with pytest.raises(AttributeError): + _ = MethodTest.PrivateStaticMethod - ob = MethodTest() - self.assertTrue(ob.PublicMethod() == "public") - with self.assertRaises(TypeError): - ob = MethodTest() - ob.PublicMethod("echo") +def test_unbound_managed_method_call(): + """Test calling unbound managed methods.""" + from Python.Test import MethodTestSub - ob = MethodTestSub() - self.assertTrue(ob.PublicMethod() == "public") + ob = MethodTest() + assert MethodTest.PublicMethod(ob) == "public" - self.assertTrue(ob.PublicMethod("echo") == "echo") + with pytest.raises(TypeError): + MethodTest.PublicMethod() - def test_method_descriptor_abuse(self): - """Test method descriptor abuse.""" - desc = MethodTest.__dict__['PublicMethod'] + ob = MethodTestSub() + assert MethodTestSub.PublicMethod(ob) == "public" + assert MethodTestSub.PublicMethod(ob, "echo") == "echo" - with self.assertRaises(TypeError): - desc.__get__(0, 0) + with pytest.raises(TypeError): + MethodTestSub.PublicMethod("echo") - with self.assertRaises(AttributeError): - desc.__set__(0, 0) - def test_method_docstrings(self): - """Test standard method docstring generation""" - method = MethodTest.GetType - value = 'System.Type GetType()' - self.assertTrue(method.__doc__ == value) +def test_overloaded_method_inheritance(): + """Test that overloads are inherited properly.""" + from Python.Test import MethodTestSub - # ====================================================================== - # Tests of specific argument and result conversion scenarios - # ====================================================================== - - def test_method_call_enum_conversion(self): - """Test enum conversion in method call.""" - from System import TypeCode + ob = MethodTest() + assert ob.PublicMethod() == "public" + with pytest.raises(TypeError): ob = MethodTest() - r = ob.TestEnumConversion(TypeCode.Int32) - self.assertTrue(r == TypeCode.Int32) + ob.PublicMethod("echo") - def test_method_call_flags_conversion(self): - """Test flags conversion in method call.""" - from System.IO import FileAccess + ob = MethodTestSub() + assert ob.PublicMethod() == "public" - ob = MethodTest() - flags = FileAccess.Read | FileAccess.Write - r = ob.TestFlagsConversion(flags) - self.assertTrue(r == flags) + assert ob.PublicMethod("echo") == "echo" - def test_method_call_struct_conversion(self): - """Test struct conversion in method call.""" - from System import Guid - ob = MethodTest() - guid = Guid.NewGuid() - temp = guid.ToString() - r = ob.TestStructConversion(guid) - self.assertTrue(r.ToString() == temp) +def test_method_descriptor_abuse(): + """Test method descriptor abuse.""" + desc = MethodTest.__dict__['PublicMethod'] - def test_subclass_instance_conversion(self): - """Test subclass instance conversion in method call.""" + with pytest.raises(TypeError): + desc.__get__(0, 0) - class TestSubException(System.Exception): - pass + with pytest.raises(AttributeError): + desc.__set__(0, 0) - ob = MethodTest() - instance = TestSubException() - result = ob.TestSubclassConversion(instance) - self.assertTrue(isinstance(result, System.Exception)) - def test_null_array_conversion(self): - """Test null array conversion in method call.""" - ob = MethodTest() - r = ob.TestNullArrayConversion(None) - self.assertTrue(r is None) - - def test_string_params_args(self): - """Test use of string params.""" - result = MethodTest.TestStringParamsArg('one', 'two', 'three') - self.assertEqual(result.Length, 3) - self.assertEqual(len(result), 3, result) - self.assertTrue(result[0] == 'one') - self.assertTrue(result[1] == 'two') - self.assertTrue(result[2] == 'three') - - result = MethodTest.TestStringParamsArg(['one', 'two', 'three']) - self.assertTrue(len(result) == 3) - self.assertTrue(result[0] == 'one') - self.assertTrue(result[1] == 'two') - self.assertTrue(result[2] == 'three') - - def test_object_params_args(self): - """Test use of object params.""" - result = MethodTest.TestObjectParamsArg('one', 'two', 'three') - self.assertEqual(len(result), 3, result) - self.assertTrue(result[0] == 'one') - self.assertTrue(result[1] == 'two') - self.assertTrue(result[2] == 'three') - - result = MethodTest.TestObjectParamsArg(['one', 'two', 'three']) - self.assertEqual(len(result), 3, result) - self.assertTrue(result[0] == 'one') - self.assertTrue(result[1] == 'two') - self.assertTrue(result[2] == 'three') - - def test_value_params_args(self): - """Test use of value type params.""" - result = MethodTest.TestValueParamsArg(1, 2, 3) - self.assertEqual(len(result), 3) - self.assertTrue(result[0] == 1) - self.assertTrue(result[1] == 2) - self.assertTrue(result[2] == 3) - - result = MethodTest.TestValueParamsArg([1, 2, 3]) - self.assertEqual(len(result), 3) - self.assertTrue(result[0] == 1) - self.assertTrue(result[1] == 2) - self.assertTrue(result[2] == 3) - - def test_non_params_array_in_last_place(self): - """Test overload resolution with of non-"params" array as - last parameter.""" - result = MethodTest.TestNonParamsArrayInLastPlace(1, 2, 3) - self.assertTrue(result) - - def test_string_out_params(self): - """Test use of string out-parameters.""" - result = MethodTest.TestStringOutParams("hi", "there") - self.assertTrue(isinstance(result, tuple)) - self.assertEqual(len(result), 2) - self.assertTrue(result[0] is True) - self.assertTrue(result[1] == "output string") - - result = MethodTest.TestStringOutParams("hi", None) - self.assertTrue(isinstance(result, tuple)) - self.assertEqual(len(result), 2) - self.assertTrue(result[0] is True) - self.assertTrue(result[1] == "output string") - - def test_string_ref_params(self): - """Test use of string byref parameters.""" - result = MethodTest.TestStringRefParams("hi", "there") - self.assertTrue(isinstance(result, tuple)) - self.assertEqual(len(result), 2) - self.assertTrue(result[0] is True) - self.assertTrue(result[1] == "output string") - - result = MethodTest.TestStringRefParams("hi", None) - self.assertTrue(isinstance(result, tuple)) - self.assertEqual(len(result), 2) - self.assertTrue(result[0] is True) - self.assertTrue(result[1] == "output string") - - def test_value_out_params(self): - """Test use of value type out-parameters.""" - result = MethodTest.TestValueOutParams("hi", 1) - self.assertTrue(isinstance(result, tuple)) - self.assertEqual(len(result), 2) - self.assertTrue(result[0] is True) - self.assertTrue(result[1] == 42) - - # None cannot be converted to a value type like int, long, etc. - with self.assertRaises(TypeError): - MethodTest.TestValueOutParams("hi", None) - - def test_value_ref_params(self): - """Test use of value type byref parameters.""" - result = MethodTest.TestValueRefParams("hi", 1) - self.assertTrue(isinstance(result, tuple)) - self.assertEqual(len(result), 2) - self.assertTrue(result[0] is True) - self.assertTrue(result[1] == 42) - - # None cannot be converted to a value type like int, long, etc. - with self.assertRaises(TypeError): - MethodTest.TestValueRefParams("hi", None) - - def test_object_out_params(self): - """Test use of object out-parameters.""" - result = MethodTest.TestObjectOutParams("hi", MethodTest()) - self.assertTrue(isinstance(result, tuple)) - self.assertTrue(len(result) == 2) - self.assertTrue(result[0] is True) - self.assertTrue(isinstance(result[1], System.Exception)) - - result = MethodTest.TestObjectOutParams("hi", None) - self.assertTrue(isinstance(result, tuple)) - self.assertEqual(len(result), 2) - self.assertTrue(result[0] is True) - self.assertTrue(isinstance(result[1], System.Exception)) - - def test_object_ref_params(self): - """Test use of object byref parameters.""" - result = MethodTest.TestObjectRefParams("hi", MethodTest()) - self.assertTrue(isinstance(result, tuple)) - self.assertEqual(len(result), 2) - self.assertTrue(result[0] is True) - self.assertTrue(isinstance(result[1], System.Exception)) - - result = MethodTest.TestObjectRefParams("hi", None) - self.assertTrue(isinstance(result, tuple)) - self.assertEqual(len(result), 2) - self.assertTrue(result[0] is True) - self.assertTrue(isinstance(result[1], System.Exception)) - - def test_struct_out_params(self): - """Test use of struct out-parameters.""" - result = MethodTest.TestStructOutParams("hi", System.Guid.NewGuid()) - self.assertTrue(isinstance(result, tuple)) - self.assertEqual(len(result), 2) - self.assertTrue(result[0] is True) - self.assertTrue(isinstance(result[1], System.Guid)) - - # None cannot be converted to a value type like a struct - with self.assertRaises(TypeError): - MethodTest.TestValueRefParams("hi", None) - - def test_struct_ref_params(self): - """Test use of struct byref parameters.""" - result = MethodTest.TestStructRefParams("hi", System.Guid.NewGuid()) - self.assertTrue(isinstance(result, tuple)) - self.assertTrue(len(result) == 2) - self.assertTrue(result[0] is True) - self.assertTrue(isinstance(result[1], System.Guid)) - - # None cannot be converted to a value type like a struct - with self.assertRaises(TypeError): - MethodTest.TestValueRefParams("hi", None) - - def test_void_single_out_param(self): - """Test void method with single out-parameter.""" - result = MethodTest.TestVoidSingleOutParam(9) - self.assertTrue(result == 42) - - # None cannot be converted to a value type - with self.assertRaises(TypeError): - MethodTest.TestVoidSingleOutParam(None) - - def test_void_single_ref_param(self): - """Test void method with single ref-parameter.""" - result = MethodTest.TestVoidSingleRefParam(9) - self.assertTrue(result == 42) - - # None cannot be converted to a value type - with self.assertRaises(TypeError): - MethodTest.TestVoidSingleRefParam(None) - - def test_single_default_param(self): - """Test void method with single ref-parameter.""" - result = MethodTest.TestSingleDefaultParam() - self.assertTrue(result == 5) - - def test_one_arg_and_two_default_param(self): - """Test void method with single ref-parameter.""" - result = MethodTest.TestOneArgAndTwoDefaultParam(11) - self.assertTrue(result == 22) - - result = MethodTest.TestOneArgAndTwoDefaultParam(15) - self.assertTrue(result == 26) - - result = MethodTest.TestOneArgAndTwoDefaultParam(20) - self.assertTrue(result == 31) - - def test_two_default_param(self): - """Test void method with single ref-parameter.""" - result = MethodTest.TestTwoDefaultParam() - self.assertTrue(result == 11) - - def test_explicit_selection_with_out_modifier(self): - """Check explicit overload selection with out modifiers.""" - refstr = System.String("").GetType().MakeByRefType() - result = MethodTest.TestStringOutParams.__overloads__[str, refstr]( - "hi", "there") - self.assertTrue(isinstance(result, tuple)) - self.assertTrue(len(result) == 2) - self.assertTrue(result[0] is True) - self.assertTrue(result[1] == "output string") - - result = MethodTest.TestStringOutParams.__overloads__[str, refstr]( - "hi", None) - self.assertTrue(isinstance(result, tuple)) - self.assertTrue(len(result) == 2) - self.assertTrue(result[0] is True) - self.assertTrue(result[1] == "output string") - - def test_explicit_selection_with_ref_modifier(self): - """Check explicit overload selection with ref modifiers.""" - refstr = System.String("").GetType().MakeByRefType() - result = MethodTest.TestStringRefParams.__overloads__[str, refstr]( - "hi", "there") - self.assertTrue(isinstance(result, tuple)) - self.assertTrue(len(result) == 2) - self.assertTrue(result[0] is True) - self.assertTrue(result[1] == "output string") - - result = MethodTest.TestStringRefParams.__overloads__[str, refstr]( - "hi", None) - self.assertTrue(isinstance(result, tuple)) - self.assertTrue(len(result) == 2) - self.assertTrue(result[0] is True) - self.assertTrue(result[1] == "output string") - - def test_explicit_overload_selection(self): - """Check explicit overload selection using [] syntax.""" - from Python.Test import ISayHello1, InterfaceTest, ShortEnum - from System import Array - - inst = InterfaceTest() - - value = MethodTest.Overloaded.__overloads__[System.Boolean](True) - self.assertTrue(value is True) - - value = MethodTest.Overloaded.__overloads__[bool](True) - self.assertTrue(value is True) - - value = MethodTest.Overloaded.__overloads__[System.Byte](255) - self.assertTrue(value == 255) - - value = MethodTest.Overloaded.__overloads__[System.SByte](127) - self.assertTrue(value == 127) - - value = MethodTest.Overloaded.__overloads__[System.Char](u'A') - self.assertTrue(value == u'A') - - value = MethodTest.Overloaded.__overloads__[System.Char](65535) - self.assertTrue(value == unichr(65535)) - - value = MethodTest.Overloaded.__overloads__[System.Int16](32767) - self.assertTrue(value == 32767) - - value = MethodTest.Overloaded.__overloads__[System.Int32](2147483647) - self.assertTrue(value == 2147483647) - - value = MethodTest.Overloaded.__overloads__[int](2147483647) - self.assertTrue(value == 2147483647) - - value = MethodTest.Overloaded.__overloads__[System.Int64]( - long(9223372036854775807)) - self.assertTrue(value == long(9223372036854775807)) +def test_method_docstrings(): + """Test standard method docstring generation""" + method = MethodTest.GetType + value = 'System.Type GetType()' + assert method.__doc__ == value - # Python 3 has no explicit long type, use System.Int64 instead - if PY2: - value = MethodTest.Overloaded.__overloads__[long]( - long(9223372036854775807)) - self.assertTrue(value == long(9223372036854775807)) - value = MethodTest.Overloaded.__overloads__[System.UInt16](65000) - self.assertTrue(value == 65000) +# ====================================================================== +# Tests of specific argument and result conversion scenarios +# ====================================================================== +def test_method_call_enum_conversion(): + """Test enum conversion in method call.""" + from System import TypeCode - value = MethodTest.Overloaded.__overloads__[System.UInt32]( - long(4294967295)) - self.assertTrue(value == long(4294967295)) + ob = MethodTest() + r = ob.TestEnumConversion(TypeCode.Int32) + assert r == TypeCode.Int32 - value = MethodTest.Overloaded.__overloads__[System.UInt64]( - long(18446744073709551615)) - self.assertTrue(value == long(18446744073709551615)) - value = MethodTest.Overloaded.__overloads__[System.Single](3.402823e38) - self.assertTrue(value == 3.402823e38) +def test_method_call_flags_conversion(): + """Test flags conversion in method call.""" + from System.IO import FileAccess - value = MethodTest.Overloaded.__overloads__[System.Double]( - 1.7976931348623157e308) - self.assertTrue(value == 1.7976931348623157e308) + ob = MethodTest() + flags = FileAccess.Read | FileAccess.Write + r = ob.TestFlagsConversion(flags) + assert r == flags - value = MethodTest.Overloaded.__overloads__[float]( - 1.7976931348623157e308) - self.assertTrue(value == 1.7976931348623157e308) - value = MethodTest.Overloaded.__overloads__[System.Decimal]( - System.Decimal.One) - self.assertTrue(value == System.Decimal.One) +def test_method_call_struct_conversion(): + """Test struct conversion in method call.""" + from System import Guid - value = MethodTest.Overloaded.__overloads__[System.String]("spam") - self.assertTrue(value == "spam") + ob = MethodTest() + guid = Guid.NewGuid() + temp = guid.ToString() + r = ob.TestStructConversion(guid) + assert r.ToString() == temp - value = MethodTest.Overloaded.__overloads__[str]("spam") - self.assertTrue(value == "spam") - value = MethodTest.Overloaded.__overloads__[ShortEnum](ShortEnum.Zero) - self.assertTrue(value == ShortEnum.Zero) +def test_subclass_instance_conversion(): + """Test subclass instance conversion in method call.""" - value = MethodTest.Overloaded.__overloads__[System.Object](inst) - self.assertTrue(value.__class__ == inst.__class__) + class TestSubException(System.Exception): + pass - value = MethodTest.Overloaded.__overloads__[InterfaceTest](inst) - self.assertTrue(value.__class__ == inst.__class__) + ob = MethodTest() + instance = TestSubException() + result = ob.TestSubclassConversion(instance) + assert isinstance(result, System.Exception) - value = MethodTest.Overloaded.__overloads__[ISayHello1](inst) - self.assertTrue(value.__class__ == inst.__class__) - atype = Array[System.Object] - value = MethodTest.Overloaded.__overloads__[str, int, atype]( - "one", 1, atype([1, 2, 3])) - self.assertTrue(value == 3) +def test_null_array_conversion(): + """Test null array conversion in method call.""" + ob = MethodTest() + r = ob.TestNullArrayConversion(None) + assert r is None - value = MethodTest.Overloaded.__overloads__[str, int]("one", 1) - self.assertTrue(value == 1) - value = MethodTest.Overloaded.__overloads__[int, str](1, "one") - self.assertTrue(value == 1) +def test_string_params_args(): + """Test use of string params.""" + result = MethodTest.TestStringParamsArg('one', 'two', 'three') + assert result.Length == 3 + assert len(result) == 3, result + assert result[0] == 'one' + assert result[1] == 'two' + assert result[2] == 'three' - def test_overload_selection_with_array_types(self): - """Check overload selection using array types.""" - from Python.Test import ISayHello1, InterfaceTest, ShortEnum - from System import Array + result = MethodTest.TestStringParamsArg(['one', 'two', 'three']) + assert len(result) == 3 + assert result[0] == 'one' + assert result[1] == 'two' + assert result[2] == 'three' - inst = InterfaceTest() - vtype = Array[System.Boolean] - input_ = vtype([True, True]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] is True) - self.assertTrue(value[1] is True) +def test_object_params_args(): + """Test use of object params.""" + result = MethodTest.TestObjectParamsArg('one', 'two', 'three') + assert len(result) == 3, result + assert result[0] == 'one' + assert result[1] == 'two' + assert result[2] == 'three' - vtype = Array[bool] - input_ = vtype([True, True]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] is True) - self.assertTrue(value[1] is True) + result = MethodTest.TestObjectParamsArg(['one', 'two', 'three']) + assert len(result) == 3, result + assert result[0] == 'one' + assert result[1] == 'two' + assert result[2] == 'three' + + +def test_value_params_args(): + """Test use of value type params.""" + result = MethodTest.TestValueParamsArg(1, 2, 3) + assert len(result) == 3 + assert result[0] == 1 + assert result[1] == 2 + assert result[2] == 3 + + result = MethodTest.TestValueParamsArg([1, 2, 3]) + assert len(result) == 3 + assert result[0] == 1 + assert result[1] == 2 + assert result[2] == 3 + + +def test_non_params_array_in_last_place(): + """Test overload resolution with of non-"params" array as + last parameter.""" + result = MethodTest.TestNonParamsArrayInLastPlace(1, 2, 3) + assert result + + +def test_string_out_params(): + """Test use of string out-parameters.""" + result = MethodTest.TestStringOutParams("hi", "there") + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert result[1] == "output string" + + result = MethodTest.TestStringOutParams("hi", None) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert result[1] == "output string" + + +def test_string_ref_params(): + """Test use of string byref parameters.""" + result = MethodTest.TestStringRefParams("hi", "there") + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert result[1] == "output string" + + result = MethodTest.TestStringRefParams("hi", None) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert result[1] == "output string" + + +def test_value_out_params(): + """Test use of value type out-parameters.""" + result = MethodTest.TestValueOutParams("hi", 1) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert result[1] == 42 + + # None cannot be converted to a value type like int, long, etc. + with pytest.raises(TypeError): + MethodTest.TestValueOutParams("hi", None) + + +def test_value_ref_params(): + """Test use of value type byref parameters.""" + result = MethodTest.TestValueRefParams("hi", 1) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert result[1] == 42 + + # None cannot be converted to a value type like int, long, etc. + with pytest.raises(TypeError): + MethodTest.TestValueRefParams("hi", None) + + +def test_object_out_params(): + """Test use of object out-parameters.""" + result = MethodTest.TestObjectOutParams("hi", MethodTest()) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert isinstance(result[1], System.Exception) + + result = MethodTest.TestObjectOutParams("hi", None) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert isinstance(result[1], System.Exception) + + +def test_object_ref_params(): + """Test use of object byref parameters.""" + result = MethodTest.TestObjectRefParams("hi", MethodTest()) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert isinstance(result[1], System.Exception) + + result = MethodTest.TestObjectRefParams("hi", None) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert isinstance(result[1], System.Exception) + + +def test_struct_out_params(): + """Test use of struct out-parameters.""" + result = MethodTest.TestStructOutParams("hi", System.Guid.NewGuid()) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert isinstance(result[1], System.Guid) + + # None cannot be converted to a value type like a struct + with pytest.raises(TypeError): + MethodTest.TestValueRefParams("hi", None) + + +def test_struct_ref_params(): + """Test use of struct byref parameters.""" + result = MethodTest.TestStructRefParams("hi", System.Guid.NewGuid()) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert isinstance(result[1], System.Guid) + + # None cannot be converted to a value type like a struct + with pytest.raises(TypeError): + MethodTest.TestValueRefParams("hi", None) + + +def test_void_single_out_param(): + """Test void method with single out-parameter.""" + result = MethodTest.TestVoidSingleOutParam(9) + assert result == 42 + + # None cannot be converted to a value type + with pytest.raises(TypeError): + MethodTest.TestVoidSingleOutParam(None) - vtype = Array[System.Byte] - input_ = vtype([0, 255]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 255) - vtype = Array[System.SByte] - input_ = vtype([0, 127]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 127) +def test_void_single_ref_param(): + """Test void method with single ref-parameter.""" + result = MethodTest.TestVoidSingleRefParam(9) + assert result == 42 - vtype = Array[System.Char] - input_ = vtype([u'A', u'Z']) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == u'A') - self.assertTrue(value[1] == u'Z') + # None cannot be converted to a value type + with pytest.raises(TypeError): + MethodTest.TestVoidSingleRefParam(None) - vtype = Array[System.Char] - input_ = vtype([0, 65535]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == unichr(0)) - self.assertTrue(value[1] == unichr(65535)) - vtype = Array[System.Int16] - input_ = vtype([0, 32767]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 32767) +def test_single_default_param(): + """Test void method with single ref-parameter.""" + result = MethodTest.TestSingleDefaultParam() + assert result == 5 - vtype = Array[System.Int32] - input_ = vtype([0, 2147483647]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 2147483647) - vtype = Array[int] - input_ = vtype([0, 2147483647]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 2147483647) +def test_one_arg_and_two_default_param(): + """Test void method with single ref-parameter.""" + result = MethodTest.TestOneArgAndTwoDefaultParam(11) + assert result == 22 - vtype = Array[System.Int64] - input_ = vtype([0, long(9223372036854775807)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == long(9223372036854775807)) - - # Python 3 has no explicit long type, use System.Int64 instead - if PY2: - vtype = Array[long] - input_ = vtype([0, long(9223372036854775807)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == long(9223372036854775807)) - - vtype = Array[System.UInt16] - input_ = vtype([0, 65000]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == 65000) + result = MethodTest.TestOneArgAndTwoDefaultParam(15) + assert result == 26 - vtype = Array[System.UInt32] - input_ = vtype([0, long(4294967295)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == long(4294967295)) + result = MethodTest.TestOneArgAndTwoDefaultParam(20) + assert result == 31 - vtype = Array[System.UInt64] - input_ = vtype([0, long(18446744073709551615)]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0) - self.assertTrue(value[1] == long(18446744073709551615)) - vtype = Array[System.Single] - input_ = vtype([0.0, 3.402823e38]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0.0) - self.assertTrue(value[1] == 3.402823e38) +def test_two_default_param(): + """Test void method with single ref-parameter.""" + result = MethodTest.TestTwoDefaultParam() + assert result == 11 - vtype = Array[System.Double] - input_ = vtype([0.0, 1.7976931348623157e308]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0.0) - self.assertTrue(value[1] == 1.7976931348623157e308) - vtype = Array[float] - input_ = vtype([0.0, 1.7976931348623157e308]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == 0.0) - self.assertTrue(value[1] == 1.7976931348623157e308) +def test_explicit_selection_with_out_modifier(): + """Check explicit overload selection with out modifiers.""" + refstr = System.String("").GetType().MakeByRefType() + result = MethodTest.TestStringOutParams.__overloads__[str, refstr]( + "hi", "there") + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert result[1] == "output string" - vtype = Array[System.Decimal] - input_ = vtype([System.Decimal.Zero, System.Decimal.One]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == System.Decimal.Zero) - self.assertTrue(value[1] == System.Decimal.One) + result = MethodTest.TestStringOutParams.__overloads__[str, refstr]( + "hi", None) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert result[1] == "output string" - vtype = Array[System.String] - input_ = vtype(["one", "two"]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == "one") - self.assertTrue(value[1] == "two") - vtype = Array[str] - input_ = vtype(["one", "two"]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == "one") - self.assertTrue(value[1] == "two") +def test_explicit_selection_with_ref_modifier(): + """Check explicit overload selection with ref modifiers.""" + refstr = System.String("").GetType().MakeByRefType() + result = MethodTest.TestStringRefParams.__overloads__[str, refstr]( + "hi", "there") + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert result[1] == "output string" - vtype = Array[ShortEnum] - input_ = vtype([ShortEnum.Zero, ShortEnum.One]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0] == ShortEnum.Zero) - self.assertTrue(value[1] == ShortEnum.One) + result = MethodTest.TestStringRefParams.__overloads__[str, refstr]( + "hi", None) + assert isinstance(result, tuple) + assert len(result) == 2 + assert result[0] is True + assert result[1] == "output string" - vtype = Array[System.Object] - input_ = vtype([inst, inst]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].__class__ == inst.__class__) - self.assertTrue(value[1].__class__ == inst.__class__) - vtype = Array[InterfaceTest] - input_ = vtype([inst, inst]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].__class__ == inst.__class__) - self.assertTrue(value[1].__class__ == inst.__class__) +def test_explicit_overload_selection(): + """Check explicit overload selection using [] syntax.""" + from Python.Test import ISayHello1, InterfaceTest, ShortEnum + from System import Array - vtype = Array[ISayHello1] - input_ = vtype([inst, inst]) - value = MethodTest.Overloaded.__overloads__[vtype](input_) - self.assertTrue(value[0].__class__ == inst.__class__) - self.assertTrue(value[1].__class__ == inst.__class__) + inst = InterfaceTest() + + value = MethodTest.Overloaded.__overloads__[System.Boolean](True) + assert value is True - def test_explicit_overload_selection_failure(self): - """Check that overload selection fails correctly.""" + value = MethodTest.Overloaded.__overloads__[bool](True) + assert value is True - with self.assertRaises(TypeError): - _ = MethodTest.Overloaded.__overloads__[System.Type](True) + value = MethodTest.Overloaded.__overloads__[System.Byte](255) + assert value == 255 - with self.assertRaises(TypeError): - _ = MethodTest.Overloaded.__overloads__[int, int](1, 1) + value = MethodTest.Overloaded.__overloads__[System.SByte](127) + assert value == 127 - with self.assertRaises(TypeError): - _ = MethodTest.Overloaded.__overloads__[str, int, int]("", 1, 1) + value = MethodTest.Overloaded.__overloads__[System.Char](u'A') + assert value == u'A' - with self.assertRaises(TypeError): - _ = MethodTest.Overloaded.__overloads__[int, long](1) + value = MethodTest.Overloaded.__overloads__[System.Char](65535) + assert value == unichr(65535) - def test_we_can_bind_to_encoding_get_string(self): - """Check that we can bind to the Encoding.GetString method - with variables.""" - from System.Text import Encoding - from System.IO import MemoryStream + value = MethodTest.Overloaded.__overloads__[System.Int16](32767) + assert value == 32767 - my_bytes = Encoding.UTF8.GetBytes('Some testing string') - stream = MemoryStream() - stream.Write(my_bytes, 0, my_bytes.Length) - stream.Position = 0 + value = MethodTest.Overloaded.__overloads__[System.Int32](2147483647) + assert value == 2147483647 - buff = System.Array.CreateInstance(System.Byte, 3) - buff.Initialize() - data = [] - read = 1 + value = MethodTest.Overloaded.__overloads__[int](2147483647) + assert value == 2147483647 - while read > 0: - read, _ = stream.Read(buff, 0, buff.Length) - temp = Encoding.UTF8.GetString(buff, 0, read) - data.append(temp) + value = MethodTest.Overloaded.__overloads__[System.Int64]( + long(9223372036854775807)) + assert value == long(9223372036854775807) - data = ''.join(data) - self.assertEqual(data, 'Some testing string') + # Python 3 has no explicit long type, use System.Int64 instead + if PY2: + value = MethodTest.Overloaded.__overloads__[long]( + long(9223372036854775807)) + assert value == long(9223372036854775807) + + value = MethodTest.Overloaded.__overloads__[System.UInt16](65000) + assert value == 65000 + + value = MethodTest.Overloaded.__overloads__[System.UInt32]( + long(4294967295)) + assert value == long(4294967295) + value = MethodTest.Overloaded.__overloads__[System.UInt64]( + long(18446744073709551615)) + assert value == long(18446744073709551615) -def test_suite(): - return unittest.makeSuite(MethodTests) + value = MethodTest.Overloaded.__overloads__[System.Single](3.402823e38) + assert value == 3.402823e38 + + value = MethodTest.Overloaded.__overloads__[System.Double]( + 1.7976931348623157e308) + assert value == 1.7976931348623157e308 + + value = MethodTest.Overloaded.__overloads__[float]( + 1.7976931348623157e308) + assert value == 1.7976931348623157e308 + + value = MethodTest.Overloaded.__overloads__[System.Decimal]( + System.Decimal.One) + assert value == System.Decimal.One + + value = MethodTest.Overloaded.__overloads__[System.String]("spam") + assert value == "spam" + + value = MethodTest.Overloaded.__overloads__[str]("spam") + assert value == "spam" + + value = MethodTest.Overloaded.__overloads__[ShortEnum](ShortEnum.Zero) + assert value == ShortEnum.Zero + + value = MethodTest.Overloaded.__overloads__[System.Object](inst) + assert value.__class__ == inst.__class__ + + value = MethodTest.Overloaded.__overloads__[InterfaceTest](inst) + assert value.__class__ == inst.__class__ + + value = MethodTest.Overloaded.__overloads__[ISayHello1](inst) + assert value.__class__ == inst.__class__ + + atype = Array[System.Object] + value = MethodTest.Overloaded.__overloads__[str, int, atype]( + "one", 1, atype([1, 2, 3])) + assert value == 3 + + value = MethodTest.Overloaded.__overloads__[str, int]("one", 1) + assert value == 1 + + value = MethodTest.Overloaded.__overloads__[int, str](1, "one") + assert value == 1 + + +def test_overload_selection_with_array_types(): + """Check overload selection using array types.""" + from Python.Test import ISayHello1, InterfaceTest, ShortEnum + from System import Array + + inst = InterfaceTest() + + vtype = Array[System.Boolean] + input_ = vtype([True, True]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] is True + assert value[1] is True + + vtype = Array[bool] + input_ = vtype([True, True]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] is True + assert value[1] is True + + vtype = Array[System.Byte] + input_ = vtype([0, 255]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0 + assert value[1] == 255 + + vtype = Array[System.SByte] + input_ = vtype([0, 127]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0 + assert value[1] == 127 + + vtype = Array[System.Char] + input_ = vtype([u'A', u'Z']) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == u'A' + assert value[1] == u'Z' + + vtype = Array[System.Char] + input_ = vtype([0, 65535]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == unichr(0) + assert value[1] == unichr(65535) + + vtype = Array[System.Int16] + input_ = vtype([0, 32767]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0 + assert value[1] == 32767 + + vtype = Array[System.Int32] + input_ = vtype([0, 2147483647]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0 + assert value[1] == 2147483647 + + vtype = Array[int] + input_ = vtype([0, 2147483647]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0 + assert value[1] == 2147483647 + + vtype = Array[System.Int64] + input_ = vtype([0, long(9223372036854775807)]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0 + assert value[1] == long(9223372036854775807) + + # Python 3 has no explicit long type, use System.Int64 instead + if PY2: + vtype = Array[long] + input_ = vtype([0, long(9223372036854775807)]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0 + assert value[1] == long(9223372036854775807) + + vtype = Array[System.UInt16] + input_ = vtype([0, 65000]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0 + assert value[1] == 65000 + + vtype = Array[System.UInt32] + input_ = vtype([0, long(4294967295)]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0 + assert value[1] == long(4294967295) + + vtype = Array[System.UInt64] + input_ = vtype([0, long(18446744073709551615)]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0 + assert value[1] == long(18446744073709551615) + + vtype = Array[System.Single] + input_ = vtype([0.0, 3.402823e38]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0.0 + assert value[1] == 3.402823e38 + + vtype = Array[System.Double] + input_ = vtype([0.0, 1.7976931348623157e308]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0.0 + assert value[1] == 1.7976931348623157e308 + + vtype = Array[float] + input_ = vtype([0.0, 1.7976931348623157e308]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == 0.0 + assert value[1] == 1.7976931348623157e308 + + vtype = Array[System.Decimal] + input_ = vtype([System.Decimal.Zero, System.Decimal.One]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == System.Decimal.Zero + assert value[1] == System.Decimal.One + + vtype = Array[System.String] + input_ = vtype(["one", "two"]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == "one" + assert value[1] == "two" + + vtype = Array[str] + input_ = vtype(["one", "two"]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == "one" + assert value[1] == "two" + + vtype = Array[ShortEnum] + input_ = vtype([ShortEnum.Zero, ShortEnum.One]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0] == ShortEnum.Zero + assert value[1] == ShortEnum.One + + vtype = Array[System.Object] + input_ = vtype([inst, inst]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0].__class__ == inst.__class__ + assert value[1].__class__ == inst.__class__ + + vtype = Array[InterfaceTest] + input_ = vtype([inst, inst]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0].__class__ == inst.__class__ + assert value[1].__class__ == inst.__class__ + + vtype = Array[ISayHello1] + input_ = vtype([inst, inst]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + assert value[0].__class__ == inst.__class__ + assert value[1].__class__ == inst.__class__ + + +def test_explicit_overload_selection_failure(): + """Check that overload selection fails correctly.""" + + with pytest.raises(TypeError): + _ = MethodTest.Overloaded.__overloads__[System.Type](True) + + with pytest.raises(TypeError): + _ = MethodTest.Overloaded.__overloads__[int, int](1, 1) + + with pytest.raises(TypeError): + _ = MethodTest.Overloaded.__overloads__[str, int, int]("", 1, 1) + + with pytest.raises(TypeError): + _ = MethodTest.Overloaded.__overloads__[int, long](1) + + +def test_we_can_bind_to_encoding_get_string(): + """Check that we can bind to the Encoding.GetString method + with variables.""" + from System.Text import Encoding + from System.IO import MemoryStream + + my_bytes = Encoding.UTF8.GetBytes('Some testing string') + stream = MemoryStream() + stream.Write(my_bytes, 0, my_bytes.Length) + stream.Position = 0 + + buff = System.Array.CreateInstance(System.Byte, 3) + buff.Initialize() + data = [] + read = 1 + + while read > 0: + read, _ = stream.Read(buff, 0, buff.Length) + temp = Encoding.UTF8.GetString(buff, 0, read) + data.append(temp) + + data = ''.join(data) + assert data == 'Some testing string' diff --git a/src/tests/test_module.py b/src/tests/test_module.py index 5ee8e6fc2..2255ea411 100644 --- a/src/tests/test_module.py +++ b/src/tests/test_module.py @@ -1,348 +1,369 @@ # -*- coding: utf-8 -*- +"""Test CLR modules and the CLR import hook.""" + import clr import time import types -import unittest import warnings from fnmatch import fnmatch -from _compat import ClassType, PY2, PY3, range -from utils import is_clr_class, is_clr_module, is_clr_root_module +import pytest + +from ._compat import ClassType, PY2, PY3, range +from .utils import is_clr_class, is_clr_module, is_clr_root_module # testImplicitAssemblyLoad() passes on deprecation warning; perfect! # # clr.AddReference('System.Windows.Forms') -class ModuleTests(unittest.TestCase): - """Test CLR modules and the CLR import hook.""" +def test_import_hook_works(): + """Test that the import hook works correctly both using the + included runtime and an external runtime. This must be + the first test run in the unit tests!""" + from System import String - def test_import_hook_works(self): - """Test that the import hook works correctly both using the - included runtime and an external runtime. This must be - the first test run in the unit tests!""" - from System import String - def test_import_clr(self): - import clr - self.assertTrue(is_clr_root_module(clr)) +def test_import_clr(): + import clr + assert is_clr_root_module(clr) - def test_version_clr(self): - import clr - self.assertTrue(clr.__version__ >= "2.2.0") - def test_preload_var(self): - import clr - self.assertTrue(clr.getPreload() is False, clr.getPreload()) +def test_version_clr(): + import clr + assert clr.__version__ >= "2.2.0" + + +def test_preload_var(): + import clr + assert clr.getPreload() is False, clr.getPreload() + clr.setPreload(False) + assert clr.getPreload() is False, clr.getPreload() + try: + clr.setPreload(True) + assert clr.getPreload() is True, clr.getPreload() + clr.setPreload(0) + assert clr.getPreload() is False, clr.getPreload() + clr.setPreload(1) + assert clr.getPreload() is True, clr.getPreload() + + import System.Configuration + content = dir(System.Configuration) + assert len(content) > 10, content + finally: clr.setPreload(False) - self.assertTrue(clr.getPreload() is False, clr.getPreload()) - try: - clr.setPreload(True) - self.assertTrue(clr.getPreload() is True, clr.getPreload()) - clr.setPreload(0) - self.assertTrue(clr.getPreload() is False, clr.getPreload()) - clr.setPreload(1) - self.assertTrue(clr.getPreload() is True, clr.getPreload()) - - import System.Configuration - content = dir(System.Configuration) - self.assertTrue(len(content) > 10, content) - finally: - clr.setPreload(False) - - def test_module_interface(self): - """Test the interface exposed by CLR module objects.""" - import System - self.assertEquals(type(System.__dict__), type({})) - self.assertEquals(System.__name__, 'System') - # the filename can be any module from the System namespace - # (eg System.Data.dll or System.dll, but also mscorlib.dll) - system_file = System.__file__ - self.assertTrue(fnmatch(system_file, "*System*.dll") or fnmatch(system_file, "*mscorlib.dll"), - "unexpected System.__file__: " + system_file) - self.assertTrue(System.__doc__.startswith("Namespace containing types from the following assemblies:")) - self.assertTrue(is_clr_class(System.String)) - self.assertTrue(is_clr_class(System.Int32)) - - def test_simple_import(self): - """Test simple import.""" - import System - self.assertTrue(is_clr_module(System)) - self.assertTrue(System.__name__ == 'System') - - import sys - self.assertTrue(isinstance(sys, types.ModuleType)) - self.assertTrue(sys.__name__ == 'sys') - - if PY3: - import http.client as httplib - self.assertTrue(isinstance(httplib, types.ModuleType)) - self.assertTrue(httplib.__name__ == 'http.client') - elif PY2: - import httplib - self.assertTrue(isinstance(httplib, types.ModuleType)) - self.assertTrue(httplib.__name__ == 'httplib') - - def test_simple_import_with_alias(self): - """Test simple import with aliasing.""" - import System as mySystem - self.assertTrue(is_clr_module(mySystem)) - self.assertTrue(mySystem.__name__ == 'System') - - import sys as mySys - self.assertTrue(isinstance(mySys, types.ModuleType)) - self.assertTrue(mySys.__name__ == 'sys') - - if PY3: - import http.client as myHttplib - self.assertTrue(isinstance(myHttplib, types.ModuleType)) - self.assertTrue(myHttplib.__name__ == 'http.client') - elif PY2: - import httplib as myHttplib - self.assertTrue(isinstance(myHttplib, types.ModuleType)) - self.assertTrue(myHttplib.__name__ == 'httplib') - - def test_dotted_name_import(self): - """Test dotted-name import.""" - import System.Reflection - self.assertTrue(is_clr_module(System.Reflection)) - self.assertTrue(System.Reflection.__name__ == 'System.Reflection') - - import xml.dom - self.assertTrue(isinstance(xml.dom, types.ModuleType)) - self.assertTrue(xml.dom.__name__ == 'xml.dom') - - def test_multiple_dotted_name_import(self): - """Test an import bug with multiple dotted imports.""" - import System.Data - self.assertTrue(is_clr_module(System.Data)) - self.assertTrue(System.Data.__name__ == 'System.Data') - import System.Data - self.assertTrue(is_clr_module(System.Data)) - self.assertTrue(System.Data.__name__ == 'System.Data') - - def test_dotted_name_import_with_alias(self): - """Test dotted-name import with aliasing.""" - import System.Reflection as SysRef - self.assertTrue(is_clr_module(SysRef)) - self.assertTrue(SysRef.__name__ == 'System.Reflection') - - import xml.dom as myDom - self.assertTrue(isinstance(myDom, types.ModuleType)) - self.assertTrue(myDom.__name__ == 'xml.dom') - - def test_simple_import_from(self): - """Test simple 'import from'.""" - from System import Reflection - self.assertTrue(is_clr_module(Reflection)) - self.assertTrue(Reflection.__name__ == 'System.Reflection') - - from xml import dom - self.assertTrue(isinstance(dom, types.ModuleType)) - self.assertTrue(dom.__name__ == 'xml.dom') - - def test_simple_import_from_with_alias(self): - """Test simple 'import from' with aliasing.""" - from System import Collections as Coll - self.assertTrue(is_clr_module(Coll)) - self.assertTrue(Coll.__name__ == 'System.Collections') - - from xml import dom as myDom - self.assertTrue(isinstance(myDom, types.ModuleType)) - self.assertTrue(myDom.__name__ == 'xml.dom') - - def test_dotted_name_import_from(self): - """Test dotted-name 'import from'.""" - from System.Collections import Specialized - self.assertTrue(is_clr_module(Specialized)) - self.assertTrue( - Specialized.__name__ == 'System.Collections.Specialized') - - from System.Collections.Specialized import StringCollection - self.assertTrue(is_clr_class(StringCollection)) - self.assertTrue(StringCollection.__name__ == 'StringCollection') - - from xml.dom import pulldom - self.assertTrue(isinstance(pulldom, types.ModuleType)) - self.assertTrue(pulldom.__name__ == 'xml.dom.pulldom') - - from xml.dom.pulldom import PullDOM - self.assertTrue(isinstance(PullDOM, ClassType)) - self.assertTrue(PullDOM.__name__ == 'PullDOM') - - def test_dotted_name_import_from_with_alias(self): - """Test dotted-name 'import from' with aliasing.""" - from System.Collections import Specialized as Spec - self.assertTrue(is_clr_module(Spec)) - self.assertTrue(Spec.__name__ == 'System.Collections.Specialized') - - from System.Collections.Specialized import StringCollection as SC - self.assertTrue(is_clr_class(SC)) - self.assertTrue(SC.__name__ == 'StringCollection') - - from xml.dom import pulldom as myPulldom - self.assertTrue(isinstance(myPulldom, types.ModuleType)) - self.assertTrue(myPulldom.__name__ == 'xml.dom.pulldom') - - from xml.dom.pulldom import PullDOM as myPullDOM - self.assertTrue(isinstance(myPullDOM, ClassType)) - self.assertTrue(myPullDOM.__name__ == 'PullDOM') - - def test_from_module_import_star(self): - """Test from module import * behavior.""" - count = len(locals().keys()) - m = __import__('System.Xml', globals(), locals(), ['*']) - self.assertTrue(m.__name__ == 'System.Xml') - self.assertTrue(is_clr_module(m)) - self.assertTrue(len(locals().keys()) > count + 1) - - def test_implicit_assembly_load(self): - """Test implicit assembly loading via import.""" - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always") - - # should trigger a DeprecationWarning as Microsoft.Build hasn't - # been added as a reference yet (and should exist for mono) - import Microsoft.Build - - self.assertEqual(len(w), 1) - self.assertTrue(isinstance(w[0].message, DeprecationWarning)) - - with warnings.catch_warnings(record=True) as w: - clr.AddReference("System.Windows.Forms") - import System.Windows.Forms as Forms - self.assertTrue(is_clr_module(Forms)) - self.assertTrue(Forms.__name__ == 'System.Windows.Forms') - from System.Windows.Forms import Form - self.assertTrue(is_clr_class(Form)) - self.assertTrue(Form.__name__ == 'Form') - self.assertEqual(len(w), 0) - - def test_explicit_assembly_load(self): - """Test explicit assembly loading using standard CLR tools.""" - from System.Reflection import Assembly - import System, sys - - assembly = Assembly.LoadWithPartialName('System.Data') - self.assertTrue(assembly is not None) - - import System.Data - self.assertTrue('System.Data' in sys.modules) - - assembly = Assembly.LoadWithPartialName('SpamSpamSpamSpamEggsAndSpam') - self.assertTrue(assembly is None) - - def test_implicit_load_already_valid_namespace(self): - """Test implicit assembly load over an already valid namespace.""" - # In this case, the mscorlib assembly (loaded by default) defines - # a number of types in the System namespace. There is also a System - # assembly, which is _not_ loaded by default, which also contains - # types in the System namespace. The desired behavior is for the - # Python runtime to "do the right thing", allowing types from both - # assemblies to be found in the System module implicitly. - import System - self.assertTrue(is_clr_class(System.UriBuilder)) - def test_import_non_existant_module(self): - """Test import failure for a non-existent module.""" - with self.assertRaises(ImportError): - import System.SpamSpamSpam - def test_lookup_no_namespace_type(self): - """Test lookup of types without a qualified namespace.""" - import Python.Test - import clr - self.assertTrue(is_clr_class(clr.NoNamespaceType)) +def test_module_interface(): + """Test the interface exposed by CLR module objects.""" + import System + assert type(System.__dict__) == type({}) + assert System.__name__ == 'System' + # the filename can be any module from the System namespace + # (eg System.Data.dll or System.dll, but also mscorlib.dll) + system_file = System.__file__ + assert fnmatch(system_file, "*System*.dll") or fnmatch(system_file, "*mscorlib.dll"), \ + "unexpected System.__file__: " + system_file + assert System.__doc__.startswith("Namespace containing types from the following assemblies:") + assert is_clr_class(System.String) + assert is_clr_class(System.Int32) + + +def test_simple_import(): + """Test simple import.""" + import System + assert is_clr_module(System) + assert System.__name__ == 'System' + + import sys + assert isinstance(sys, types.ModuleType) + assert sys.__name__ == 'sys' + + if PY3: + import http.client as httplib + assert isinstance(httplib, types.ModuleType) + assert httplib.__name__ == 'http.client' + elif PY2: + import httplib + assert isinstance(httplib, types.ModuleType) + assert httplib.__name__ == 'httplib' + + +def test_simple_import_with_alias(): + """Test simple import with aliasing.""" + import System as mySystem + assert is_clr_module(mySystem) + assert mySystem.__name__ == 'System' + + import sys as mySys + assert isinstance(mySys, types.ModuleType) + assert mySys.__name__ == 'sys' + + if PY3: + import http.client as myHttplib + assert isinstance(myHttplib, types.ModuleType) + assert myHttplib.__name__ == 'http.client' + elif PY2: + import httplib as myHttplib + assert isinstance(myHttplib, types.ModuleType) + assert myHttplib.__name__ == 'httplib' + + +def test_dotted_name_import(): + """Test dotted-name import.""" + import System.Reflection + assert is_clr_module(System.Reflection) + assert System.Reflection.__name__ == 'System.Reflection' + + import xml.dom + assert isinstance(xml.dom, types.ModuleType) + assert xml.dom.__name__ == 'xml.dom' + + +def test_multiple_dotted_name_import(): + """Test an import bug with multiple dotted imports.""" + import System.Data + assert is_clr_module(System.Data) + assert System.Data.__name__ == 'System.Data' + import System.Data + assert is_clr_module(System.Data) + assert System.Data.__name__ == 'System.Data' + + +def test_dotted_name_import_with_alias(): + """Test dotted-name import with aliasing.""" + import System.Reflection as SysRef + assert is_clr_module(SysRef) + assert SysRef.__name__ == 'System.Reflection' + + import xml.dom as myDom + assert isinstance(myDom, types.ModuleType) + assert myDom.__name__ == 'xml.dom' + + +def test_simple_import_from(): + """Test simple 'import from'.""" + from System import Reflection + assert is_clr_module(Reflection) + assert Reflection.__name__ == 'System.Reflection' + + from xml import dom + assert isinstance(dom, types.ModuleType) + assert dom.__name__ == 'xml.dom' + + +def test_simple_import_from_with_alias(): + """Test simple 'import from' with aliasing.""" + from System import Collections as Coll + assert is_clr_module(Coll) + assert Coll.__name__ == 'System.Collections' + + from xml import dom as myDom + assert isinstance(myDom, types.ModuleType) + assert myDom.__name__ == 'xml.dom' + + +def test_dotted_name_import_from(): + """Test dotted-name 'import from'.""" + from System.Collections import Specialized + assert is_clr_module(Specialized) + assert Specialized.__name__ == 'System.Collections.Specialized' + + from System.Collections.Specialized import StringCollection + assert is_clr_class(StringCollection) + assert StringCollection.__name__ == 'StringCollection' + + from xml.dom import pulldom + assert isinstance(pulldom, types.ModuleType) + assert pulldom.__name__ == 'xml.dom.pulldom' + + from xml.dom.pulldom import PullDOM + assert isinstance(PullDOM, ClassType) + assert PullDOM.__name__ == 'PullDOM' + + +def test_dotted_name_import_from_with_alias(): + """Test dotted-name 'import from' with aliasing.""" + from System.Collections import Specialized as Spec + assert is_clr_module(Spec) + assert Spec.__name__ == 'System.Collections.Specialized' + + from System.Collections.Specialized import StringCollection as SC + assert is_clr_class(SC) + assert SC.__name__ == 'StringCollection' + + from xml.dom import pulldom as myPulldom + assert isinstance(myPulldom, types.ModuleType) + assert myPulldom.__name__ == 'xml.dom.pulldom' + + from xml.dom.pulldom import PullDOM as myPullDOM + assert isinstance(myPullDOM, ClassType) + assert myPullDOM.__name__ == 'PullDOM' + + +def test_from_module_import_star(): + """Test from module import * behavior.""" + count = len(locals().keys()) + m = __import__('System.Xml', globals(), locals(), ['*']) + assert m.__name__ == 'System.Xml' + assert is_clr_module(m) + assert len(locals().keys()) > count + 1 + + +def test_implicit_assembly_load(): + """Test implicit assembly loading via import.""" + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + + # should trigger a DeprecationWarning as Microsoft.Build hasn't + # been added as a reference yet (and should exist for mono) + import Microsoft.Build + + assert len(w) == 1 + assert isinstance(w[0].message, DeprecationWarning) + + with warnings.catch_warnings(record=True) as w: + clr.AddReference("System.Windows.Forms") + import System.Windows.Forms as Forms + assert is_clr_module(Forms) + assert Forms.__name__ == 'System.Windows.Forms' + from System.Windows.Forms import Form + assert is_clr_class(Form) + assert Form.__name__ == 'Form' + assert len(w) == 0 - def test_module_lookup_recursion(self): - """Test for recursive lookup handling.""" - with self.assertRaises(ImportError): - from System import System +def test_explicit_assembly_load(): + """Test explicit assembly loading using standard CLR tools.""" + from System.Reflection import Assembly + import System, sys - with self.assertRaises(AttributeError): - import System - _ = System.System + assembly = Assembly.LoadWithPartialName('System.Data') + assert assembly is not None - def test_module_get_attr(self): - """Test module getattr behavior.""" + import System.Data + assert 'System.Data' in sys.modules + + assembly = Assembly.LoadWithPartialName('SpamSpamSpamSpamEggsAndSpam') + assert assembly is None + + +def test_implicit_load_already_valid_namespace(): + """Test implicit assembly load over an already valid namespace.""" + # In this case, the mscorlib assembly (loaded by default) defines + # a number of types in the System namespace. There is also a System + # assembly, which is _not_ loaded by default, which also contains + # types in the System namespace. The desired behavior is for the + # Python runtime to "do the right thing", allowing types from both + # assemblies to be found in the System module implicitly. + import System + assert is_clr_class(System.UriBuilder) + + +def test_import_non_existant_module(): + """Test import failure for a non-existent module.""" + with pytest.raises(ImportError): + import System.SpamSpamSpam + + +def test_lookup_no_namespace_type(): + """Test lookup of types without a qualified namespace.""" + import Python.Test + import clr + assert is_clr_class(clr.NoNamespaceType) + + +def test_module_lookup_recursion(): + """Test for recursive lookup handling.""" + + with pytest.raises(ImportError): + from System import System + + with pytest.raises(AttributeError): import System + _ = System.System + - int_type = System.Int32 - self.assertTrue(is_clr_class(int_type)) +def test_module_get_attr(): + """Test module getattr behavior.""" + import System - module = System.Xml - self.assertTrue(is_clr_module(module)) + int_type = System.Int32 + assert is_clr_class(int_type) - with self.assertRaises(AttributeError): - _ = System.Spam + module = System.Xml + assert is_clr_module(module) - with self.assertRaises(TypeError): - _ = getattr(System, 1) + with pytest.raises(AttributeError): + _ = System.Spam - def test_module_attr_abuse(self): - """Test handling of attempts to set module attributes.""" + with pytest.raises(TypeError): + _ = getattr(System, 1) - # It would be safer to use a dict-proxy as the __dict__ for CLR - # modules, but as of Python 2.3 some parts of the CPython runtime - # like dir() will fail if a module dict is not a real dictionary. - def test(): - import System - System.__dict__['foo'] = 0 - return 1 +def test_module_attr_abuse(): + """Test handling of attempts to set module attributes.""" - self.assertTrue(test()) + # It would be safer to use a dict-proxy as the __dict__ for CLR + # modules, but as of Python 2.3 some parts of the CPython runtime + # like dir() will fail if a module dict is not a real dictionary. - def test_module_type_abuse(self): - """Test handling of attempts to break the module type.""" + def test(): import System - mtype = type(System) - - with self.assertRaises(TypeError): - mtype.__getattribute__(0, 'spam') - - with self.assertRaises(TypeError): - mtype.__setattr__(0, 'spam', 1) - - with self.assertRaises(TypeError): - mtype.__repr__(0) - - def test_clr_list_assemblies(self): - from clr import ListAssemblies - verbose = list(ListAssemblies(True)) - short = list(ListAssemblies(False)) - self.assertTrue(u'mscorlib' in short) - self.assertTrue(u'System' in short) - self.assertTrue(u'Culture=' in verbose[0]) - self.assertTrue(u'Version=' in verbose[0]) - - def test_clr_add_reference(self): - from clr import AddReference - from System.IO import FileNotFoundException - for name in ("System", "Python.Runtime"): - assy = AddReference(name) - assy_name = assy.GetName().Name - self.assertEqual(assy_name, name) - - with self.assertRaises(FileNotFoundException): - AddReference("somethingtotallysilly") - - def test_assembly_load_thread_safety(self): - from Python.Test import ModuleTest - # spin up .NET thread which loads assemblies and triggers AppDomain.AssemblyLoad event - ModuleTest.RunThreads() - time.sleep(1e-5) - for _ in range(1, 100): - # call import clr, which in AssemblyManager.GetNames iterates through the loaded types - import clr - # import some .NET types - from System import DateTime - from System import Guid - from System.Collections.Generic import Dictionary - _ = Dictionary[Guid, DateTime]() - ModuleTest.JoinThreads() - - -def test_suite(): - return unittest.makeSuite(ModuleTests) + System.__dict__['foo'] = 0 + return 1 + + assert test() + + +def test_module_type_abuse(): + """Test handling of attempts to break the module type.""" + import System + mtype = type(System) + + with pytest.raises(TypeError): + mtype.__getattribute__(0, 'spam') + + with pytest.raises(TypeError): + mtype.__setattr__(0, 'spam', 1) + + with pytest.raises(TypeError): + mtype.__repr__(0) + + +def test_clr_list_assemblies(): + from clr import ListAssemblies + verbose = list(ListAssemblies(True)) + short = list(ListAssemblies(False)) + assert u'mscorlib' in short + assert u'System' in short + assert u'Culture=' in verbose[0] + assert u'Version=' in verbose[0] + + +def test_clr_add_reference(): + from clr import AddReference + from System.IO import FileNotFoundException + for name in ("System", "Python.Runtime"): + assy = AddReference(name) + assy_name = assy.GetName().Name + assert assy_name == name + + with pytest.raises(FileNotFoundException): + AddReference("somethingtotallysilly") + + +def test_assembly_load_thread_safety(): + from Python.Test import ModuleTest + # spin up .NET thread which loads assemblies and triggers AppDomain.AssemblyLoad event + ModuleTest.RunThreads() + time.sleep(1e-5) + for _ in range(1, 100): + # call import clr, which in AssemblyManager.GetNames iterates through the loaded types + import clr + # import some .NET types + from System import DateTime + from System import Guid + from System.Collections.Generic import Dictionary + _ = Dictionary[Guid, DateTime]() + ModuleTest.JoinThreads() diff --git a/src/tests/test_property.py b/src/tests/test_property.py index 8fb37768a..4dc8ea111 100644 --- a/src/tests/test_property.py +++ b/src/tests/test_property.py @@ -1,145 +1,148 @@ # -*- coding: utf-8 -*- -import unittest +"""Test CLR property support.""" +import pytest from Python.Test import PropertyTest -class PropertyTests(unittest.TestCase): - """Test CLR property support.""" +def test_public_instance_property(): + """Test public instance properties.""" + ob = PropertyTest() - def test_public_instance_property(self): - """Test public instance properties.""" - ob = PropertyTest() + assert ob.PublicProperty == 0 + ob.PublicProperty = 1 + assert ob.PublicProperty == 1 - self.assertTrue(ob.PublicProperty == 0) - ob.PublicProperty = 1 - self.assertTrue(ob.PublicProperty == 1) + with pytest.raises(TypeError): + del PropertyTest().PublicProperty - with self.assertRaises(TypeError): - del PropertyTest().PublicProperty - def test_public_static_property(self): - """Test public static properties.""" - ob = PropertyTest() +def test_public_static_property(): + """Test public static properties.""" + ob = PropertyTest() - self.assertTrue(PropertyTest.PublicStaticProperty == 0) - PropertyTest.PublicStaticProperty = 1 - self.assertTrue(PropertyTest.PublicStaticProperty == 1) + assert PropertyTest.PublicStaticProperty == 0 + PropertyTest.PublicStaticProperty = 1 + assert PropertyTest.PublicStaticProperty == 1 - self.assertTrue(ob.PublicStaticProperty == 1) - ob.PublicStaticProperty = 0 - self.assertTrue(ob.PublicStaticProperty == 0) + assert ob.PublicStaticProperty == 1 + ob.PublicStaticProperty = 0 + assert ob.PublicStaticProperty == 0 - with self.assertRaises(TypeError): - del PropertyTest.PublicStaticProperty + with pytest.raises(TypeError): + del PropertyTest.PublicStaticProperty - with self.assertRaises(TypeError): - del PropertyTest().PublicStaticProperty + with pytest.raises(TypeError): + del PropertyTest().PublicStaticProperty - def test_protected_instance_property(self): - """Test protected instance properties.""" - ob = PropertyTest() - self.assertTrue(ob.ProtectedProperty == 0) - ob.ProtectedProperty = 1 - self.assertTrue(ob.ProtectedProperty == 1) +def test_protected_instance_property(): + """Test protected instance properties.""" + ob = PropertyTest() - with self.assertRaises(TypeError): - del PropertyTest().ProtectedProperty + assert ob.ProtectedProperty == 0 + ob.ProtectedProperty = 1 + assert ob.ProtectedProperty == 1 - def test_protected_static_property(self): - """Test protected static properties.""" - ob = PropertyTest() + with pytest.raises(TypeError): + del PropertyTest().ProtectedProperty - self.assertTrue(PropertyTest.ProtectedStaticProperty == 0) - PropertyTest.ProtectedStaticProperty = 1 - self.assertTrue(PropertyTest.ProtectedStaticProperty == 1) - self.assertTrue(ob.ProtectedStaticProperty == 1) - ob.ProtectedStaticProperty = 0 - self.assertTrue(ob.ProtectedStaticProperty == 0) +def test_protected_static_property(): + """Test protected static properties.""" + ob = PropertyTest() - with self.assertRaises(TypeError): - del PropertyTest.ProtectedStaticProperty + assert PropertyTest.ProtectedStaticProperty == 0 + PropertyTest.ProtectedStaticProperty = 1 + assert PropertyTest.ProtectedStaticProperty == 1 - with self.assertRaises(TypeError): - del PropertyTest().ProtectedStaticProperty + assert ob.ProtectedStaticProperty == 1 + ob.ProtectedStaticProperty = 0 + assert ob.ProtectedStaticProperty == 0 - def test_internal_property(self): - """Test internal properties.""" + with pytest.raises(TypeError): + del PropertyTest.ProtectedStaticProperty - with self.assertRaises(AttributeError): - _ = PropertyTest().InternalProperty + with pytest.raises(TypeError): + del PropertyTest().ProtectedStaticProperty - with self.assertRaises(AttributeError): - _ = PropertyTest().InternalStaticProperty - with self.assertRaises(AttributeError): - _ = PropertyTest.InternalStaticProperty +def test_internal_property(): + """Test internal properties.""" - def test_private_property(self): - """Test private properties.""" + with pytest.raises(AttributeError): + _ = PropertyTest().InternalProperty - with self.assertRaises(AttributeError): - _ = PropertyTest().PrivateProperty + with pytest.raises(AttributeError): + _ = PropertyTest().InternalStaticProperty - with self.assertRaises(AttributeError): - _ = PropertyTest().PrivateStaticProperty + with pytest.raises(AttributeError): + _ = PropertyTest.InternalStaticProperty - with self.assertRaises(AttributeError): - _ = PropertyTest.PrivateStaticProperty - def test_property_descriptor_get_set(self): - """Test property descriptor get / set.""" +def test_private_property(): + """Test private properties.""" - # This test ensures that setting an attribute implemented with - # a descriptor actually goes through the descriptor (rather than - # silently replacing the descriptor in the instance or type dict. + with pytest.raises(AttributeError): + _ = PropertyTest().PrivateProperty - ob = PropertyTest() + with pytest.raises(AttributeError): + _ = PropertyTest().PrivateStaticProperty + + with pytest.raises(AttributeError): + _ = PropertyTest.PrivateStaticProperty - self.assertTrue(PropertyTest.PublicStaticProperty == 0) - self.assertTrue(ob.PublicStaticProperty == 0) - descriptor = PropertyTest.__dict__['PublicStaticProperty'] - self.assertTrue(type(descriptor) != int) +def test_property_descriptor_get_set(): + """Test property descriptor get / set.""" - ob.PublicStaticProperty = 0 - descriptor = PropertyTest.__dict__['PublicStaticProperty'] - self.assertTrue(type(descriptor) != int) + # This test ensures that setting an attribute implemented with + # a descriptor actually goes through the descriptor (rather than + # silently replacing the descriptor in the instance or type dict. - PropertyTest.PublicStaticProperty = 0 - descriptor = PropertyTest.__dict__['PublicStaticProperty'] - self.assertTrue(type(descriptor) != int) + ob = PropertyTest() - def test_property_descriptor_wrong_type(self): - """Test setting a property using a value of the wrong type.""" + assert PropertyTest.PublicStaticProperty == 0 + assert ob.PublicStaticProperty == 0 - with self.assertRaises(TypeError): - ob = PropertyTest() - ob.PublicProperty = "spam" + descriptor = PropertyTest.__dict__['PublicStaticProperty'] + assert type(descriptor) != int + + ob.PublicStaticProperty = 0 + descriptor = PropertyTest.__dict__['PublicStaticProperty'] + assert type(descriptor) != int + + PropertyTest.PublicStaticProperty = 0 + descriptor = PropertyTest.__dict__['PublicStaticProperty'] + assert type(descriptor) != int + + +def test_property_descriptor_wrong_type(): + """Test setting a property using a value of the wrong type.""" + + with pytest.raises(TypeError): + ob = PropertyTest() + ob.PublicProperty = "spam" - def test_property_descriptor_abuse(self): - """Test property descriptor abuse.""" - desc = PropertyTest.__dict__['PublicProperty'] - with self.assertRaises(TypeError): - desc.__get__(0, 0) +def test_property_descriptor_abuse(): + """Test property descriptor abuse.""" + desc = PropertyTest.__dict__['PublicProperty'] - with self.assertRaises(TypeError): - desc.__set__(0, 0) + with pytest.raises(TypeError): + desc.__get__(0, 0) - def test_interface_property(self): - """Test properties of interfaces. Added after a bug report - that an IsAbstract check was inappropriate and prevented - use of properties when only the interface is known.""" - from System.Collections import Hashtable, ICollection + with pytest.raises(TypeError): + desc.__set__(0, 0) - mapping = Hashtable() - coll = ICollection(mapping) - self.assertTrue(coll.Count == 0) +def test_interface_property(): + """Test properties of interfaces. Added after a bug report + that an IsAbstract check was inappropriate and prevented + use of properties when only the interface is known.""" + from System.Collections import Hashtable, ICollection -def test_suite(): - return unittest.makeSuite(PropertyTests) + mapping = Hashtable() + coll = ICollection(mapping) + assert coll.Count == 0 diff --git a/src/tests/test_recursive_types.py b/src/tests/test_recursive_types.py new file mode 100644 index 000000000..ca4b871cf --- /dev/null +++ b/src/tests/test_recursive_types.py @@ -0,0 +1,12 @@ +# -*- coding: utf-8 -*- + +"""Test if interop with recursive type inheritance works.""" + + +def test_recursive_type_creation(): + """Test that a recursive types don't crash with a + StackOverflowException""" + from Python.Test import RecursiveInheritance + + test_instance = RecursiveInheritance.SubClass() + test_instance.SomeMethod() diff --git a/src/tests/test_subclass.py b/src/tests/test_subclass.py index 34ec86d9a..8e862a56d 100644 --- a/src/tests/test_subclass.py +++ b/src/tests/test_subclass.py @@ -4,14 +4,15 @@ # both Linux and Windows # TODO: Remove delay of class creations. Adding SetUp/TearDown may help -import unittest +"""Test sub-classing managed types""" import System +import pytest from Python.Test import (IInterfaceTest, SubClassTest, EventArgsTest, FunctionsTest) from System.Collections.Generic import List -from _compat import range +from ._compat import range def interface_test_class_fixture(): @@ -84,113 +85,111 @@ def OnTestEvent(self, value): return DerivedEventTest -class SubClassTests(unittest.TestCase): - """Test sub-classing managed types""" - - @unittest.skip(reason="FIXME: test randomly pass/fails") - def test_base_class(self): - """Test base class managed type""" - ob = SubClassTest() - self.assertEqual(ob.foo(), "foo") - self.assertEqual(FunctionsTest.test_foo(ob), "foo") - self.assertEqual(ob.bar("bar", 2), "bar") - self.assertEqual(FunctionsTest.test_bar(ob, "bar", 2), "bar") - self.assertEqual(ob.not_overriden(), "not_overriden") - self.assertEqual(list(ob.return_list()), ["a", "b", "c"]) - self.assertEqual(list(SubClassTest.test_list(ob)), ["a", "b", "c"]) - - @unittest.skip(reason="FIXME: test randomly pass/fails") - def test_interface(self): - """Test python classes can derive from C# interfaces""" - InterfaceTestClass = interface_test_class_fixture() - ob = InterfaceTestClass() - self.assertEqual(ob.foo(), "InterfaceTestClass") - self.assertEqual(FunctionsTest.test_foo(ob), "InterfaceTestClass") - self.assertEqual(ob.bar("bar", 2), "bar/bar") - self.assertEqual(FunctionsTest.test_bar(ob, "bar", 2), "bar/bar") - - x = FunctionsTest.pass_through(ob) - self.assertEqual(id(x), id(ob)) - - @unittest.skip(reason="FIXME: test randomly pass/fails") - def test_derived_class(self): - """Test python class derived from managed type""" - DerivedClass = derived_class_fixture() - ob = DerivedClass() - self.assertEqual(ob.foo(), "DerivedClass") - self.assertEqual(ob.base_foo(), "foo") - self.assertEqual(ob.super_foo(), "foo") - self.assertEqual(FunctionsTest.test_foo(ob), "DerivedClass") - self.assertEqual(ob.bar("bar", 2), "bar_bar") - self.assertEqual(FunctionsTest.test_bar(ob, "bar", 2), "bar_bar") - self.assertEqual(ob.not_overriden(), "not_overriden") - self.assertEqual(list(ob.return_list()), ["A", "B", "C"]) - self.assertEqual(list(SubClassTest.test_list(ob)), ["A", "B", "C"]) - - x = FunctionsTest.pass_through(ob) - self.assertEqual(id(x), id(ob)) - - @unittest.skip(reason="FIXME: test randomly pass/fails") - def test_create_instance(self): - """Test derived instances can be created from managed code""" - DerivedClass = derived_class_fixture() - ob = FunctionsTest.create_instance(DerivedClass) - self.assertEqual(ob.foo(), "DerivedClass") - self.assertEqual(FunctionsTest.test_foo(ob), "DerivedClass") - self.assertEqual(ob.bar("bar", 2), "bar_bar") - self.assertEqual(FunctionsTest.test_bar(ob, "bar", 2), "bar_bar") - self.assertEqual(ob.not_overriden(), "not_overriden") - - x = FunctionsTest.pass_through(ob) - self.assertEqual(id(x), id(ob)) - - InterfaceTestClass = interface_test_class_fixture() - ob2 = FunctionsTest.create_instance(InterfaceTestClass) - self.assertEqual(ob2.foo(), "InterfaceTestClass") - self.assertEqual(FunctionsTest.test_foo(ob2), "InterfaceTestClass") - self.assertEqual(ob2.bar("bar", 2), "bar/bar") - self.assertEqual(FunctionsTest.test_bar(ob2, "bar", 2), "bar/bar") - - y = FunctionsTest.pass_through(ob2) - self.assertEqual(id(y), id(ob2)) - - @unittest.skip(reason="FIXME: test randomly pass/fails") - def test_events(self): - class EventHandler(object): - def handler(self, x, args): - self.value = args.value - - event_handler = EventHandler() - - x = SubClassTest() - x.TestEvent += event_handler.handler - self.assertEqual(FunctionsTest.test_event(x, 1), 1) - self.assertEqual(event_handler.value, 1) - - InterfaceTestClass = interface_test_class_fixture() - i = InterfaceTestClass() - with self.assertRaises(System.NotImplementedException): - FunctionsTest.test_event(i, 2) - - DerivedEventTest = derived_event_test_class_fixture() - d = DerivedEventTest() - d.add_TestEvent(event_handler.handler) - self.assertEqual(FunctionsTest.test_event(d, 3), 3) - self.assertEqual(event_handler.value, 3) - self.assertEqual(len(d.event_handlers), 1) - - def test_isinstance(self): - a = [str(x) for x in range(0, 1000)] - b = [System.String(x) for x in a] - - for x in a: - self.assertFalse(isinstance(x, System.Object)) - self.assertFalse(isinstance(x, System.String)) - - for x in b: - self.assertTrue(isinstance(x, System.Object)) - self.assertTrue(isinstance(x, System.String)) - - -def test_suite(): - return unittest.makeSuite(SubClassTests) +@pytest.mark.skip(reason="FIXME: test randomly pass/fails") +def test_base_class(): + """Test base class managed type""" + ob = SubClassTest() + assert ob.foo() == "foo" + assert FunctionsTest.test_foo(ob) == "foo" + assert ob.bar("bar", 2) == "bar" + assert FunctionsTest.test_bar(ob, "bar", 2) == "bar" + assert ob.not_overriden() == "not_overriden" + assert list(ob.return_list()) == ["a", "b", "c"] + assert list(SubClassTest.test_list(ob)) == ["a", "b", "c"] + + +@pytest.mark.skip(reason="FIXME: test randomly pass/fails") +def test_interface(): + """Test python classes can derive from C# interfaces""" + InterfaceTestClass = interface_test_class_fixture() + ob = InterfaceTestClass() + assert ob.foo() == "InterfaceTestClass" + assert FunctionsTest.test_foo(ob) == "InterfaceTestClass" + assert ob.bar("bar", 2) == "bar/bar" + assert FunctionsTest.test_bar(ob, "bar", 2) == "bar/bar" + + x = FunctionsTest.pass_through(ob) + assert id(x) == id(ob) + + +@pytest.mark.skip(reason="FIXME: test randomly pass/fails") +def test_derived_class(): + """Test python class derived from managed type""" + DerivedClass = derived_class_fixture() + ob = DerivedClass() + assert ob.foo() == "DerivedClass" + assert ob.base_foo() == "foo" + assert ob.super_foo() == "foo" + assert FunctionsTest.test_foo(ob) == "DerivedClass" + assert ob.bar("bar", 2) == "bar_bar" + assert FunctionsTest.test_bar(ob, "bar", 2) == "bar_bar" + assert ob.not_overriden() == "not_overriden" + assert list(ob.return_list()) == ["A", "B", "C"] + assert list(SubClassTest.test_list(ob)) == ["A", "B", "C"] + + x = FunctionsTest.pass_through(ob) + assert id(x) == id(ob) + + +@pytest.mark.skip(reason="FIXME: test randomly pass/fails") +def test_create_instance(): + """Test derived instances can be created from managed code""" + DerivedClass = derived_class_fixture() + ob = FunctionsTest.create_instance(DerivedClass) + assert ob.foo() == "DerivedClass" + assert FunctionsTest.test_foo(ob) == "DerivedClass" + assert ob.bar("bar", 2) == "bar_bar" + assert FunctionsTest.test_bar(ob, "bar", 2) == "bar_bar" + assert ob.not_overriden() == "not_overriden" + + x = FunctionsTest.pass_through(ob) + assert id(x) == id(ob) + + InterfaceTestClass = interface_test_class_fixture() + ob2 = FunctionsTest.create_instance(InterfaceTestClass) + assert ob2.foo() == "InterfaceTestClass" + assert FunctionsTest.test_foo(ob2) == "InterfaceTestClass" + assert ob2.bar("bar", 2) == "bar/bar" + assert FunctionsTest.test_bar(ob2, "bar", 2) == "bar/bar" + + y = FunctionsTest.pass_through(ob2) + assert id(y) == id(ob2) + + +@pytest.mark.skip(reason="FIXME: test randomly pass/fails") +def test_events(): + class EventHandler(object): + def handler(self, x, args): + self.value = args.value + + event_handler = EventHandler() + + x = SubClassTest() + x.TestEvent += event_handler.handler + assert FunctionsTest.test_event(x, 1) == 1 + assert event_handler.value == 1 + + InterfaceTestClass = interface_test_class_fixture() + i = InterfaceTestClass() + with pytest.raises(System.NotImplementedException): + FunctionsTest.test_event(i, 2) + + DerivedEventTest = derived_event_test_class_fixture() + d = DerivedEventTest() + d.add_TestEvent(event_handler.handler) + assert FunctionsTest.test_event(d, 3) == 3 + assert event_handler.value == 3 + assert len(d.event_handlers) == 1 + + +def test_isinstance_check(): + a = [str(x) for x in range(0, 1000)] + b = [System.String(x) for x in a] + + for x in a: + assert not isinstance(x, System.Object) + assert not isinstance(x, System.String) + + for x in b: + assert isinstance(x, System.Object) + assert isinstance(x, System.String) diff --git a/src/tests/test_suite/__init__.py b/src/tests/test_suite/__init__.py deleted file mode 100644 index ecc1c858f..000000000 --- a/src/tests/test_suite/__init__.py +++ /dev/null @@ -1,15 +0,0 @@ -# -*- coding: utf-8 -*- - -import unittest - -from .test_callback import test_suite as callback_tests -from .test_import import test_suite as import_tests -from .test_recursive_types import test_suite as recursive_types_tests - - -def test_suite(): - suite = unittest.TestSuite() - suite.addTests((import_tests(),)) - suite.addTests((callback_tests(),)) - suite.addTests((recursive_types_tests(),)) - return suite diff --git a/src/tests/test_suite/test_callback.py b/src/tests/test_suite/test_callback.py deleted file mode 100644 index 2cb234442..000000000 --- a/src/tests/test_suite/test_callback.py +++ /dev/null @@ -1,33 +0,0 @@ -# -*- coding: utf-8 -*- - -import unittest - - -def simpleDefaultArg(arg='test'): - return arg - - -class CallbackTests(unittest.TestCase): - """Test that callbacks from C# into python work.""" - - def test_default_for_null(self): - """Test that C# can use null for an optional python argument""" - from Python.Test import CallbackTest - - test_instance = CallbackTest() - ret_val = test_instance.Call_simpleDefaultArg_WithNull(__name__) - python_ret_val = simpleDefaultArg(None) - self.assertEquals(ret_val, python_ret_val) - - def test_default_for_none(self): - """Test that C# can use no argument for an optional python argument""" - from Python.Test import CallbackTest - - test_instance = CallbackTest() - ret_val = test_instance.Call_simpleDefaultArg_WithEmptyArgs(__name__) - python_ret_val = simpleDefaultArg() - self.assertEquals(ret_val, python_ret_val) - - -def test_suite(): - return unittest.makeSuite(CallbackTests) diff --git a/src/tests/test_suite/test_import.py b/src/tests/test_suite/test_import.py deleted file mode 100644 index 9bae9ca5f..000000000 --- a/src/tests/test_suite/test_import.py +++ /dev/null @@ -1,18 +0,0 @@ -# -*- coding: utf-8 -*- - -import unittest - - -class ImportTests(unittest.TestCase): - """Test the import statement.""" - - def test_relative_missing_import(self): - """Test that a relative missing import doesn't crash. - Some modules use this to check if a package is installed. - Relative import in the site-packages folder""" - with self.assertRaises(ImportError): - from . import _missing_import - - -def test_suite(): - return unittest.makeSuite(ImportTests) diff --git a/src/tests/test_suite/test_recursive_types.py b/src/tests/test_suite/test_recursive_types.py deleted file mode 100644 index a213937a5..000000000 --- a/src/tests/test_suite/test_recursive_types.py +++ /dev/null @@ -1,19 +0,0 @@ -# -*- coding: utf-8 -*- - -import unittest - - -class RecursiveTypesTests(unittest.TestCase): - """Test if interop with recursive type inheritance works.""" - - def test_recursive_type_creation(self): - """Test that a recursive types don't crash with a - StackOverflowException""" - from Python.Test import RecursiveInheritance - - test_instance = RecursiveInheritance.SubClass() - test_instance.SomeMethod() - - -def test_suite(): - return unittest.makeSuite(RecursiveTypesTests) diff --git a/src/tests/test_sysargv.py b/src/tests/test_sysargv.py index eefb4d341..2649bf885 100644 --- a/src/tests/test_sysargv.py +++ b/src/tests/test_sysargv.py @@ -1,17 +1,12 @@ # -*- coding: utf-8 -*- -import unittest -import sys - -class SysArgvTests(unittest.TestCase): - """Test sys.argv state.""" +"""Test sys.argv state.""" - def test_sys_argv_state(self): - """Test sys.argv state doesn't change after clr import.""" - argv = sys.argv - import clr - self.assertTrue(argv == sys.argv) +import sys -def test_suite(): - return unittest.makeSuite(SysArgvTests) +def test_sys_argv_state(): + """Test sys.argv state doesn't change after clr import.""" + argv = sys.argv + import clr + assert argv == sys.argv diff --git a/src/tests/test_thread.py b/src/tests/test_thread.py index 623be60a0..c62c15939 100644 --- a/src/tests/test_thread.py +++ b/src/tests/test_thread.py @@ -1,62 +1,58 @@ # -*- coding: utf-8 -*- +"""Test CLR bridge threading and GIL handling.""" + import threading import time -import unittest - -from _compat import range, thread -from utils import dprint - -class ThreadTests(unittest.TestCase): - """Test CLR bridge threading and GIL handling.""" +from ._compat import range, thread +from .utils import dprint - def test_simple_callback_to_python(self): - """Test a call to managed code that then calls back into Python.""" - from Python.Test import ThreadTest - dprint("thread %s SimpleCallBack" % thread.get_ident()) - result = ThreadTest.CallEchoString("spam") - self.assertTrue(result == "spam") - dprint("thread %s SimpleCallBack ret" % thread.get_ident()) +def test_simple_callback_to_python(): + """Test a call to managed code that then calls back into Python.""" + from Python.Test import ThreadTest - def test_double_callback_to_python(self): - """Test a call to managed code that then calls back into Python - that then calls managed code that then calls Python again.""" - from Python.Test import ThreadTest + dprint("thread %s SimpleCallBack" % thread.get_ident()) + result = ThreadTest.CallEchoString("spam") + assert result == "spam" + dprint("thread %s SimpleCallBack ret" % thread.get_ident()) - dprint("thread %s DoubleCallBack" % thread.get_ident()) - result = ThreadTest.CallEchoString2("spam") - self.assertTrue(result == "spam") - dprint("thread %s DoubleCallBack ret" % thread.get_ident()) - def test_python_thread_calls_to_clr(self): - """Test calls by Python-spawned threads into managed code.""" - # This test is very likely to hang if something is wrong ;) - import System +def test_double_callback_to_python(): + """Test a call to managed code that then calls back into Python + that then calls managed code that then calls Python again.""" + from Python.Test import ThreadTest - done = [] + dprint("thread %s DoubleCallBack" % thread.get_ident()) + result = ThreadTest.CallEchoString2("spam") + assert result == "spam" + dprint("thread %s DoubleCallBack ret" % thread.get_ident()) - def run_thread(): - for i in range(10): - time.sleep(0.1) - dprint("thread %s %d" % (thread.get_ident(), i)) - mstr = System.String("thread %s %d" % (thread.get_ident(), i)) - dprint(mstr.ToString()) - done.append(None) - dprint("thread %s %d done" % (thread.get_ident(), i)) - def start_threads(count): - for _ in range(count): - thread_ = threading.Thread(target=run_thread) - thread_.start() +def test_python_thread_calls_to_clr(): + """Test calls by Python-spawned threads into managed code.""" + # This test is very likely to hang if something is wrong ;) + import System - start_threads(5) + done = [] - while len(done) < 50: - dprint(len(done)) + def run_thread(): + for i in range(10): time.sleep(0.1) - - -def test_suite(): - return unittest.makeSuite(ThreadTests) + dprint("thread %s %d" % (thread.get_ident(), i)) + mstr = System.String("thread %s %d" % (thread.get_ident(), i)) + dprint(mstr.ToString()) + done.append(None) + dprint("thread %s %d done" % (thread.get_ident(), i)) + + def start_threads(count): + for _ in range(count): + thread_ = threading.Thread(target=run_thread) + thread_.start() + + start_threads(5) + + while len(done) < 50: + dprint(len(done)) + time.sleep(0.1) diff --git a/src/tests/utils.py b/src/tests/utils.py index 6729d7b30..cacb015ec 100644 --- a/src/tests/utils.py +++ b/src/tests/utils.py @@ -7,7 +7,7 @@ from __future__ import print_function -from _compat import PY2, PY3 +from ._compat import PY2, PY3 def dprint(msg): From 104ef716fc6eea46a5830e1e1317ad5c8a336273 Mon Sep 17 00:00:00 2001 From: Victor Uriarte Date: Mon, 23 Jan 2017 05:42:26 -0700 Subject: [PATCH 3/4] Add setup.cfg Control settings for some add-ons like pytest --- setup.cfg | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 setup.cfg diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 000000000..4930652bb --- /dev/null +++ b/setup.cfg @@ -0,0 +1,7 @@ +[tool:pytest] +xfail_strict = True + +[check-manifest] +ignore = + .github + .github/* From 76aa7311c442adeac1f84300b6d3e41fc59c4bf6 Mon Sep 17 00:00:00 2001 From: Victor Uriarte Date: Sat, 28 Jan 2017 22:23:46 -0700 Subject: [PATCH 4/4] Simpler tox --- tox.ini | 26 ++++++-------------------- 1 file changed, 6 insertions(+), 20 deletions(-) diff --git a/tox.ini b/tox.ini index 1cc666ae3..ef15d5099 100644 --- a/tox.ini +++ b/tox.ini @@ -1,5 +1,4 @@ [tox] -skipsdist=True skip_missing_interpreters=True envlist = py27 @@ -7,32 +6,19 @@ envlist = py34 py35 py36 + py37 check [testenv] -recreate=True -basepython = - py27: {env:TOXPYTHON:python2.7} - py33: {env:TOXPYTHON:python3.3} - py34: {env:TOXPYTHON:python3.4} - py35: {env:TOXPYTHON:python3.5} - py36: {env:TOXPYTHON:python3.6} - check: python3.5 -setenv = - PYTHONUNBUFFERED=True - DISTUTILS_DEBUG= -passenv = - * +deps = + pytest commands = - python --version - python -c "import struct; print('ARCH: %d' % (struct.calcsize('P') * 8))" - python -c "import ctypes; print('UCS%d' % ctypes.sizeof(ctypes.c_wchar))" - python setup.py bdist_wheel - pip install --no-index --find-links=dist/ pythonnet - {posargs:python src\tests\runtests.py} + {posargs:py.test} [testenv:check] ignore_errors=True +skip_install=True +basepython=python3.5 deps = check-manifest flake8