diff --git a/.travis.yml b/.travis.yml index 418e50cfc..1b5806d59 100644 --- a/.travis.yml +++ b/.travis.yml @@ -25,7 +25,7 @@ addons: - nunit-console install: - - pip install pycparser coverage codecov six + - pip install pycparser coverage codecov - coverage run setup.py build_ext --inplace script: diff --git a/appveyor.yml b/appveyor.yml index a8827aee7..2795a94f8 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -46,7 +46,7 @@ init: install: # install for wheels & coverage - - pip install --upgrade pip wheel coverage codecov six + - pip install --upgrade pip wheel coverage codecov # Install OpenCover. Can't put on packages.config; not Linux/Mono compatible - .\tools\nuget\nuget.exe install OpenCover -OutputDirectory packages diff --git a/src/testing/arraytest.cs b/src/testing/arraytest.cs index b9891cac8..591b5b1c4 100644 --- a/src/testing/arraytest.cs +++ b/src/testing/arraytest.cs @@ -1,6 +1,3 @@ -using System; -using System.Collections; - namespace Python.Test { //======================================================================== @@ -318,4 +315,4 @@ public static Spam[][] EchoRangeAA(Spam[][] items) return items; } } -} \ No newline at end of file +} diff --git a/src/testing/callbacktest.cs b/src/testing/callbacktest.cs index f95cbc602..33e240531 100644 --- a/src/testing/callbacktest.cs +++ b/src/testing/callbacktest.cs @@ -1,7 +1,4 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; +using Python.Runtime; namespace Python.Test { @@ -13,17 +10,18 @@ public class CallbackTest { public string Call_simpleDefaultArg_WithNull(string moduleName) { - using (Runtime.Py.GIL()) + using (Py.GIL()) { - dynamic module = Runtime.Py.Import(moduleName); + dynamic module = Py.Import(moduleName); return module.simpleDefaultArg(null); } } + public string Call_simpleDefaultArg_WithEmptyArgs(string moduleName) { - using (Runtime.Py.GIL()) + using (Py.GIL()) { - dynamic module = Runtime.Py.Import(moduleName); + dynamic module = Py.Import(moduleName); return module.simpleDefaultArg(); } } @@ -31,14 +29,14 @@ public string Call_simpleDefaultArg_WithEmptyArgs(string moduleName) //========================================================================== // Tests calling from Python into C# and back into Python using a PyObject. - // SelfCallbackTest should be inherited by a Python class. + // SelfCallbackTest should be inherited by a Python class. // Used in test_class.py / testCallback //========================================================================== public class SelfCallbackTest { - public void Callback(Runtime.PyObject self) + public void Callback(PyObject self) { - using (Runtime.Py.GIL()) + using (Py.GIL()) ((dynamic)self).PyCallback(self); } } diff --git a/src/testing/classtest.cs b/src/testing/classtest.cs index 5f3b0d7ed..ab0cad7ad 100644 --- a/src/testing/classtest.cs +++ b/src/testing/classtest.cs @@ -1,4 +1,3 @@ -using System; using System.Collections; namespace Python.Test @@ -61,4 +60,4 @@ public ClassCtorTest2(string v) internal class InternalClass { } -} \ No newline at end of file +} diff --git a/src/testing/constructortests.cs b/src/testing/constructortests.cs index cffcee888..4d3cc5710 100644 --- a/src/testing/constructortests.cs +++ b/src/testing/constructortests.cs @@ -1,5 +1,4 @@ using System; -using System.Collections; using System.IO; namespace Python.Test @@ -50,4 +49,4 @@ public SubclassConstructorTest(Exception v) this.value = v; } } -} \ No newline at end of file +} diff --git a/src/testing/conversiontest.cs b/src/testing/conversiontest.cs index e4d4762e6..5686a1943 100644 --- a/src/testing/conversiontest.cs +++ b/src/testing/conversiontest.cs @@ -1,6 +1,3 @@ -using System; - - namespace Python.Test { //======================================================================== @@ -58,4 +55,4 @@ public string GetValue() return value; } } -} \ No newline at end of file +} diff --git a/src/testing/delegatetest.cs b/src/testing/delegatetest.cs index d13750c49..94169f650 100644 --- a/src/testing/delegatetest.cs +++ b/src/testing/delegatetest.cs @@ -1,5 +1,3 @@ -using System; - namespace Python.Test { //======================================================================== @@ -60,4 +58,4 @@ public bool CallBoolDelegate(BoolDelegate d) return d(); } } -} \ No newline at end of file +} diff --git a/src/testing/doctest.cs b/src/testing/doctest.cs index 156248029..a0f60b2e1 100644 --- a/src/testing/doctest.cs +++ b/src/testing/doctest.cs @@ -8,19 +8,19 @@ namespace Python.Test // Classes with a constructor have their docstring set to the ctor signature. // Test if a class has an explicit doc string it gets set correctly. - [DocStringAttribute("DocWithCtorTest Class")] + [DocString("DocWithCtorTest Class")] public class DocWithCtorTest { public DocWithCtorTest() { } - [DocStringAttribute("DocWithCtorTest TestMethod")] + [DocString("DocWithCtorTest TestMethod")] public void TestMethod() { } - [DocStringAttribute("DocWithCtorTest StaticTestMethod")] + [DocString("DocWithCtorTest StaticTestMethod")] public static void StaticTestMethod() { } @@ -41,17 +41,17 @@ public static void StaticTestMethod(double a, int b) } } - [DocStringAttribute("DocWithoutCtorTest Class")] + [DocString("DocWithoutCtorTest Class")] public class DocWithoutCtorTest { - [DocStringAttribute("DocWithoutCtorTest TestMethod")] + [DocString("DocWithoutCtorTest TestMethod")] public void TestMethod() { } - [DocStringAttribute("DocWithoutCtorTest StaticTestMethod")] + [DocString("DocWithoutCtorTest StaticTestMethod")] public static void StaticTestMethod() { } } -} \ No newline at end of file +} diff --git a/src/testing/enumtest.cs b/src/testing/enumtest.cs index 162771980..0d0d56190 100644 --- a/src/testing/enumtest.cs +++ b/src/testing/enumtest.cs @@ -86,7 +86,7 @@ public enum ULongEnum : ulong Five } - [FlagsAttribute] + [Flags] public enum FlagsEnum { Zero, @@ -96,4 +96,4 @@ public enum FlagsEnum Four, Five } -} \ No newline at end of file +} diff --git a/src/testing/eventtest.cs b/src/testing/eventtest.cs index 544e0f259..d39557c4d 100644 --- a/src/testing/eventtest.cs +++ b/src/testing/eventtest.cs @@ -6,26 +6,26 @@ namespace Python.Test // Supports CLR event unit tests. //======================================================================== - public delegate void TestEventHandler(object sender, TestEventArgs e); + public delegate void EventHandlerTest(object sender, EventArgsTest e); public class EventTest { - public static event TestEventHandler PublicStaticEvent; + public static event EventHandlerTest PublicStaticEvent; - protected static event TestEventHandler ProtectedStaticEvent; + protected static event EventHandlerTest ProtectedStaticEvent; - internal static event TestEventHandler InternalStaticEvent; + internal static event EventHandlerTest InternalStaticEvent; - private static event TestEventHandler PrivateStaticEvent; + private static event EventHandlerTest PrivateStaticEvent; - public event TestEventHandler PublicEvent; + public event EventHandlerTest PublicEvent; - protected event TestEventHandler ProtectedEvent; + protected event EventHandlerTest ProtectedEvent; - internal event TestEventHandler InternalEvent; + internal event EventHandlerTest InternalEvent; - private event TestEventHandler PrivateEvent; + private event EventHandlerTest PrivateEvent; public static int s_value; @@ -42,7 +42,7 @@ static EventTest() } - public void OnPublicEvent(TestEventArgs e) + public void OnPublicEvent(EventArgsTest e) { if (PublicEvent != null) { @@ -51,7 +51,7 @@ public void OnPublicEvent(TestEventArgs e) } - public void OnProtectedEvent(TestEventArgs e) + public void OnProtectedEvent(EventArgsTest e) { if (ProtectedEvent != null) { @@ -60,7 +60,7 @@ public void OnProtectedEvent(TestEventArgs e) } - public static void OnPublicStaticEvent(TestEventArgs e) + public static void OnPublicStaticEvent(EventArgsTest e) { if (PublicStaticEvent != null) { @@ -69,7 +69,7 @@ public static void OnPublicStaticEvent(TestEventArgs e) } - protected static void OnProtectedStaticEvent(TestEventArgs e) + protected static void OnProtectedStaticEvent(EventArgsTest e) { if (ProtectedStaticEvent != null) { @@ -78,12 +78,12 @@ protected static void OnProtectedStaticEvent(TestEventArgs e) } - public void GenericHandler(object sender, TestEventArgs e) + public void GenericHandler(object sender, EventArgsTest e) { this.value = e.value; } - public static void StaticHandler(object sender, TestEventArgs e) + public static void StaticHandler(object sender, EventArgsTest e) { s_value = e.value; } @@ -92,7 +92,7 @@ public static void ShutUpCompiler() { // Quiet compiler warnings. EventTest e = new EventTest(); - TestEventHandler f = new TestEventHandler(e.GenericHandler); + EventHandlerTest f = new EventHandlerTest(e.GenericHandler); ProtectedStaticEvent += f; InternalStaticEvent += f; PrivateStaticEvent += f; @@ -103,13 +103,13 @@ public static void ShutUpCompiler() } - public class TestEventArgs : EventArgs + public class EventArgsTest : EventArgs { public int value; - public TestEventArgs(int v) + public EventArgsTest(int v) { this.value = v; } } -} \ No newline at end of file +} diff --git a/src/testing/exceptiontest.cs b/src/testing/exceptiontest.cs index 414c25d82..ae5fc86c0 100644 --- a/src/testing/exceptiontest.cs +++ b/src/testing/exceptiontest.cs @@ -99,4 +99,4 @@ public string GetExtraInfo() return extra; } } -} \ No newline at end of file +} diff --git a/src/testing/fieldtest.cs b/src/testing/fieldtest.cs index 5860bdafb..4d41cf084 100644 --- a/src/testing/fieldtest.cs +++ b/src/testing/fieldtest.cs @@ -1,6 +1,3 @@ -using System; - - namespace Python.Test { //======================================================================== @@ -54,4 +51,4 @@ public void Shutup() public object ObjectField; public ISpam SpamField; } -} \ No newline at end of file +} diff --git a/src/testing/generictest.cs b/src/testing/generictest.cs index 3019c1eb6..b38f5e8e5 100644 --- a/src/testing/generictest.cs +++ b/src/testing/generictest.cs @@ -1,6 +1,3 @@ -using System; -using System.Collections; - namespace Python.Test { //======================================================================== @@ -131,4 +128,4 @@ public static string Overloaded(int arg1, int arg2, string arg3) return arg3; } } -} \ No newline at end of file +} diff --git a/src/testing/globaltest.cs b/src/testing/globaltest.cs index 887668d96..2d6d56cda 100644 --- a/src/testing/globaltest.cs +++ b/src/testing/globaltest.cs @@ -1,9 +1,7 @@ -using System; - //======================================================================== // Supports units tests for access to types without a namespace. //======================================================================== public class NoNamespaceType { -} \ No newline at end of file +} diff --git a/src/testing/indexertest.cs b/src/testing/indexertest.cs index eb0381777..f1dcbda0b 100644 --- a/src/testing/indexertest.cs +++ b/src/testing/indexertest.cs @@ -1,4 +1,3 @@ -using System; using System.Collections; namespace Python.Test @@ -415,4 +414,4 @@ public MultiDefaultKeyIndexerTest() : base() } } } -} \ No newline at end of file +} diff --git a/src/testing/interfacetest.cs b/src/testing/interfacetest.cs index b35ca81a8..4c4056d68 100644 --- a/src/testing/interfacetest.cs +++ b/src/testing/interfacetest.cs @@ -1,5 +1,3 @@ -using System; - namespace Python.Test { //======================================================================== @@ -62,4 +60,4 @@ private interface IPrivate { } } -} \ No newline at end of file +} diff --git a/src/testing/methodtest.cs b/src/testing/methodtest.cs index 675b1577c..65e39cf69 100644 --- a/src/testing/methodtest.cs +++ b/src/testing/methodtest.cs @@ -1,6 +1,5 @@ using System; using System.IO; -using System.Collections.Generic; namespace Python.Test { @@ -156,13 +155,13 @@ public static bool TestValueRefParams(string s, ref int i1) public static bool TestObjectOutParams(object o, out object o1) { - o1 = new System.Exception("test"); + o1 = new Exception("test"); return true; } public static bool TestObjectRefParams(object o, ref object o1) { - o1 = new System.Exception("test"); + o1 = new Exception("test"); return true; } @@ -630,4 +629,4 @@ public string PublicMethod(string echo) return echo; } } -} \ No newline at end of file +} diff --git a/src/testing/moduletest.cs b/src/testing/moduletest.cs index ca75a1313..2d5734a11 100644 --- a/src/testing/moduletest.cs +++ b/src/testing/moduletest.cs @@ -1,16 +1,20 @@ using System; using System.Threading; -namespace Python.Test { - public class ModuleTest { +namespace Python.Test +{ + public class ModuleTest + { private static Thread _thread; public static void RunThreads() { - _thread = new Thread(() => { + _thread = new Thread(() => + { var appdomain = AppDomain.CurrentDomain; var assemblies = appdomain.GetAssemblies(); - foreach (var assembly in assemblies) { + foreach (var assembly in assemblies) + { assembly.GetTypes(); } }); diff --git a/src/testing/propertytest.cs b/src/testing/propertytest.cs index f01c02e0b..b70e9487a 100644 --- a/src/testing/propertytest.cs +++ b/src/testing/propertytest.cs @@ -1,5 +1,3 @@ -using System; - namespace Python.Test { //======================================================================== @@ -84,4 +82,4 @@ public ShortEnum EnumProperty set { _enum_property = value; } } } -} \ No newline at end of file +} diff --git a/src/testing/subclasstest.cs b/src/testing/subclasstest.cs index 2b61be254..9ee105aef 100644 --- a/src/testing/subclasstest.cs +++ b/src/testing/subclasstest.cs @@ -1,7 +1,5 @@ using System; using System.Collections.Generic; -using System.Linq; -using System.Text; namespace Python.Test { @@ -14,14 +12,14 @@ public interface IInterfaceTest string bar(string s, int i); // test events on interfaces - event TestEventHandler TestEvent; + event EventHandlerTest TestEvent; void OnTestEvent(int value); } public class SubClassTest : IInterfaceTest { - public event TestEventHandler TestEvent; + public event EventHandlerTest TestEvent; public SubClassTest() { @@ -60,7 +58,7 @@ public static IList test_list(SubClassTest x) public virtual void OnTestEvent(int value) { if (null != TestEvent) - TestEvent(this, new TestEventArgs(value)); + TestEvent(this, new EventArgsTest(value)); } } @@ -70,12 +68,11 @@ public class SubClass : RecursiveInheritance { public void SomeMethod() { - } } } - public class TestFunctions + public class FunctionsTest { public static string test_foo(IInterfaceTest x) { diff --git a/src/testing/threadtest.cs b/src/testing/threadtest.cs index 0a4f46ccc..0cb2abe57 100644 --- a/src/testing/threadtest.cs +++ b/src/testing/threadtest.cs @@ -1,5 +1,4 @@ using System; -using System.Collections; using Python.Runtime; namespace Python.Test @@ -77,4 +76,4 @@ public static string CallEchoString2(string arg) } } } -} \ No newline at end of file +} diff --git a/src/tests/PyImportTest/__init__.py b/src/tests/PyImportTest/__init__.py index e69de29bb..40a96afc6 100644 --- a/src/tests/PyImportTest/__init__.py +++ b/src/tests/PyImportTest/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/tests/PyImportTest/test/__init__.py b/src/tests/PyImportTest/test/__init__.py index e69de29bb..40a96afc6 100644 --- a/src/tests/PyImportTest/test/__init__.py +++ b/src/tests/PyImportTest/test/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/tests/PyImportTest/test/one.py b/src/tests/PyImportTest/test/one.py index e69de29bb..40a96afc6 100644 --- a/src/tests/PyImportTest/test/one.py +++ b/src/tests/PyImportTest/test/one.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/tests/__init__.py b/src/tests/__init__.py new file mode 100644 index 000000000..40a96afc6 --- /dev/null +++ b/src/tests/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/tests/_compat.py b/src/tests/_compat.py new file mode 100644 index 000000000..3a9d48c7e --- /dev/null +++ b/src/tests/_compat.py @@ -0,0 +1,65 @@ +# -*- coding: utf-8 -*- + +"""Python 2.7, 3.3+ compatibility module. + +Using Python 3 syntax to encourage upgrade unless otherwise noted. +""" + +import operator +import sys +import types + +PY2 = sys.version_info[0] == 2 +PY3 = sys.version_info[0] == 3 + +if PY3: + import _thread as thread # Using PY2 name + import pickle + from collections import UserList + + indexbytes = operator.getitem + input = input + + string_types = str, + binary_type = bytes + text_type = str + + DictProxyType = type(object.__dict__) + ClassType = type + + # No PY3 equivalents, use PY2 name + long = int + unichr = chr + unicode = str + + # from nowhere import Nothing + cmp = lambda a, b: (a > b) - (a < b) # No Py3 equivalent + map = map + range = range + zip = zip + +elif PY2: + import thread # Using PY2 name + import cPickle as pickle + from UserList import UserList + + indexbytes = lambda buf, i: ord(buf[i]) + input = raw_input + + string_types = str, unicode + bytes_type = str + text_type = unicode + + DictProxyType = types.DictProxyType + ClassType = types.ClassType + + # No PY3 equivalents, use PY2 name + long = long + unichr = unichr + unicode = unicode + + from itertools import izip, imap + cmp = cmp + map = imap + range = xrange + zip = izip diff --git a/src/tests/leaktest.py b/src/tests/leaktest.py index 383da87c8..646cb512e 100644 --- a/src/tests/leaktest.py +++ b/src/tests/leaktest.py @@ -1,9 +1,22 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# FIXME: TypeError: 'EventBinding' object is not callable + from __future__ import print_function -import System + +import clr import gc +import sys + +import System + +from _compat import range +from utils import (CallableHandler, ClassMethodHandler, GenericHandler, + HelloClass, StaticMethodHandler, VarCallableHandler, + VariableArgsHandler, hello_func) -class LeakTest: +class LeakTest(object): """A leak-check test for the objects implemented in the managed runtime. For each kind of object tested, memory should reach a particular level after warming up and stay essentially the @@ -30,10 +43,10 @@ def end_test(self): end = System.Environment.WorkingSet diff = end - start if diff > 0: - diff = '+%d' % diff + diff = '+{0}'.format(diff) else: - diff = '%d' % diff - print(" start: %d end: %d diff: %s" % (start, end, diff)) + diff = '{0}'.format(diff) + print(" start: {0} end: {1} diff: {2}".format(start, end, diff)) print("") def run(self): @@ -44,17 +57,16 @@ def run(self): self.testDelegates() def report(self): - import sys, gc gc.collect() dicttype = type({}) for item in gc.get_objects(): if type(item) != dicttype: print(item, sys.getrefcount(item)) - def testModules(self): + def test_modules(self): self.notify("Running module leak check...") - for i in xrange(self.count): + for i in range(self.count): if i == 10: self.start_test() @@ -66,14 +78,13 @@ def testModules(self): self.end_test() - def testClasses(self): + def test_classes(self): from System.Collections import Hashtable from Python.Test import StringDelegate - from System import Int32 self.notify("Running class leak check...") - for i in xrange(self.count): + for i in range(self.count): if i == 10: self.start_test() @@ -82,21 +93,21 @@ def testClasses(self): del x # Value type - x = Int32(99) + x = System.Int32(99) del x # Delegate type - x = StringDelegate(hello) + x = StringDelegate(hello_func) del x self.end_test() - def testEnumerations(self): - from Python import Test + def test_enumerations(self): + import Python.Test as Test self.notify("Running enum leak check...") - for i in xrange(self.count): + for i in range(self.count): if i == 10: self.start_test() @@ -126,12 +137,12 @@ def testEnumerations(self): self.end_test() - def testEvents(self): - from Python.Test import EventTest, TestEventArgs + def test_events(self): + from Python.Test import EventTest, EventArgsTest self.notify("Running event leak check...") - for i in xrange(self.count): + for i in range(self.count): if i == 10: self.start_test() @@ -140,28 +151,28 @@ def testEvents(self): # Instance method event handler handler = GenericHandler() testob.PublicEvent += handler.handler - testob.PublicEvent(testob, TestEventArgs(10)) + testob.PublicEvent(testob, EventArgsTest(10)) testob.PublicEvent -= handler.handler del handler # Vararg method event handler handler = VariableArgsHandler() testob.PublicEvent += handler.handler - testob.PublicEvent(testob, TestEventArgs(10)) + testob.PublicEvent(testob, EventArgsTest(10)) testob.PublicEvent -= handler.handler del handler # Callable object event handler handler = CallableHandler() testob.PublicEvent += handler - testob.PublicEvent(testob, TestEventArgs(10)) + testob.PublicEvent(testob, EventArgsTest(10)) testob.PublicEvent -= handler del handler # Callable vararg event handler handler = VarCallableHandler() testob.PublicEvent += handler - testob.PublicEvent(testob, TestEventArgs(10)) + testob.PublicEvent(testob, EventArgsTest(10)) testob.PublicEvent -= handler del handler @@ -169,7 +180,7 @@ def testEvents(self): handler = StaticMethodHandler() StaticMethodHandler.value = None testob.PublicEvent += handler.handler - testob.PublicEvent(testob, TestEventArgs(10)) + testob.PublicEvent(testob, EventArgsTest(10)) testob.PublicEvent -= handler.handler del handler @@ -177,46 +188,45 @@ def testEvents(self): handler = ClassMethodHandler() ClassMethodHandler.value = None testob.PublicEvent += handler.handler - testob.PublicEvent(testob, TestEventArgs(10)) + testob.PublicEvent(testob, EventArgsTest(10)) testob.PublicEvent -= handler.handler del handler # Managed instance event handler testob.PublicEvent += testob.GenericHandler - testob.PublicEvent(testob, TestEventArgs(10)) + testob.PublicEvent(testob, EventArgsTest(10)) testob.PublicEvent -= testob.GenericHandler # Static managed event handler testob.PublicEvent += EventTest.StaticHandler - testob.PublicEvent(testob, TestEventArgs(10)) + testob.PublicEvent(testob, EventArgsTest(10)) testob.PublicEvent -= EventTest.StaticHandler # Function event handler - dict = {'value': None} + dict_ = {'value': None} - def handler(sender, args, dict=dict): - dict['value'] = args.value + def handler(sender, args, dict_=dict_): + dict_['value'] = args.value testob.PublicEvent += handler - testob.PublicEvent(testob, TestEventArgs(10)) + testob.PublicEvent(testob, EventArgsTest(10)) testob.PublicEvent -= handler del handler self.end_test() - def testDelegates(self): + def test_delegates(self): from Python.Test import DelegateTest, StringDelegate - import System self.notify("Running delegate leak check...") - for i in xrange(self.count): + for i in range(self.count): if i == 10: self.start_test() # Delegate from function testob = DelegateTest() - d = StringDelegate(hello) + d = StringDelegate(hello_func) testob.CallStringDelegate(d) testob.stringDelegate = d testob.stringDelegate() @@ -225,7 +235,7 @@ def testDelegates(self): del d # Delegate from instance method - inst = Hello() + inst = HelloClass() testob = DelegateTest() d = StringDelegate(inst.hello) testob.CallStringDelegate(d) @@ -238,7 +248,7 @@ def testDelegates(self): # Delegate from static method testob = DelegateTest() - d = StringDelegate(Hello.s_hello) + d = StringDelegate(HelloClass.s_hello) testob.CallStringDelegate(d) testob.stringDelegate = d testob.stringDelegate() @@ -248,7 +258,7 @@ def testDelegates(self): # Delegate from class method testob = DelegateTest() - d = StringDelegate(Hello.c_hello) + d = StringDelegate(HelloClass.c_hello) testob.CallStringDelegate(d) testob.stringDelegate = d testob.stringDelegate() @@ -257,7 +267,7 @@ def testDelegates(self): del d # Delegate from callable object - inst = Hello() + inst = HelloClass() testob = DelegateTest() d = StringDelegate(inst) testob.CallStringDelegate(d) @@ -290,7 +300,7 @@ def testDelegates(self): # Nested delegates testob = DelegateTest() - d1 = StringDelegate(hello) + d1 = StringDelegate(hello_func) d2 = StringDelegate(d1) testob.CallStringDelegate(d2) testob.stringDelegate = d2 @@ -302,8 +312,8 @@ def testDelegates(self): # Multicast delegates testob = DelegateTest() - d1 = StringDelegate(hello) - d2 = StringDelegate(hello) + d1 = StringDelegate(hello_func) + d2 = StringDelegate(hello_func) md = System.Delegate.Combine(d1, d2) testob.CallStringDelegate(md) testob.stringDelegate = md @@ -317,92 +327,6 @@ def testDelegates(self): self.end_test() -class GenericHandler: - """A generic handler to test event callbacks.""" - - def __init__(self): - self.value = None - - def handler(self, sender, args): - self.value = args.value - - -class VariableArgsHandler: - """A variable args handler to test event callbacks.""" - - def __init__(self): - self.value = None - - def handler(self, *args): - ob, eventargs = args - self.value = eventargs.value - - -class CallableHandler: - """A callable handler to test event callbacks.""" - - def __init__(self): - self.value = None - - def __call__(self, sender, args): - self.value = args.value - - -class VarCallableHandler: - """A variable args callable handler to test event callbacks.""" - - def __init__(self): - self.value = None - - def __call__(self, *args): - ob, eventargs = args - self.value = eventargs.value - - -class StaticMethodHandler(object): - """A static method handler to test event callbacks.""" - - value = None - - def handler(sender, args): - StaticMethodHandler.value = args.value - - handler = staticmethod(handler) - - -class ClassMethodHandler(object): - """A class method handler to test event callbacks.""" - - value = None - - def handler(cls, sender, args): - cls.value = args.value - - handler = classmethod(handler) - - -class Hello: - def hello(self): - return "hello" - - def __call__(self): - return "hello" - - def s_hello(): - return "hello" - - s_hello = staticmethod(s_hello) - - def c_hello(cls): - return "hello" - - c_hello = classmethod(c_hello) - - -def hello(): - return "hello" - - if __name__ == '__main__': test = LeakTest() test.run() diff --git a/src/tests/profile.py b/src/tests/profile.py index 6117b9616..f6576ddce 100644 --- a/src/tests/profile.py +++ b/src/tests/profile.py @@ -1,26 +1,37 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# FIXME: FAIL: testImplicitAssemblyLoad AssertionError: 0 != 1 + """Run all of the unit tests for this package over and over, - in order to provide for better profiling.""" + in order to provide for better profiling. +""" + from __future__ import print_function +import gc +import os +import sys +import time -def main(): - import sys, os, gc, time +import runtests +from _compat import range + +def main(): dirname = os.path.split(__file__) sys.path.append(dirname) - import runtests gc.set_debug(gc.DEBUG_LEAK) start = time.clock() for i in range(50): - print('iteration: %d' % i) + print('iteration: {0:d}'.format(i)) runtests.main() stop = time.clock() took = str(stop - start) - print('Total Time: %s' % took) + print('Total Time: {0}'.format(took)) for item in gc.get_objects(): print(item, sys.getrefcount(item)) @@ -28,4 +39,3 @@ def main(): if __name__ == '__main__': main() - sys.exit(0) diff --git a/src/tests/runtests.py b/src/tests/runtests.py index 660d3442d..9b77f99dd 100644 --- a/src/tests/runtests.py +++ b/src/tests/runtests.py @@ -1,11 +1,15 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + """Run all of the unit tests for this package.""" +from __future__ import print_function + import os import sys import unittest -import warnfilter -warnfilter.addClrWarnfilter() +from _compat import input try: import System @@ -13,17 +17,23 @@ print("Load clr import hook") import clr + clr.AddReference("Python.Test") + clr.AddReference("System.Collections") + clr.AddReference("System.Data") + clr.AddReference("System.Management") + test_modules = ( - 'test_module', # Passes on its own, but not here if + # 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', @@ -35,20 +45,27 @@ 'test_indexer', 'test_delegate', 'test_array', - 'test_thread' + 'test_thread', + 'test_docstring', + + # FIXME: Has tests that are being skipped. + 'test_engine', + + # FIXME: Has tests that are being skipped. + 'test_subclass', ) -def removePyc(): +def remove_pyc(): path = os.path.dirname(os.path.abspath(__file__)) for name in test_modules: - pyc = os.path.join(path, "%s.pyc" % name) + pyc = os.path.join(path, "{0}.pyc".format(name)) if os.path.isfile(pyc): os.unlink(pyc) def main(verbosity=1): - removePyc() + remove_pyc() suite = unittest.TestSuite() @@ -62,7 +79,7 @@ def main(verbosity=1): if __name__ == '__main__': - main(1) + main() if '--pause' in sys.argv: print("Press enter to continue") - raw_input() + input() diff --git a/src/tests/stress.py b/src/tests/stress.py index dba74a6df..2ffe06958 100644 --- a/src/tests/stress.py +++ b/src/tests/stress.py @@ -1,15 +1,27 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# FIXME: FAIL: testImplicitAssemblyLoad AssertionError: 0 != 1 + """ Run all of the unit tests for this package multiple times in a highly -multithreaded way to stress the system. This makes it possible to look +multi-threaded way to stress the system. This makes it possible to look for memory leaks and threading issues and provides a good target for a profiler to accumulate better data. """ + from __future__ import print_function -import sys, os, gc, time, threading, thread +import gc +import os +import sys +import threading +import time +from _compat import range, thread +from utils import dprint -class StressTest: + +class StressTest(object): def __init__(self): self.dirname = os.path.split(__file__)[0] sys.path.append(self.dirname) @@ -18,53 +30,48 @@ def __init__(self): self.module = runtests self.done = [] - def dprint(self, msg): - # Debugging helper to trace thread-related tests. - if 1: print(msg) - - def markStart(self): + def mark_start(self): self._start = time.clock() - def markFinish(self): + def mark_finish(self): self._finish = time.clock() def elapsed(self): return self._finish - self._start - def printGCReport(self): + def print_gc_report(self): for item in gc.get_objects(): print(item, sys.getrefcount(item)) - def runThread(self, iterations): + def run_thread(self, iterations): thread_id = thread.get_ident() - self.dprint("thread %s starting..." % thread_id) + dprint("thread {0} starting...".format(thread_id)) time.sleep(0.1) for i in range(iterations): - self.dprint("thread %s iter %d start" % (thread_id, i)) + dprint("thread {0} iter {1} start".format(thread_id, i)) self.module.main() - self.dprint("thread %s iter %d end" % (thread_id, i)) + dprint("thread {0} iter {1} end".format(thread_id, i)) self.done.append(None) - self.dprint("thread %s done" % thread_id) + dprint("thread {0} done".format(thread_id)) - def stressTest(self, iterations=1, threads=1): + def stress_test(self, iterations=1, threads=1): args = (iterations,) - self.markStart() - for i in range(threads): - thread = threading.Thread(target=self.runThread, args=args) + self.mark_start() + for _ in range(threads): + thread = threading.Thread(target=self.run_thread, args=args) thread.start() while len(self.done) < (iterations * threads): - self.dprint(len(self.done)) + dprint(len(self.done)) time.sleep(0.1) - self.markFinish() + self.mark_finish() took = self.elapsed() - self.printGCReport() + self.print_gc_report() def main(): test = StressTest() - test.stressTest(2, 10) + test.stress_test(2, 10) if __name__ == '__main__': main() - sys.exit(0) diff --git a/src/tests/stresstest.py b/src/tests/stresstest.py index bdb7c3e70..947959239 100644 --- a/src/tests/stresstest.py +++ b/src/tests/stresstest.py @@ -1,36 +1,57 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# FIXME: FAIL: testImplicitAssemblyLoad AssertionError: 0 != 1 + """Basic stress test.""" +from __future__ import print_function + +import gc +import time +import unittest +# import pdb + +from _compat import range + +try: + import System +except ImportError: + print("Load clr import hook") + import clr + clr.AddReference("Python.Test") + clr.AddReference("System.Collections") + clr.AddReference("System.Data") + clr.AddReference("System.Management") + def main(): - import time start = time.clock() for i in range(2000): print(i) for name in ( - 'test_module', - 'test_conversion', - # 'test_class', - 'test_interface', - 'test_enum', - 'test_field', - 'test_property', - 'test_indexer', - 'test_event', - 'test_method', - # 'test_delegate', - 'test_array', + 'test_module', + 'test_conversion', + # 'test_class', + 'test_interface', + 'test_enum', + 'test_field', + 'test_property', + 'test_indexer', + 'test_event', + 'test_method', + # 'test_delegate', + 'test_array', ): module = __import__(name) - module.main() + unittest.TextTestRunner().run(module.test_suite()) - # import pdb; pdb.set_trace() + # pdb.set_trace() stop = time.clock() took = str(stop - start) - print 'Total Time: %s' % took + print('Total Time: {0}'.format(took)) - import gc for i in gc.get_objects(): print(i) diff --git a/src/tests/test_array.py b/src/tests/test_array.py index 9e396d7ed..36f225c82 100644 --- a/src/tests/test_array.py +++ b/src/tests/test_array.py @@ -1,20 +1,20 @@ -import sys, os, string, unittest, types +# -*- coding: utf-8 -*- + +import unittest + import Python.Test as Test import System -import six -if six.PY3: - long = int - unichr = chr +from _compat import PY2, UserList, long, range, unichr class ArrayTests(unittest.TestCase): """Test support for managed arrays.""" - def testPublicArray(self): + def test_public_array(self): """Test public arrays.""" - object = Test.PublicArrayTest() - items = object.items + ob = Test.PublicArrayTest() + items = ob.items self.assertTrue(len(items) == 5) @@ -33,10 +33,10 @@ def testPublicArray(self): items[-1] = 4 self.assertTrue(items[-1] == 4) - def testProtectedArray(self): + def test_protected_array(self): """Test protected arrays.""" - object = Test.ProtectedArrayTest() - items = object.items + ob = Test.ProtectedArrayTest() + items = ob.items self.assertTrue(len(items) == 5) @@ -55,29 +55,25 @@ def testProtectedArray(self): items[-1] = 4 self.assertTrue(items[-1] == 4) - def testInternalArray(self): + def test_internal_array(self): """Test internal arrays.""" - def test(): - object = Test.InternalArrayTest() - items = object.items - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + ob = Test.InternalArrayTest() + _ = ob.items - def testPrivateArray(self): + def test_private_array(self): """Test private arrays.""" - def test(): - object = Test.PrivateArrayTest() - items = object.items + with self.assertRaises(AttributeError): + ob = Test.PrivateArrayTest() + _ = ob.items - self.assertRaises(AttributeError, test) - - def testArrayBoundsChecking(self): + def test_array_bounds_checking(self): """Test array bounds checking.""" - object = Test.Int32ArrayTest() - items = object.items + ob = Test.Int32ArrayTest() + items = ob.items self.assertTrue(items[0] == 0) self.assertTrue(items[1] == 1) @@ -91,35 +87,27 @@ def testArrayBoundsChecking(self): self.assertTrue(items[-2] == 3) self.assertTrue(items[-1] == 4) - def test(): - object = Test.Int32ArrayTest() - object.items[5] - - self.assertRaises(IndexError, test) - - def test(): - object = Test.Int32ArrayTest() - object.items[5] = 0 + with self.assertRaises(IndexError): + ob = Test.Int32ArrayTest() + _ = ob.items[5] - self.assertRaises(IndexError, test) + with self.assertRaises(IndexError): + ob = Test.Int32ArrayTest() + ob.items[5] = 0 - def test(): - object = Test.Int32ArrayTest() + with self.assertRaises(IndexError): + ob = Test.Int32ArrayTest() items[-6] - self.assertRaises(IndexError, test) - - def test(): - object = Test.Int32ArrayTest() + with self.assertRaises(IndexError): + ob = Test.Int32ArrayTest() items[-6] = 0 - self.assertRaises(IndexError, test) - - def testArrayContains(self): + def test_array_contains(self): """Test array support for __contains__.""" - object = Test.Int32ArrayTest() - items = object.items + ob = Test.Int32ArrayTest() + items = ob.items self.assertTrue(0 in items) self.assertTrue(1 in items) @@ -132,544 +120,464 @@ def testArrayContains(self): 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 testBooleanArray(self): + def test_boolean_array(self): """Test boolean arrays.""" - object = Test.BooleanArrayTest() - items = object.items + ob = Test.BooleanArrayTest() + items = ob.items self.assertTrue(len(items) == 5) - self.assertTrue(items[0] == True) - self.assertTrue(items[1] == False) - self.assertTrue(items[2] == True) - self.assertTrue(items[3] == False) - self.assertTrue(items[4] == True) + 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) items[0] = False - self.assertTrue(items[0] == False) + self.assertTrue(items[0] is False) items[0] = True - self.assertTrue(items[0] == True) - - def test(): - object = Test.ByteArrayTest() - v = object.items["wrong"] + self.assertTrue(items[0] is True) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.ByteArrayTest() + _ = ob.items["wrong"] - def test(): - object = Test.ByteArrayTest() - object[0] = "wrong" + with self.assertRaises(TypeError): + ob = Test.ByteArrayTest() + ob[0] = "wrong" - self.assertRaises(TypeError, test) - - def testByteArray(self): + def test_byte_array(self): """Test byte arrays.""" - object = Test.ByteArrayTest() - items = object.items + ob = Test.ByteArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 0) self.assertTrue(items[4] == 4) - max = 255 - min = 0 - - items[0] = max - self.assertTrue(items[0] == max) + max_ = 255 + min_ = 0 - items[0] = min - self.assertTrue(items[0] == min) + items[0] = max_ + self.assertTrue(items[0] == max_) - items[-4] = max - self.assertTrue(items[-4] == max) + items[0] = min_ + self.assertTrue(items[0] == min_) - items[-1] = min - self.assertTrue(items[-1] == min) + items[-4] = max_ + self.assertTrue(items[-4] == max_) - def test(): - object = Test.ByteArrayTest() - object.items[0] = max + 1 + items[-1] = min_ + self.assertTrue(items[-1] == min_) - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + ob = Test.ByteArrayTest() + ob.items[0] = max_ + 1 - def test(): - object = Test.ByteArrayTest() - object.items[0] = min - 1 + with self.assertRaises(OverflowError): + ob = Test.ByteArrayTest() + ob.items[0] = min_ - 1 - self.assertRaises(OverflowError, test) + with self.assertRaises(TypeError): + ob = Test.ByteArrayTest() + _ = ob.items["wrong"] - def test(): - object = Test.ByteArrayTest() - v = object.items["wrong"] + with self.assertRaises(TypeError): + ob = Test.ByteArrayTest() + ob[0] = "wrong" - self.assertRaises(TypeError, test) - - def test(): - object = Test.ByteArrayTest() - object[0] = "wrong" - - self.assertRaises(TypeError, test) - - def testSByteArray(self): + def test_sbyte_array(self): """Test sbyte arrays.""" - object = Test.SByteArrayTest() - items = object.items + ob = Test.SByteArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 0) self.assertTrue(items[4] == 4) - max = 127 - min = -128 - - items[0] = max - self.assertTrue(items[0] == max) - - items[0] = min - self.assertTrue(items[0] == min) - - items[-4] = max - self.assertTrue(items[-4] == max) + max_ = 127 + min_ = -128 - items[-1] = min - self.assertTrue(items[-1] == min) + items[0] = max_ + self.assertTrue(items[0] == max_) - def test(): - object = Test.SByteArrayTest() - object.items[0] = max + 1 + items[0] = min_ + self.assertTrue(items[0] == min_) - self.assertRaises(OverflowError, test) + items[-4] = max_ + self.assertTrue(items[-4] == max_) - def test(): - object = Test.SByteArrayTest() - object.items[0] = min - 1 + items[-1] = min_ + self.assertTrue(items[-1] == min_) - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + ob = Test.SByteArrayTest() + ob.items[0] = max_ + 1 - def test(): - object = Test.SByteArrayTest() - v = object.items["wrong"] + with self.assertRaises(OverflowError): + ob = Test.SByteArrayTest() + ob.items[0] = min_ - 1 - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.SByteArrayTest() + _ = ob.items["wrong"] - def test(): - object = Test.SByteArrayTest() - object[0] = "wrong" + with self.assertRaises(TypeError): + ob = Test.SByteArrayTest() + ob[0] = "wrong" - self.assertRaises(TypeError, test) - - def testCharArray(self): + def test_char_array(self): """Test char arrays.""" - object = Test.CharArrayTest() - items = object.items + ob = Test.CharArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 'a') self.assertTrue(items[4] == 'e') - max = unichr(65535) - min = unichr(0) - - items[0] = max - self.assertTrue(items[0] == max) - - items[0] = min - self.assertTrue(items[0] == min) + max_ = unichr(65535) + min_ = unichr(0) - items[-4] = max - self.assertTrue(items[-4] == max) + items[0] = max_ + self.assertTrue(items[0] == max_) - items[-1] = min - self.assertTrue(items[-1] == min) + items[0] = min_ + self.assertTrue(items[0] == min_) - def test(): - object = Test.CharArrayTest() - v = object.items["wrong"] + items[-4] = max_ + self.assertTrue(items[-4] == max_) - self.assertRaises(TypeError, test) + items[-1] = min_ + self.assertTrue(items[-1] == min_) - def test(): - object = Test.CharArrayTest() - object[0] = "wrong" + with self.assertRaises(TypeError): + ob = Test.CharArrayTest() + _ = ob.items["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.CharArrayTest() + ob[0] = "wrong" - def testInt16Array(self): + def test_int16_array(self): """Test Int16 arrays.""" - object = Test.Int16ArrayTest() - items = object.items + ob = Test.Int16ArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 0) self.assertTrue(items[4] == 4) - max = 32767 - min = -32768 - - items[0] = max - self.assertTrue(items[0] == max) - - items[0] = min - self.assertTrue(items[0] == min) + max_ = 32767 + min_ = -32768 - items[-4] = max - self.assertTrue(items[-4] == max) + items[0] = max_ + self.assertTrue(items[0] == max_) - items[-1] = min - self.assertTrue(items[-1] == min) + items[0] = min_ + self.assertTrue(items[0] == min_) - def test(): - object = Test.Int16ArrayTest() - object.items[0] = max + 1 + items[-4] = max_ + self.assertTrue(items[-4] == max_) - self.assertRaises(OverflowError, test) + items[-1] = min_ + self.assertTrue(items[-1] == min_) - def test(): - object = Test.Int16ArrayTest() - object.items[0] = min - 1 + with self.assertRaises(OverflowError): + ob = Test.Int16ArrayTest() + ob.items[0] = max_ + 1 - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + ob = Test.Int16ArrayTest() + ob.items[0] = min_ - 1 - def test(): - object = Test.Int16ArrayTest() - v = object.items["wrong"] + with self.assertRaises(TypeError): + ob = Test.Int16ArrayTest() + _ = ob.items["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.Int16ArrayTest() + ob[0] = "wrong" - def test(): - object = Test.Int16ArrayTest() - object[0] = "wrong" - - self.assertRaises(TypeError, test) - - def testInt32Array(self): + def test_int32_array(self): """Test Int32 arrays.""" - object = Test.Int32ArrayTest() - items = object.items + ob = Test.Int32ArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 0) self.assertTrue(items[4] == 4) - max = 2147483647 - min = -2147483648 - - items[0] = max - self.assertTrue(items[0] == max) - - items[0] = min - self.assertTrue(items[0] == min) - - items[-4] = max - self.assertTrue(items[-4] == max) - - items[-1] = min - self.assertTrue(items[-1] == min) + max_ = 2147483647 + min_ = -2147483648 - def test(): - object = Test.Int32ArrayTest() - object.items[0] = max + 1 + items[0] = max_ + self.assertTrue(items[0] == max_) - self.assertRaises(OverflowError, test) + items[0] = min_ + self.assertTrue(items[0] == min_) - def test(): - object = Test.Int32ArrayTest() - object.items[0] = min - 1 + items[-4] = max_ + self.assertTrue(items[-4] == max_) - self.assertRaises(OverflowError, test) + items[-1] = min_ + self.assertTrue(items[-1] == min_) - def test(): - object = Test.Int32ArrayTest() - v = object.items["wrong"] + with self.assertRaises(OverflowError): + ob = Test.Int32ArrayTest() + ob.items[0] = max_ + 1 - self.assertRaises(TypeError, test) + with self.assertRaises(OverflowError): + ob = Test.Int32ArrayTest() + ob.items[0] = min_ - 1 - def test(): - object = Test.Int32ArrayTest() - object[0] = "wrong" + with self.assertRaises(TypeError): + ob = Test.Int32ArrayTest() + _ = ob.items["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.Int32ArrayTest() + ob[0] = "wrong" - def testInt64Array(self): + def test_int64_array(self): """Test Int64 arrays.""" - object = Test.Int64ArrayTest() - items = object.items + ob = Test.Int64ArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 0) self.assertTrue(items[4] == 4) - max = long(9223372036854775807) - min = long(-9223372036854775808) + max_ = long(9223372036854775807) + min_ = long(-9223372036854775808) - items[0] = max - self.assertTrue(items[0] == max) + items[0] = max_ + self.assertTrue(items[0] == max_) - items[0] = min - self.assertTrue(items[0] == min) + items[0] = min_ + self.assertTrue(items[0] == min_) - items[-4] = max - self.assertTrue(items[-4] == max) + items[-4] = max_ + self.assertTrue(items[-4] == max_) - items[-1] = min - self.assertTrue(items[-1] == min) + items[-1] = min_ + self.assertTrue(items[-1] == min_) - def test(): - object = Test.Int64ArrayTest() - object.items[0] = max + 1 + with self.assertRaises(OverflowError): + ob = Test.Int64ArrayTest() + ob.items[0] = max_ + 1 - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + ob = Test.Int64ArrayTest() + ob.items[0] = min_ - 1 - def test(): - object = Test.Int64ArrayTest() - object.items[0] = min - 1 + with self.assertRaises(TypeError): + ob = Test.Int64ArrayTest() + _ = ob.items["wrong"] - self.assertRaises(OverflowError, test) + with self.assertRaises(TypeError): + ob = Test.Int64ArrayTest() + ob[0] = "wrong" - def test(): - object = Test.Int64ArrayTest() - v = object.items["wrong"] - - self.assertRaises(TypeError, test) - - def test(): - object = Test.Int64ArrayTest() - object[0] = "wrong" - - self.assertRaises(TypeError, test) - - def testUInt16Array(self): + def test_uint16_array(self): """Test UInt16 arrays.""" - object = Test.UInt16ArrayTest() - items = object.items + ob = Test.UInt16ArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 0) self.assertTrue(items[4] == 4) - max = 65535 - min = 0 - - items[0] = max - self.assertTrue(items[0] == max) + max_ = 65535 + min_ = 0 - items[0] = min - self.assertTrue(items[0] == min) + items[0] = max_ + self.assertTrue(items[0] == max_) - items[-4] = max - self.assertTrue(items[-4] == max) + items[0] = min_ + self.assertTrue(items[0] == min_) - items[-1] = min - self.assertTrue(items[-1] == min) + items[-4] = max_ + self.assertTrue(items[-4] == max_) - def test(): - object = Test.UInt16ArrayTest() - object.items[0] = max + 1 + items[-1] = min_ + self.assertTrue(items[-1] == min_) - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + ob = Test.UInt16ArrayTest() + ob.items[0] = max_ + 1 - def test(): - object = Test.UInt16ArrayTest() - object.items[0] = min - 1 + with self.assertRaises(OverflowError): + ob = Test.UInt16ArrayTest() + ob.items[0] = min_ - 1 - self.assertRaises(OverflowError, test) + with self.assertRaises(TypeError): + ob = Test.UInt16ArrayTest() + _ = ob.items["wrong"] - def test(): - object = Test.UInt16ArrayTest() - v = object.items["wrong"] + with self.assertRaises(TypeError): + ob = Test.UInt16ArrayTest() + ob[0] = "wrong" - self.assertRaises(TypeError, test) - - def test(): - object = Test.UInt16ArrayTest() - object[0] = "wrong" - - self.assertRaises(TypeError, test) - - def testUInt32Array(self): + def test_uint32_array(self): """Test UInt32 arrays.""" - object = Test.UInt32ArrayTest() - items = object.items + ob = Test.UInt32ArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 0) self.assertTrue(items[4] == 4) - max = long(4294967295) - min = 0 - - items[0] = max - self.assertTrue(items[0] == max) - - items[0] = min - self.assertTrue(items[0] == min) - - items[-4] = max - self.assertTrue(items[-4] == max) + max_ = long(4294967295) + min_ = 0 - items[-1] = min - self.assertTrue(items[-1] == min) + items[0] = max_ + self.assertTrue(items[0] == max_) - def test(): - object = Test.UInt32ArrayTest() - object.items[0] = max + 1 + items[0] = min_ + self.assertTrue(items[0] == min_) - self.assertRaises(OverflowError, test) + items[-4] = max_ + self.assertTrue(items[-4] == max_) - def test(): - object = Test.UInt32ArrayTest() - object.items[0] = min - 1 + items[-1] = min_ + self.assertTrue(items[-1] == min_) - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + ob = Test.UInt32ArrayTest() + ob.items[0] = max_ + 1 - def test(): - object = Test.UInt32ArrayTest() - v = object.items["wrong"] + with self.assertRaises(OverflowError): + ob = Test.UInt32ArrayTest() + ob.items[0] = min_ - 1 - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.UInt32ArrayTest() + _ = ob.items["wrong"] - def test(): - object = Test.UInt32ArrayTest() - object[0] = "wrong" + with self.assertRaises(TypeError): + ob = Test.UInt32ArrayTest() + ob[0] = "wrong" - self.assertRaises(TypeError, test) - - def testUInt64Array(self): + def test_uint64_array(self): """Test UInt64 arrays.""" - object = Test.UInt64ArrayTest() - items = object.items + ob = Test.UInt64ArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 0) self.assertTrue(items[4] == 4) - max = long(18446744073709551615) - min = 0 - - items[0] = max - self.assertTrue(items[0] == max) - - items[0] = min - self.assertTrue(items[0] == min) - - items[-4] = max - self.assertTrue(items[-4] == max) - - items[-1] = min - self.assertTrue(items[-1] == min) + max_ = long(18446744073709551615) + min_ = 0 - def test(): - object = Test.UInt64ArrayTest() - object.items[0] = max + 1 + items[0] = max_ + self.assertTrue(items[0] == max_) - self.assertRaises(OverflowError, test) + items[0] = min_ + self.assertTrue(items[0] == min_) - def test(): - object = Test.UInt64ArrayTest() - object.items[0] = min - 1 + items[-4] = max_ + self.assertTrue(items[-4] == max_) - self.assertRaises(OverflowError, test) + items[-1] = min_ + self.assertTrue(items[-1] == min_) - def test(): - object = Test.UInt64ArrayTest() - v = object.items["wrong"] + with self.assertRaises(OverflowError): + ob = Test.UInt64ArrayTest() + ob.items[0] = max_ + 1 - self.assertRaises(TypeError, test) + with self.assertRaises(OverflowError): + ob = Test.UInt64ArrayTest() + ob.items[0] = min_ - 1 - def test(): - object = Test.UInt64ArrayTest() - object[0] = "wrong" + with self.assertRaises(TypeError): + ob = Test.UInt64ArrayTest() + _ = ob.items["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.UInt64ArrayTest() + ob[0] = "wrong" - def testSingleArray(self): + def test_single_array(self): """Test Single arrays.""" - object = Test.SingleArrayTest() - items = object.items + ob = Test.SingleArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 0.0) self.assertTrue(items[4] == 4.0) - max = 3.402823e38 - min = -3.402823e38 + max_ = 3.402823e38 + min_ = -3.402823e38 - items[0] = max - self.assertTrue(items[0] == max) + items[0] = max_ + self.assertTrue(items[0] == max_) - items[0] = min - self.assertTrue(items[0] == min) + items[0] = min_ + self.assertTrue(items[0] == min_) - items[-4] = max - self.assertTrue(items[-4] == max) + items[-4] = max_ + self.assertTrue(items[-4] == max_) - items[-1] = min - self.assertTrue(items[-1] == min) + items[-1] = min_ + self.assertTrue(items[-1] == min_) - def test(): - object = Test.SingleArrayTest() - v = object.items["wrong"] + with self.assertRaises(TypeError): + ob = Test.SingleArrayTest() + _ = ob.items["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.SingleArrayTest() + ob[0] = "wrong" - def test(): - object = Test.SingleArrayTest() - object[0] = "wrong" - - self.assertRaises(TypeError, test) - - def testDoubleArray(self): + def test_double_array(self): """Test Double arrays.""" - object = Test.DoubleArrayTest() - items = object.items + ob = Test.DoubleArrayTest() + items = ob.items self.assertTrue(len(items) == 5) self.assertTrue(items[0] == 0.0) self.assertTrue(items[4] == 4.0) - max = 1.7976931348623157e308 - min = -1.7976931348623157e308 - - items[0] = max - self.assertTrue(items[0] == max) + max_ = 1.7976931348623157e308 + min_ = -1.7976931348623157e308 - items[0] = min - self.assertTrue(items[0] == min) + items[0] = max_ + self.assertTrue(items[0] == max_) - items[-4] = max - self.assertTrue(items[-4] == max) + items[0] = min_ + self.assertTrue(items[0] == min_) - items[-1] = min - self.assertTrue(items[-1] == min) + items[-4] = max_ + self.assertTrue(items[-4] == max_) - def test(): - object = Test.DoubleArrayTest() - v = object.items["wrong"] + items[-1] = min_ + self.assertTrue(items[-1] == min_) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.DoubleArrayTest() + _ = ob.items["wrong"] - def test(): - object = Test.DoubleArrayTest() - object[0] = "wrong" + with self.assertRaises(TypeError): + ob = Test.DoubleArrayTest() + ob[0] = "wrong" - self.assertRaises(TypeError, test) - - def testDecimalArray(self): + def test_decimal_array(self): """Test Decimal arrays.""" - object = Test.DecimalArrayTest() - items = object.items + ob = Test.DecimalArrayTest() + items = ob.items from System import Decimal max_d = Decimal.Parse("79228162514264337593543950335") @@ -692,22 +600,18 @@ def testDecimalArray(self): items[-1] = min_d self.assertTrue(items[-1] == min_d) - def test(): - object = Test.DecimalArrayTest() - v = object.items["wrong"] - - self.assertRaises(TypeError, test) - - def test(): - object = Test.DecimalArrayTest() - object[0] = "wrong" + with self.assertRaises(TypeError): + ob = Test.DecimalArrayTest() + _ = ob.items["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.DecimalArrayTest() + ob[0] = "wrong" - def testStringArray(self): + def test_string_array(self): """Test String arrays.""" - object = Test.StringArrayTest() - items = object.items + ob = Test.StringArrayTest() + items = ob.items self.assertTrue(len(items) == 5) @@ -726,23 +630,19 @@ def testStringArray(self): items[-1] = "eggs" self.assertTrue(items[-1] == "eggs") - def test(): - object = Test.StringArrayTest() - v = object.items["wrong"] + with self.assertRaises(TypeError): + ob = Test.StringArrayTest() + _ = ob.items["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.Int64ArrayTest() + ob[0] = 0 - def test(): - object = Test.Int64ArrayTest() - object[0] = 0 - - self.assertRaises(TypeError, test) - - def testEnumArray(self): + def test_enum_array(self): """Test enum arrays.""" from Python.Test import ShortEnum - object = Test.EnumArrayTest() - items = object.items + ob = Test.EnumArrayTest() + items = ob.items self.assertTrue(len(items) == 5) @@ -761,29 +661,23 @@ def testEnumArray(self): items[-1] = ShortEnum.Zero self.assertTrue(items[-1] == ShortEnum.Zero) - def test(): - object = Test.EnumArrayTest() - object.items[0] = 99 - - self.assertRaises(ValueError, test) - - def test(): - object = Test.EnumArrayTest() - v = object.items["wrong"] - - self.assertRaises(TypeError, test) + with self.assertRaises(ValueError): + ob = Test.EnumArrayTest() + ob.items[0] = 99 - def test(): - object = Test.EnumArrayTest() - object[0] = "wrong" + with self.assertRaises(TypeError): + ob = Test.EnumArrayTest() + _ = ob.items["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.EnumArrayTest() + ob[0] = "wrong" - def testObjectArray(self): - """Test object arrays.""" + def test_object_array(self): + """Test ob arrays.""" from Python.Test import Spam - object = Test.ObjectArrayTest() - items = object.items + ob = Test.ObjectArrayTest() + items = ob.items self.assertTrue(len(items) == 5) @@ -806,56 +700,50 @@ def testObjectArray(self): self.assertTrue(items[0] == 99) items[0] = None - self.assertTrue(items[0] == None) + self.assertTrue(items[0] is None) - def test(): - object = Test.ObjectArrayTest() - v = object.items["wrong"] + with self.assertRaises(TypeError): + ob = Test.ObjectArrayTest() + _ = ob.items["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.ObjectArrayTest() + ob.items["wrong"] = "wrong" - def test(): - object = Test.ObjectArrayTest() - object.items["wrong"] = "wrong" - - self.assertRaises(TypeError, test) - - def testNullArray(self): + def test_null_array(self): """Test null arrays.""" - object = Test.NullArrayTest() - items = object.items + ob = Test.NullArrayTest() + items = ob.items self.assertTrue(len(items) == 5) - self.assertTrue(items[0] == None) - self.assertTrue(items[4] == None) + self.assertTrue(items[0] is None) + self.assertTrue(items[4] is None) items[0] = "spam" self.assertTrue(items[0] == "spam") items[0] = None - self.assertTrue(items[0] == None) + self.assertTrue(items[0] is None) items[-4] = "spam" self.assertTrue(items[-4] == "spam") items[-1] = None - self.assertTrue(items[-1] == None) + self.assertTrue(items[-1] is None) - empty = object.empty + empty = ob.empty self.assertTrue(len(empty) == 0) - def test(): - object = Test.NullArrayTest() - v = object.items["wrong"] - - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.NullArrayTest() + _ = ob.items["wrong"] - def testInterfaceArray(self): + def test_interface_array(self): """Test interface arrays.""" from Python.Test import Spam - object = Test.InterfaceArrayTest() - items = object.items + ob = Test.InterfaceArrayTest() + items = ob.items self.assertTrue(len(items) == 5) @@ -875,31 +763,25 @@ def testInterfaceArray(self): self.assertTrue(items[-1].GetValue() == "0") items[0] = None - self.assertTrue(items[0] == None) - - def test(): - object = Test.InterfaceArrayTest() - object.items[0] = 99 - - self.assertRaises(TypeError, test) - - def test(): - object = Test.InterfaceArrayTest() - v = object.items["wrong"] + self.assertTrue(items[0] is None) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.InterfaceArrayTest() + ob.items[0] = 99 - def test(): - object = Test.InterfaceArrayTest() - object.items["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.InterfaceArrayTest() + _ = ob.items["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.InterfaceArrayTest() + ob.items["wrong"] = "wrong" - def testTypedArray(self): + def test_typed_array(self): """Test typed arrays.""" from Python.Test import Spam - object = Test.TypedArrayTest() - items = object.items + ob = Test.TypedArrayTest() + items = ob.items self.assertTrue(len(items) == 5) @@ -919,30 +801,24 @@ def testTypedArray(self): self.assertTrue(items[-1].GetValue() == "0") items[0] = None - self.assertTrue(items[0] == None) + self.assertTrue(items[0] is None) - def test(): - object = Test.TypedArrayTest() - object.items[0] = 99 + with self.assertRaises(TypeError): + ob = Test.TypedArrayTest() + ob.items[0] = 99 - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.TypedArrayTest() + _ = ob.items["wrong"] - def test(): - object = Test.TypedArrayTest() - v = object.items["wrong"] + with self.assertRaises(TypeError): + ob = Test.TypedArrayTest() + ob.items["wrong"] = "wrong" - self.assertRaises(TypeError, test) - - def test(): - object = Test.TypedArrayTest() - object.items["wrong"] = "wrong" - - self.assertRaises(TypeError, test) - - def testMultiDimensionalArray(self): + def test_multi_dimensional_array(self): """Test multi-dimensional arrays.""" - object = Test.MultiDimensionalArrayTest() - items = object.items + ob = Test.MultiDimensionalArrayTest() + items = ob.items self.assertTrue(len(items) == 25) @@ -972,46 +848,38 @@ def testMultiDimensionalArray(self): 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) + max_ = 2147483647 + min_ = -2147483648 - items[-4, 0] = max - self.assertTrue(items[-4, 0] == max) + items[0, 0] = max_ + self.assertTrue(items[0, 0] == max_) - items[-1, -1] = min - self.assertTrue(items[-1, -1] == min) + items[0, 0] = min_ + self.assertTrue(items[0, 0] == min_) - def test(): - object = Test.MultiDimensionalArrayTest() - object.items[0, 0] = max + 1 + items[-4, 0] = max_ + self.assertTrue(items[-4, 0] == max_) - self.assertRaises(OverflowError, test) + items[-1, -1] = min_ + self.assertTrue(items[-1, -1] == min_) - def test(): - object = Test.MultiDimensionalArrayTest() - object.items[0, 0] = min - 1 + with self.assertRaises(OverflowError): + ob = Test.MultiDimensionalArrayTest() + ob.items[0, 0] = max_ + 1 - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + ob = Test.MultiDimensionalArrayTest() + ob.items[0, 0] = min_ - 1 - def test(): - object = Test.MultiDimensionalArrayTest() - v = object.items["wrong", 0] + with self.assertRaises(TypeError): + ob = Test.MultiDimensionalArrayTest() + _ = ob.items["wrong", 0] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.MultiDimensionalArrayTest() + ob[0, 0] = "wrong" - def test(): - object = Test.MultiDimensionalArrayTest() - object[0, 0] = "wrong" - - self.assertRaises(TypeError, test) - - def testArrayIteration(self): + def test_array_iteration(self): """Test array iteration.""" items = Test.Int32ArrayTest().items @@ -1021,14 +889,14 @@ def testArrayIteration(self): items = Test.NullArrayTest().items for i in items: - self.assertTrue(i == None) + self.assertTrue(i is None) empty = Test.NullArrayTest().empty for i in empty: raise TypeError('iteration over empty array') - def testTupleArrayConversion(self): + def test_tuple_array_conversion(self): """Test conversion of tuples to array arguments.""" from Python.Test import ArrayConversionTest from Python.Test import Spam @@ -1042,7 +910,7 @@ def testTupleArrayConversion(self): self.assertTrue(result[0].__class__ == Spam) self.assertTrue(len(result) == 10) - def testTupleNestedArrayConversion(self): + 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 @@ -1050,7 +918,7 @@ def testTupleNestedArrayConversion(self): items = [] for i in range(10): subs = [] - for n in range(10): + for _ in range(10): subs.append(Spam(str(i))) items.append(tuple(subs)) items = tuple(items) @@ -1061,7 +929,7 @@ def testTupleNestedArrayConversion(self): self.assertTrue(len(result[0]) == 10) self.assertTrue(result[0][0].__class__ == Spam) - def testListArrayConversion(self): + def test_list_array_conversion(self): """Test conversion of lists to array arguments.""" from Python.Test import ArrayConversionTest from Python.Test import Spam @@ -1074,7 +942,7 @@ def testListArrayConversion(self): self.assertTrue(result[0].__class__ == Spam) self.assertTrue(len(result) == 10) - def testListNestedArrayConversion(self): + 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 @@ -1082,7 +950,7 @@ def testListNestedArrayConversion(self): items = [] for i in range(10): subs = [] - for n in range(10): + for _ in range(10): subs.append(Spam(str(i))) items.append(subs) @@ -1092,14 +960,10 @@ def testListNestedArrayConversion(self): self.assertTrue(len(result[0]) == 10) self.assertTrue(result[0][0].__class__ == Spam) - def testSequenceArrayConversion(self): - """Test conversion of sequence-like objects to array arguments.""" + 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 - if six.PY3: - from collections import UserList - else: - from UserList import UserList items = UserList() for i in range(10): @@ -1109,19 +973,15 @@ def testSequenceArrayConversion(self): self.assertTrue(result[0].__class__ == Spam) self.assertTrue(len(result) == 10) - def testSequenceNestedArrayConversion(self): + 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 - if six.PY3: - from collections import UserList - else: - from UserList import UserList items = UserList() for i in range(10): subs = UserList() - for n in range(10): + for _ in range(10): subs.append(Spam(str(i))) items.append(subs) @@ -1131,7 +991,7 @@ def testSequenceNestedArrayConversion(self): self.assertTrue(len(result[0]) == 10) self.assertTrue(result[0][0].__class__ == Spam) - def testTupleArrayConversionTypeChecking(self): + 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 @@ -1148,26 +1008,20 @@ def testTupleArrayConversionTypeChecking(self): result = ArrayConversionTest.EchoRange(items) self.assertTrue(result[0].__class__ == Spam) - self.assertTrue(result[1] == None) + self.assertTrue(result[1] is None) self.assertTrue(len(result) == 10) - def test(items=items): + with self.assertRaises(TypeError): temp = list(items) temp[1] = 1 + _ = ArrayConversionTest.EchoRange(tuple(temp)) - result = ArrayConversionTest.EchoRange(tuple(temp)) - - self.assertRaises(TypeError, test) - - def test(items=items): + with self.assertRaises(TypeError): temp = list(items) temp[1] = "spam" + _ = ArrayConversionTest.EchoRange(tuple(temp)) - result = ArrayConversionTest.EchoRange(tuple(temp)) - - self.assertRaises(TypeError, test) - - def testListArrayConversionTypeChecking(self): + 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 @@ -1183,29 +1037,21 @@ def testListArrayConversionTypeChecking(self): result = ArrayConversionTest.EchoRange(items) self.assertTrue(result[0].__class__ == Spam) - self.assertTrue(result[1] == None) + self.assertTrue(result[1] is None) self.assertTrue(len(result) == 10) - def test(items=items): + with self.assertRaises(TypeError): items[1] = 1 - result = ArrayConversionTest.EchoRange(items) + _ = ArrayConversionTest.EchoRange(items) - self.assertRaises(TypeError, test) - - def test(items=items): + with self.assertRaises(TypeError): items[1] = "spam" - result = ArrayConversionTest.EchoRange(items) - - self.assertRaises(TypeError, test) + _ = ArrayConversionTest.EchoRange(items) - def testSequenceArrayConversionTypeChecking(self): + 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 - if six.PY3: - from collections import UserList - else: - from UserList import UserList # This should work, because null / None is a valid value in an # array of reference types. @@ -1218,22 +1064,18 @@ def testSequenceArrayConversionTypeChecking(self): result = ArrayConversionTest.EchoRange(items) self.assertTrue(result[0].__class__ == Spam) - self.assertTrue(result[1] == None) + self.assertTrue(result[1] is None) self.assertTrue(len(result) == 10) - def test(items=items): + with self.assertRaises(TypeError): items[1] = 1 - result = ArrayConversionTest.EchoRange(items) - - self.assertRaises(TypeError, test) + _ = ArrayConversionTest.EchoRange(items) - def test(items=items): + with self.assertRaises(TypeError): items[1] = "spam" - result = ArrayConversionTest.EchoRange(items) + _ = ArrayConversionTest.EchoRange(items) - self.assertRaises(TypeError, test) - - def testMDArrayConversion(self): + def test_md_array_conversion(self): """Test passing of multi-dimensional array arguments.""" from Python.Test import ArrayConversionTest from Python.Test import Spam @@ -1257,7 +1099,7 @@ def testMDArrayConversion(self): self.assertTrue(result[0, 0].__class__ == Spam) self.assertTrue(result[0, 0].__class__ == Spam) - def testBoxedValueTypeMutationResult(self): + def test_boxed_value_type_mutation_result(self): """Test behavior of boxed value types.""" # This test actually exists mostly as documentation of an important @@ -1275,7 +1117,7 @@ def testBoxedValueTypeMutationResult(self): items[i] = Point(i, i) for i in range(5): - # Boxed items, so settr will not change the array member. + # 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 @@ -1294,20 +1136,20 @@ def testBoxedValueTypeMutationResult(self): self.assertTrue(items[i].X == i + 1) self.assertTrue(items[i].Y == i + 1) - def testSpecialArrayCreation(self): + 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] == True) - self.assertTrue(value[1] == 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] == True) - self.assertTrue(value[1] == True) + self.assertTrue(value[0] is True) + self.assertTrue(value[1] is True) self.assertTrue(value.Length == 2) value = Array[System.Byte]([0, 255]) @@ -1320,9 +1162,9 @@ def testSpecialArrayCreation(self): self.assertTrue(value[1] == 127) self.assertTrue(value.Length == 2) - value = Array[System.Char]([six.u('A'), six.u('Z')]) - self.assertTrue(value[0] == six.u('A')) - self.assertTrue(value[1] == six.u('Z')) + 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]) @@ -1351,7 +1193,7 @@ def testSpecialArrayCreation(self): self.assertTrue(value.Length == 2) # there's no explicit long type in python3, use System.Int64 instead - if not six.PY3: + if PY2: value = Array[long]([0, long(9223372036854775807)]) self.assertTrue(value[0] == 0) self.assertTrue(value[1] == long(9223372036854775807)) @@ -1428,61 +1270,37 @@ def testSpecialArrayCreation(self): self.assertTrue(value[1].__class__ == inst.__class__) self.assertTrue(value.Length == 2) - def testArrayAbuse(self): + def test_array_abuse(self): """Test array abuse.""" _class = Test.PublicArrayTest - object = Test.PublicArrayTest() + ob = Test.PublicArrayTest() - def test(): + with self.assertRaises(AttributeError): del _class.__getitem__ - self.assertRaises(AttributeError, test) - - def test(): - del object.__getitem__ + with self.assertRaises(AttributeError): + del ob.__getitem__ - self.assertRaises(AttributeError, test) - - def test(): + with self.assertRaises(AttributeError): del _class.__setitem__ - self.assertRaises(AttributeError, test) - - def test(): - del object.__setitem__ - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + del ob.__setitem__ - def test(): + with self.assertRaises(TypeError): Test.PublicArrayTest.__getitem__(0, 0) - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): Test.PublicArrayTest.__setitem__(0, 0, 0) - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): desc = Test.PublicArrayTest.__dict__['__getitem__'] desc(0, 0) - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): desc = Test.PublicArrayTest.__dict__['__setitem__'] desc(0, 0, 0) - self.assertRaises(TypeError, test) - def test_suite(): return unittest.makeSuite(ArrayTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_class.py b/src/tests/test_class.py index 9e2af14da..bf3b6f143 100644 --- a/src/tests/test_class.py +++ b/src/tests/test_class.py @@ -1,73 +1,65 @@ -import clr -import types +# -*- coding: utf-8 -*- +# TODO: Add tests for ClassicClass, NewStyleClass? + import unittest import Python.Test as Test import System -import six -from Python.Test import ClassTest -from System.Collections import Hashtable -if six.PY3: - DictProxyType = type(object.__dict__) -else: - DictProxyType = types.DictProxyType +from _compat import DictProxyType, range class ClassTests(unittest.TestCase): """Test CLR class support.""" - def testBasicReferenceType(self): + def test_basic_reference_type(self): """Test usage of CLR defined reference types.""" - String = System.String - self.assertEquals(String.Empty, "") + self.assertEquals(System.String.Empty, "") - def testBasicValueType(self): + def test_basic_value_type(self): """Test usage of CLR defined value types.""" - Int32 = System.Int32 - self.assertEquals(Int32.MaxValue, 2147483647) + self.assertEquals(System.Int32.MaxValue, 2147483647) - def testClassStandardAttrs(self): + 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(type(ClassTest.__dict__) == DictProxyType) + self.assertTrue(isinstance(ClassTest.__dict__, DictProxyType)) self.assertTrue(len(ClassTest.__doc__) > 0) - def testClassDocstrings(self): + def test_class_docstrings(self): """Test standard class docstring generation""" + from Python.Test import ClassTest + value = 'Void .ctor()' self.assertTrue(ClassTest.__doc__ == value) - def testClassDefaultStr(self): + 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 testClassDefaultRepr(self): + 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 = Test.ClassTest.GetHashtable() + dict_ = ClassTest.GetHashtable() - for item in dict: + for item in dict_: cname = item.__class__.__name__ self.assertTrue(cname.endswith('DictionaryEntry')) - def testIEnumeratorIteration(self): + def test_ienumerator_iteration(self): """Test iteration over objects supporting IEnumerator.""" - chars = Test.ClassTest.GetEnumerator() + from Python.Test import ClassTest + + chars = ClassTest.GetEnumerator() for item in chars: self.assertTrue(item in 'test string') - def testOverrideGetItem(self): + def test_override_get_item(self): """Test managed subclass overriding __getitem__.""" + from System.Collections import Hashtable class MyTable(Hashtable): def __getitem__(self, key): @@ -182,8 +176,9 @@ def __getitem__(self, key): self.assertTrue(table.Count == 3) - def testOverrideSetItem(self): + def test_override_set_item(self): """Test managed subclass overriding __setitem__.""" + from System.Collections import Hashtable class MyTable(Hashtable): def __setitem__(self, key, value): @@ -201,19 +196,19 @@ def __setitem__(self, key, value): self.assertTrue(table.Count == 3) - def testAddAndRemoveClassAttribute(self): - + def test_add_and_remove_class_attribute(self): from System import TimeSpan - for i in range(100): - TimeSpan.new_method = lambda self: self.TotalMinutes + 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")) - def testComparisons(self): + 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") @@ -242,47 +237,36 @@ def testComparisons(self): self.assertEqual(d2 >= d1, True) self.assertEqual(d2 > d1, True) - self.assertRaises(TypeError, lambda: d1 < None) - self.assertRaises(TypeError, lambda: d1 < System.Guid()) + with self.assertRaises(TypeError): + d1 < None + + with self.assertRaises(TypeError): + d1 < System.Guid() # ClassTest does not implement IComparable c1 = ClassTest() c2 = ClassTest() - self.assertRaises(TypeError, lambda: c1 < c2) + with self.assertRaises(TypeError): + c1 < c2 + + def test_self_callback(self): + """Test calling back and forth between this and a c# baseclass.""" - def testSelfCallback(self): - """ Test calling back and forth between this and a c# baseclass.""" 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 - + testobj = CallbackUser() testobj.DoCallback() self.assertTrue(testobj.PyCallbackWasCalled) self.assertTrue(testobj.SameReference) -class ClassicClass: - def kind(self): - return 'classic' - - -class NewStyleClass(object): - def kind(self): - return 'new-style' - def test_suite(): return unittest.makeSuite(ClassTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_compat.py b/src/tests/test_compat.py index 8c74b855a..cea51ca49 100644 --- a/src/tests/test_compat.py +++ b/src/tests/test_compat.py @@ -1,193 +1,177 @@ -import sys, os, string, unittest, types -import six +# -*- coding: utf-8 -*- +# TODO: Complete removal of methods below. Similar to test_module -if six.PY3: - ClassType = type -else: - ClassType = types.ClassType +import types +import unittest +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. - """ - - def isCLRModule(self, object): - return type(object).__name__ == 'ModuleObject' - - def isCLRRootModule(self, object): - if six.PY3: - # in Python 3 the clr module is a normal python module - return object.__name__ == "clr" - return type(object).__name__ == 'CLRModule' - def isCLRClass(self, object): - return type(object).__name__ == 'CLR Metatype' # for now +class CompatibilityTests(unittest.TestCase): + """Backward-compatibility tests for deprecated features.""" # Tests for old-style CLR-prefixed module naming. - def testSimpleImport(self): + def test_simple_import(self): """Test simple import.""" import CLR - self.assertTrue(self.isCLRRootModule(CLR)) + self.assertTrue(is_clr_root_module(CLR)) self.assertTrue(CLR.__name__ == 'clr') import sys - self.assertTrue(type(sys) == types.ModuleType) + self.assertTrue(isinstance(sys, types.ModuleType)) self.assertTrue(sys.__name__ == 'sys') - if six.PY3: + if PY3: import http.client - self.assertTrue(type(http.client) == types.ModuleType) + self.assertTrue(isinstance(http.client, types.ModuleType)) self.assertTrue(http.client.__name__ == 'http.client') - else: + elif PY2: import httplib - self.assertTrue(type(httplib) == types.ModuleType) + self.assertTrue(isinstance(httplib, types.ModuleType)) self.assertTrue(httplib.__name__ == 'httplib') - def testSimpleImportWithAlias(self): + def test_simple_import_with_alias(self): """Test simple import with aliasing.""" import CLR as myCLR - self.assertTrue(self.isCLRRootModule(myCLR)) + self.assertTrue(is_clr_root_module(myCLR)) self.assertTrue(myCLR.__name__ == 'clr') import sys as mySys - self.assertTrue(type(mySys) == types.ModuleType) + self.assertTrue(isinstance(mySys, types.ModuleType)) self.assertTrue(mySys.__name__ == 'sys') - if six.PY3: + if PY3: import http.client as myHttplib - self.assertTrue(type(myHttplib) == types.ModuleType) + self.assertTrue(isinstance(myHttplib, types.ModuleType)) self.assertTrue(myHttplib.__name__ == 'http.client') - else: + elif PY2: import httplib as myHttplib - self.assertTrue(type(myHttplib) == types.ModuleType) + self.assertTrue(isinstance(myHttplib, types.ModuleType)) self.assertTrue(myHttplib.__name__ == 'httplib') - def testDottedNameImport(self): + def test_dotted_name_import(self): """Test dotted-name import.""" import CLR.System - self.assertTrue(self.isCLRModule(CLR.System)) + self.assertTrue(is_clr_module(CLR.System)) self.assertTrue(CLR.System.__name__ == 'System') import System - self.assertTrue(self.isCLRModule(System)) + self.assertTrue(is_clr_module(System)) self.assertTrue(System.__name__ == 'System') self.assertTrue(System is CLR.System) import xml.dom - self.assertTrue(type(xml.dom) == types.ModuleType) + self.assertTrue(isinstance(xml.dom, types.ModuleType)) self.assertTrue(xml.dom.__name__ == 'xml.dom') - def testDottedNameImportWithAlias(self): + def test_dotted_name_import_with_alias(self): """Test dotted-name import with aliasing.""" import CLR.System as myCLRSystem - self.assertTrue(self.isCLRModule(myCLRSystem)) + self.assertTrue(is_clr_module(myCLRSystem)) self.assertTrue(myCLRSystem.__name__ == 'System') import System as mySystem - self.assertTrue(self.isCLRModule(mySystem)) + self.assertTrue(is_clr_module(mySystem)) self.assertTrue(mySystem.__name__ == 'System') self.assertTrue(mySystem is myCLRSystem) import xml.dom as myDom - self.assertTrue(type(myDom) == types.ModuleType) + self.assertTrue(isinstance(myDom, types.ModuleType)) self.assertTrue(myDom.__name__ == 'xml.dom') - def testSimpleImportFrom(self): + def test_simple_import_from(self): """Test simple 'import from'.""" from CLR import System - self.assertTrue(self.isCLRModule(System)) + self.assertTrue(is_clr_module(System)) self.assertTrue(System.__name__ == 'System') from xml import dom - self.assertTrue(type(dom) == types.ModuleType) + self.assertTrue(isinstance(dom, types.ModuleType)) self.assertTrue(dom.__name__ == 'xml.dom') - def testSimpleImportFromWithAlias(self): + def test_simple_import_from_with_alias(self): """Test simple 'import from' with aliasing.""" from CLR import System as mySystem - self.assertTrue(self.isCLRModule(mySystem)) + self.assertTrue(is_clr_module(mySystem)) self.assertTrue(mySystem.__name__ == 'System') from xml import dom as myDom - self.assertTrue(type(myDom) == types.ModuleType) + self.assertTrue(isinstance(myDom, types.ModuleType)) self.assertTrue(myDom.__name__ == 'xml.dom') - def testDottedNameImportFrom(self): + def test_dotted_name_import_from(self): """Test dotted-name 'import from'.""" from CLR.System import Xml - self.assertTrue(self.isCLRModule(Xml)) + self.assertTrue(is_clr_module(Xml)) self.assertTrue(Xml.__name__ == 'System.Xml') from CLR.System.Xml import XmlDocument - self.assertTrue(self.isCLRClass(XmlDocument)) + self.assertTrue(is_clr_class(XmlDocument)) self.assertTrue(XmlDocument.__name__ == 'XmlDocument') from xml.dom import pulldom - self.assertTrue(type(pulldom) == types.ModuleType) + self.assertTrue(isinstance(pulldom, types.ModuleType)) self.assertTrue(pulldom.__name__ == 'xml.dom.pulldom') from xml.dom.pulldom import PullDOM - self.assertTrue(type(PullDOM) == ClassType) + self.assertTrue(isinstance(PullDOM, ClassType)) self.assertTrue(PullDOM.__name__ == 'PullDOM') - def testDottedNameImportFromWithAlias(self): + 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(self.isCLRModule(myXml)) + self.assertTrue(is_clr_module(myXml)) self.assertTrue(myXml.__name__ == 'System.Xml') from CLR.System.Xml import XmlDocument as myXmlDocument - self.assertTrue(self.isCLRClass(myXmlDocument)) + self.assertTrue(is_clr_class(myXmlDocument)) self.assertTrue(myXmlDocument.__name__ == 'XmlDocument') from xml.dom import pulldom as myPulldom - self.assertTrue(type(myPulldom) == types.ModuleType) + self.assertTrue(isinstance(myPulldom, types.ModuleType)) self.assertTrue(myPulldom.__name__ == 'xml.dom.pulldom') from xml.dom.pulldom import PullDOM as myPullDOM - self.assertTrue(type(myPullDOM) == ClassType) + self.assertTrue(isinstance(myPullDOM, ClassType)) self.assertTrue(myPullDOM.__name__ == 'PullDOM') - def testFromModuleImportStar(self): + def test_from_module_import_star(self): """Test from module import * behavior.""" - import clr - clr.AddReference("System.Management") - count = len(locals().keys()) m = __import__('CLR.System.Management', globals(), locals(), ['*']) self.assertTrue(m.__name__ == 'System.Management') - self.assertTrue(self.isCLRModule(m)) + 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(self.isCLRModule(m2)) + self.assertTrue(is_clr_module(m2)) self.assertTrue(len(locals().keys()) > count + 1) self.assertTrue(m is m2) - def testExplicitAssemblyLoad(self): + 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 != None) + self.assertTrue(assembly is not None) import CLR.System.Data self.assertTrue('System.Data' in sys.modules) assembly = Assembly.LoadWithPartialName('SpamSpamSpamSpamEggsAndSpam') - self.assertTrue(assembly == None) + self.assertTrue(assembly is None) - def testImplicitLoadAlreadyValidNamespace(self): + 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 @@ -196,80 +180,54 @@ def testImplicitLoadAlreadyValidNamespace(self): # 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(self.isCLRClass(CLR.System.UriBuilder)) + self.assertTrue(is_clr_class(CLR.System.UriBuilder)) - def testImportNonExistantModule(self): - """Test import failure for a non-existant module.""" - - def test(): + def test_import_non_existant_module(self): + """Test import failure for a non-existent module.""" + with self.assertRaises(ImportError): import System.SpamSpamSpam - def testclr(): + with self.assertRaises(ImportError): import CLR.System.SpamSpamSpam - self.assertRaises(ImportError, test) - self.assertRaises(ImportError, testclr) - - def testLookupNoNamespaceType(self): + def test_lookup_no_namespace_type(self): """Test lookup of types without a qualified namespace.""" import CLR.Python.Test import CLR - self.assertTrue(self.isCLRClass(CLR.NoNamespaceType)) + self.assertTrue(is_clr_class(CLR.NoNamespaceType)) - def testModuleLookupRecursion(self): + def test_module_lookup_recursion(self): """Test for recursive lookup handling.""" - - def test1(): + with self.assertRaises(ImportError): from CLR import CLR - self.assertRaises(ImportError, test1) - - def test2(): + with self.assertRaises(AttributeError): import CLR - x = CLR.CLR + _ = CLR.CLR - self.assertRaises(AttributeError, test2) - - def testModuleGetAttr(self): + def test_module_get_attr(self): """Test module getattr behavior.""" import CLR.System as System int_type = System.Int32 - self.assertTrue(self.isCLRClass(int_type)) + self.assertTrue(is_clr_class(int_type)) module = System.Xml - self.assertTrue(self.isCLRModule(module)) - - def test(): - spam = System.Spam - - self.assertRaises(AttributeError, test) + self.assertTrue(is_clr_module(module)) - def test(): - spam = getattr(System, 1) + with self.assertRaises(AttributeError): + _ = System.Spam - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + _ = getattr(System, 1) - def test000MultipleImports(self): + def test_multiple_imports(self): # import CLR did raise a Seg Fault once # test if the Exceptions.warn() method still causes it - for n in range(100): + for _ in range(100): import CLR + _ = CLR def test_suite(): return unittest.makeSuite(CompatibilityTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - try: - import System - except ImportError: - print("Load clr import hook") - import clr - - main() diff --git a/src/tests/test_constructors.py b/src/tests/test_constructors.py index 6e02528bb..0039f9bf3 100644 --- a/src/tests/test_constructors.py +++ b/src/tests/test_constructors.py @@ -1,15 +1,14 @@ -import sys, os, string, unittest, types -import clr +# -*- coding: utf-8 -*- + +import unittest -clr.AddReference("Python.Test") -import Python.Test as Test import System class ConstructorTests(unittest.TestCase): """Test CLR class constructor support.""" - def testEnumConstructor(self): + def test_enum_constructor(self): """Test enum constructor args""" from System import TypeCode from Python.Test import EnumConstructorTest @@ -17,7 +16,7 @@ def testEnumConstructor(self): ob = EnumConstructorTest(TypeCode.Int32) self.assertTrue(ob.value == TypeCode.Int32) - def testFlagsConstructor(self): + def test_flags_constructor(self): """Test flags constructor args""" from Python.Test import FlagsConstructorTest from System.IO import FileAccess @@ -26,7 +25,7 @@ def testFlagsConstructor(self): ob = FlagsConstructorTest(flags) self.assertTrue(ob.value == flags) - def testStructConstructor(self): + def test_struct_constructor(self): """Test struct constructor args""" from System import Guid from Python.Test import StructConstructorTest @@ -35,25 +34,17 @@ def testStructConstructor(self): ob = StructConstructorTest(guid) self.assertTrue(ob.value == guid) - def testSubclassConstructor(self): + def test_subclass_constructor(self): """Test subclass constructor args""" from Python.Test import SubclassConstructorTest - class sub(System.Exception): + class Sub(System.Exception): pass - instance = sub() + instance = Sub() ob = SubclassConstructorTest(instance) self.assertTrue(isinstance(ob.value, System.Exception)) def test_suite(): return unittest.makeSuite(ConstructorTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_conversion.py b/src/tests/test_conversion.py index a00a91c48..0d0cd4008 100644 --- a/src/tests/test_conversion.py +++ b/src/tests/test_conversion.py @@ -1,601 +1,475 @@ -import sys, os, string, unittest, types -from Python.Test import ConversionTest +# -*- coding: utf-8 -*- + +import unittest + import System -import six +from Python.Test import ConversionTest -if six.PY3: - long = int - unichr = chr +from _compat import indexbytes, long, unichr class ConversionTests(unittest.TestCase): """Test CLR <-> Python type conversions.""" - def testBoolConversion(self): + def test_bool_conversion(self): """Test bool conversion.""" - object = ConversionTest() - self.assertTrue(object.BooleanField == False) - self.assertTrue(object.BooleanField is False) - self.assertTrue(object.BooleanField == 0) - - object.BooleanField = True - self.assertTrue(object.BooleanField == True) - self.assertTrue(object.BooleanField is True) - self.assertTrue(object.BooleanField == 1) - - object.BooleanField = False - self.assertTrue(object.BooleanField == False) - self.assertTrue(object.BooleanField is False) - self.assertTrue(object.BooleanField == 0) - - object.BooleanField = 1 - self.assertTrue(object.BooleanField == True) - self.assertTrue(object.BooleanField is True) - self.assertTrue(object.BooleanField == 1) - - object.BooleanField = 0 - self.assertTrue(object.BooleanField == False) - self.assertTrue(object.BooleanField is False) - self.assertTrue(object.BooleanField == 0) - - object.BooleanField = System.Boolean(None) - self.assertTrue(object.BooleanField == False) - self.assertTrue(object.BooleanField is False) - self.assertTrue(object.BooleanField == 0) - - object.BooleanField = System.Boolean('') - self.assertTrue(object.BooleanField == False) - self.assertTrue(object.BooleanField is False) - self.assertTrue(object.BooleanField == 0) - - object.BooleanField = System.Boolean(0) - self.assertTrue(object.BooleanField == False) - self.assertTrue(object.BooleanField is False) - self.assertTrue(object.BooleanField == 0) - - object.BooleanField = System.Boolean(1) - self.assertTrue(object.BooleanField == True) - self.assertTrue(object.BooleanField is True) - self.assertTrue(object.BooleanField == 1) - - object.BooleanField = System.Boolean('a') - self.assertTrue(object.BooleanField == True) - self.assertTrue(object.BooleanField is True) - self.assertTrue(object.BooleanField == 1) - - def testSByteConversion(self): + 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) - object = ConversionTest() - self.assertTrue(object.SByteField == 0) + ob = ConversionTest() + self.assertTrue(ob.SByteField == 0) - object.SByteField = 127 - self.assertTrue(object.SByteField == 127) + ob.SByteField = 127 + self.assertTrue(ob.SByteField == 127) - object.SByteField = -128 - self.assertTrue(object.SByteField == -128) + ob.SByteField = -128 + self.assertTrue(ob.SByteField == -128) - object.SByteField = System.SByte(127) - self.assertTrue(object.SByteField == 127) + ob.SByteField = System.SByte(127) + self.assertTrue(ob.SByteField == 127) - object.SByteField = System.SByte(-128) - self.assertTrue(object.SByteField == -128) + ob.SByteField = System.SByte(-128) + self.assertTrue(ob.SByteField == -128) - def test(): + with self.assertRaises(TypeError): ConversionTest().SByteField = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().SByteField = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().SByteField = 128 - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().SByteField = -129 - self.assertRaises(OverflowError, test) - - def test(): - value = System.SByte(128) - - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + _ = System.SByte(128) - def test(): - value = System.SByte(-129) + with self.assertRaises(OverflowError): + _ = System.SByte(-129) - self.assertRaises(OverflowError, test) - - def testByteConversion(self): + def test_byte_conversion(self): """Test byte conversion.""" self.assertTrue(System.Byte.MaxValue == 255) self.assertTrue(System.Byte.MinValue == 0) - object = ConversionTest() - self.assertTrue(object.ByteField == 0) + ob = ConversionTest() + self.assertTrue(ob.ByteField == 0) - object.ByteField = 255 - self.assertTrue(object.ByteField == 255) + ob.ByteField = 255 + self.assertTrue(ob.ByteField == 255) - object.ByteField = 0 - self.assertTrue(object.ByteField == 0) + ob.ByteField = 0 + self.assertTrue(ob.ByteField == 0) - object.ByteField = System.Byte(255) - self.assertTrue(object.ByteField == 255) + ob.ByteField = System.Byte(255) + self.assertTrue(ob.ByteField == 255) - object.ByteField = System.Byte(0) - self.assertTrue(object.ByteField == 0) + ob.ByteField = System.Byte(0) + self.assertTrue(ob.ByteField == 0) - def test(): + with self.assertRaises(TypeError): ConversionTest().ByteField = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().ByteField = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().ByteField = 256 - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().ByteField = -1 - self.assertRaises(OverflowError, test) - - def test(): - value = System.Byte(256) - - self.assertRaises(OverflowError, test) - - def test(): - value = System.Byte(-1) + with self.assertRaises(OverflowError): + _ = System.Byte(256) - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + _ = System.Byte(-1) - def testCharConversion(self): + def test_char_conversion(self): """Test char conversion.""" self.assertTrue(System.Char.MaxValue == unichr(65535)) self.assertTrue(System.Char.MinValue == unichr(0)) - object = ConversionTest() - self.assertTrue(object.CharField == six.u('A')) + ob = ConversionTest() + self.assertTrue(ob.CharField == u'A') - object.CharField = 'B' - self.assertTrue(object.CharField == six.u('B')) + ob.CharField = 'B' + self.assertTrue(ob.CharField == u'B') - object.CharField = six.u('B') - self.assertTrue(object.CharField == six.u('B')) + ob.CharField = u'B' + self.assertTrue(ob.CharField == u'B') - object.CharField = 67 - self.assertTrue(object.CharField == six.u('C')) + ob.CharField = 67 + self.assertTrue(ob.CharField == u'C') - def test(): + with self.assertRaises(OverflowError): ConversionTest().CharField = 65536 - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().CharField = -1 - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().CharField = None - self.assertRaises(TypeError, test) - - def testInt16Conversion(self): + def test_int16_conversion(self): """Test int16 conversion.""" self.assertTrue(System.Int16.MaxValue == 32767) self.assertTrue(System.Int16.MinValue == -32768) - object = ConversionTest() - self.assertTrue(object.Int16Field == 0) + ob = ConversionTest() + self.assertTrue(ob.Int16Field == 0) - object.Int16Field = 32767 - self.assertTrue(object.Int16Field == 32767) + ob.Int16Field = 32767 + self.assertTrue(ob.Int16Field == 32767) - object.Int16Field = -32768 - self.assertTrue(object.Int16Field == -32768) + ob.Int16Field = -32768 + self.assertTrue(ob.Int16Field == -32768) - object.Int16Field = System.Int16(32767) - self.assertTrue(object.Int16Field == 32767) + ob.Int16Field = System.Int16(32767) + self.assertTrue(ob.Int16Field == 32767) - object.Int16Field = System.Int16(-32768) - self.assertTrue(object.Int16Field == -32768) + ob.Int16Field = System.Int16(-32768) + self.assertTrue(ob.Int16Field == -32768) - def test(): + with self.assertRaises(TypeError): ConversionTest().Int16Field = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().Int16Field = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().Int16Field = 32768 - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().Int16Field = -32769 - self.assertRaises(OverflowError, test) - - def test(): - value = System.Int16(32768) - - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + _ = System.Int16(32768) - def test(): - value = System.Int16(-32769) + with self.assertRaises(OverflowError): + _ = System.Int16(-32769) - self.assertRaises(OverflowError, test) - - def testInt32Conversion(self): + def test_int32_conversion(self): """Test int32 conversion.""" self.assertTrue(System.Int32.MaxValue == 2147483647) self.assertTrue(System.Int32.MinValue == -2147483648) - object = ConversionTest() - self.assertTrue(object.Int32Field == 0) + ob = ConversionTest() + self.assertTrue(ob.Int32Field == 0) - object.Int32Field = 2147483647 - self.assertTrue(object.Int32Field == 2147483647) + ob.Int32Field = 2147483647 + self.assertTrue(ob.Int32Field == 2147483647) - object.Int32Field = -2147483648 - self.assertTrue(object.Int32Field == -2147483648) + ob.Int32Field = -2147483648 + self.assertTrue(ob.Int32Field == -2147483648) - object.Int32Field = System.Int32(2147483647) - self.assertTrue(object.Int32Field == 2147483647) + ob.Int32Field = System.Int32(2147483647) + self.assertTrue(ob.Int32Field == 2147483647) - object.Int32Field = System.Int32(-2147483648) - self.assertTrue(object.Int32Field == -2147483648) + ob.Int32Field = System.Int32(-2147483648) + self.assertTrue(ob.Int32Field == -2147483648) - def test(): + with self.assertRaises(TypeError): ConversionTest().Int32Field = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().Int32Field = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().Int32Field = 2147483648 - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().Int32Field = -2147483649 - self.assertRaises(OverflowError, test) - - def test(): - value = System.Int32(2147483648) - - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + _ = System.Int32(2147483648) - def test(): - value = System.Int32(-2147483649) + with self.assertRaises(OverflowError): + _ = System.Int32(-2147483649) - self.assertRaises(OverflowError, test) - - def testInt64Conversion(self): + def test_int64_conversion(self): """Test int64 conversion.""" self.assertTrue(System.Int64.MaxValue == long(9223372036854775807)) self.assertTrue(System.Int64.MinValue == long(-9223372036854775808)) - object = ConversionTest() - self.assertTrue(object.Int64Field == 0) + ob = ConversionTest() + self.assertTrue(ob.Int64Field == 0) - object.Int64Field = long(9223372036854775807) - self.assertTrue(object.Int64Field == long(9223372036854775807)) + ob.Int64Field = long(9223372036854775807) + self.assertTrue(ob.Int64Field == long(9223372036854775807)) - object.Int64Field = long(-9223372036854775808) - self.assertTrue(object.Int64Field == long(-9223372036854775808)) + ob.Int64Field = long(-9223372036854775808) + self.assertTrue(ob.Int64Field == long(-9223372036854775808)) - object.Int64Field = System.Int64(long(9223372036854775807)) - self.assertTrue(object.Int64Field == long(9223372036854775807)) + ob.Int64Field = System.Int64(long(9223372036854775807)) + self.assertTrue(ob.Int64Field == long(9223372036854775807)) - object.Int64Field = System.Int64(long(-9223372036854775808)) - self.assertTrue(object.Int64Field == long(-9223372036854775808)) + ob.Int64Field = System.Int64(long(-9223372036854775808)) + self.assertTrue(ob.Int64Field == long(-9223372036854775808)) - def test(): + with self.assertRaises(TypeError): ConversionTest().Int64Field = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().Int64Field = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().Int64Field = long(9223372036854775808) - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().Int64Field = long(-9223372036854775809) - self.assertRaises(OverflowError, test) - - def test(): - value = System.Int64(long(9223372036854775808)) - - self.assertRaises(OverflowError, test) - - def test(): - value = System.Int64(long(-9223372036854775809)) + with self.assertRaises(OverflowError): + _ = System.Int64(long(9223372036854775808)) - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + _ = System.Int64(long(-9223372036854775809)) - def testUInt16Conversion(self): + def test_uint16_conversion(self): """Test uint16 conversion.""" self.assertTrue(System.UInt16.MaxValue == 65535) self.assertTrue(System.UInt16.MinValue == 0) - object = ConversionTest() - self.assertTrue(object.UInt16Field == 0) + ob = ConversionTest() + self.assertTrue(ob.UInt16Field == 0) - object.UInt16Field = 65535 - self.assertTrue(object.UInt16Field == 65535) + ob.UInt16Field = 65535 + self.assertTrue(ob.UInt16Field == 65535) - object.UInt16Field = -0 - self.assertTrue(object.UInt16Field == 0) + ob.UInt16Field = -0 + self.assertTrue(ob.UInt16Field == 0) - object.UInt16Field = System.UInt16(65535) - self.assertTrue(object.UInt16Field == 65535) + ob.UInt16Field = System.UInt16(65535) + self.assertTrue(ob.UInt16Field == 65535) - object.UInt16Field = System.UInt16(0) - self.assertTrue(object.UInt16Field == 0) + ob.UInt16Field = System.UInt16(0) + self.assertTrue(ob.UInt16Field == 0) - def test(): + with self.assertRaises(TypeError): ConversionTest().UInt16Field = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().UInt16Field = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().UInt16Field = 65536 - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().UInt16Field = -1 - self.assertRaises(OverflowError, test) - - def test(): - value = System.UInt16(65536) - - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + _ = System.UInt16(65536) - def test(): - value = System.UInt16(-1) + with self.assertRaises(OverflowError): + _ = System.UInt16(-1) - self.assertRaises(OverflowError, test) - - def testUInt32Conversion(self): + def test_uint32_conversion(self): """Test uint32 conversion.""" self.assertTrue(System.UInt32.MaxValue == long(4294967295)) self.assertTrue(System.UInt32.MinValue == 0) - object = ConversionTest() - self.assertTrue(object.UInt32Field == 0) + ob = ConversionTest() + self.assertTrue(ob.UInt32Field == 0) - object.UInt32Field = long(4294967295) - self.assertTrue(object.UInt32Field == long(4294967295)) + ob.UInt32Field = long(4294967295) + self.assertTrue(ob.UInt32Field == long(4294967295)) - object.UInt32Field = -0 - self.assertTrue(object.UInt32Field == 0) + ob.UInt32Field = -0 + self.assertTrue(ob.UInt32Field == 0) - object.UInt32Field = System.UInt32(long(4294967295)) - self.assertTrue(object.UInt32Field == long(4294967295)) + ob.UInt32Field = System.UInt32(long(4294967295)) + self.assertTrue(ob.UInt32Field == long(4294967295)) - object.UInt32Field = System.UInt32(0) - self.assertTrue(object.UInt32Field == 0) + ob.UInt32Field = System.UInt32(0) + self.assertTrue(ob.UInt32Field == 0) - def test(): + with self.assertRaises(TypeError): ConversionTest().UInt32Field = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().UInt32Field = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().UInt32Field = long(4294967296) - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().UInt32Field = -1 - self.assertRaises(OverflowError, test) - - def test(): - value = System.UInt32(long(4294967296)) - - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + _ = System.UInt32(long(4294967296)) - def test(): - value = System.UInt32(-1) + with self.assertRaises(OverflowError): + _ = System.UInt32(-1) - self.assertRaises(OverflowError, test) - - def testUInt64Conversion(self): + def test_uint64_conversion(self): """Test uint64 conversion.""" self.assertTrue(System.UInt64.MaxValue == long(18446744073709551615)) self.assertTrue(System.UInt64.MinValue == 0) - object = ConversionTest() - self.assertTrue(object.UInt64Field == 0) + ob = ConversionTest() + self.assertTrue(ob.UInt64Field == 0) - object.UInt64Field = long(18446744073709551615) - self.assertTrue(object.UInt64Field == long(18446744073709551615)) + ob.UInt64Field = long(18446744073709551615) + self.assertTrue(ob.UInt64Field == long(18446744073709551615)) - object.UInt64Field = -0 - self.assertTrue(object.UInt64Field == 0) + ob.UInt64Field = -0 + self.assertTrue(ob.UInt64Field == 0) - object.UInt64Field = System.UInt64(long(18446744073709551615)) - self.assertTrue(object.UInt64Field == long(18446744073709551615)) + ob.UInt64Field = System.UInt64(long(18446744073709551615)) + self.assertTrue(ob.UInt64Field == long(18446744073709551615)) - object.UInt64Field = System.UInt64(0) - self.assertTrue(object.UInt64Field == 0) + ob.UInt64Field = System.UInt64(0) + self.assertTrue(ob.UInt64Field == 0) - def test(): + with self.assertRaises(TypeError): ConversionTest().UInt64Field = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().UInt64Field = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().UInt64Field = long(18446744073709551616) - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().UInt64Field = -1 - self.assertRaises(OverflowError, test) - - def test(): - value = System.UInt64(long(18446744073709551616)) + with self.assertRaises(OverflowError): + _ = System.UInt64(long(18446744073709551616)) - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + _ = System.UInt64(-1) - def test(): - value = System.UInt64(-1) - - self.assertRaises(OverflowError, test) - - def testSingleConversion(self): + def test_single_conversion(self): """Test single conversion.""" self.assertTrue(System.Single.MaxValue == 3.402823e38) self.assertTrue(System.Single.MinValue == -3.402823e38) - object = ConversionTest() - self.assertTrue(object.SingleField == 0.0) + ob = ConversionTest() + self.assertTrue(ob.SingleField == 0.0) - object.SingleField = 3.402823e38 - self.assertTrue(object.SingleField == 3.402823e38) + ob.SingleField = 3.402823e38 + self.assertTrue(ob.SingleField == 3.402823e38) - object.SingleField = -3.402823e38 - self.assertTrue(object.SingleField == -3.402823e38) + ob.SingleField = -3.402823e38 + self.assertTrue(ob.SingleField == -3.402823e38) - object.SingleField = System.Single(3.402823e38) - self.assertTrue(object.SingleField == 3.402823e38) + ob.SingleField = System.Single(3.402823e38) + self.assertTrue(ob.SingleField == 3.402823e38) - object.SingleField = System.Single(-3.402823e38) - self.assertTrue(object.SingleField == -3.402823e38) + ob.SingleField = System.Single(-3.402823e38) + self.assertTrue(ob.SingleField == -3.402823e38) - def test(): + with self.assertRaises(TypeError): ConversionTest().SingleField = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().SingleField = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().SingleField = 3.402824e38 - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().SingleField = -3.402824e38 - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + _ = System.Single(3.402824e38) - def test(): - value = System.Single(3.402824e38) + with self.assertRaises(OverflowError): + _ = System.Single(-3.402824e38) - self.assertRaises(OverflowError, test) - - def test(): - value = System.Single(-3.402824e38) - - self.assertRaises(OverflowError, test) - - def testDoubleConversion(self): + def test_double_conversion(self): """Test double conversion.""" self.assertTrue(System.Double.MaxValue == 1.7976931348623157e308) self.assertTrue(System.Double.MinValue == -1.7976931348623157e308) - object = ConversionTest() - self.assertTrue(object.DoubleField == 0.0) + ob = ConversionTest() + self.assertTrue(ob.DoubleField == 0.0) - object.DoubleField = 1.7976931348623157e308 - self.assertTrue(object.DoubleField == 1.7976931348623157e308) + ob.DoubleField = 1.7976931348623157e308 + self.assertTrue(ob.DoubleField == 1.7976931348623157e308) - object.DoubleField = -1.7976931348623157e308 - self.assertTrue(object.DoubleField == -1.7976931348623157e308) + ob.DoubleField = -1.7976931348623157e308 + self.assertTrue(ob.DoubleField == -1.7976931348623157e308) - object.DoubleField = System.Double(1.7976931348623157e308) - self.assertTrue(object.DoubleField == 1.7976931348623157e308) + ob.DoubleField = System.Double(1.7976931348623157e308) + self.assertTrue(ob.DoubleField == 1.7976931348623157e308) - object.DoubleField = System.Double(-1.7976931348623157e308) - self.assertTrue(object.DoubleField == -1.7976931348623157e308) + ob.DoubleField = System.Double(-1.7976931348623157e308) + self.assertTrue(ob.DoubleField == -1.7976931348623157e308) - def test(): + with self.assertRaises(TypeError): ConversionTest().DoubleField = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().DoubleField = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().DoubleField = 1.7976931348623159e308 - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(OverflowError): ConversionTest().DoubleField = -1.7976931348623159e308 - self.assertRaises(OverflowError, test) - - def test(): - value = System.Double(1.7976931348623159e308) - - self.assertRaises(OverflowError, test) + with self.assertRaises(OverflowError): + _ = System.Double(1.7976931348623159e308) - def test(): - value = System.Double(-1.7976931348623159e308) + with self.assertRaises(OverflowError): + _ = System.Double(-1.7976931348623159e308) - self.assertRaises(OverflowError, test) - - def testDecimalConversion(self): + def test_decimal_conversion(self): """Test decimal conversion.""" from System import Decimal @@ -604,241 +478,207 @@ def testDecimalConversion(self): self.assertTrue(Decimal.ToInt64(Decimal(10)) == long(10)) - object = ConversionTest() - self.assertTrue(object.DecimalField == Decimal(0)) + ob = ConversionTest() + self.assertTrue(ob.DecimalField == Decimal(0)) - object.DecimalField = Decimal(10) - self.assertTrue(object.DecimalField == Decimal(10)) + ob.DecimalField = Decimal(10) + self.assertTrue(ob.DecimalField == Decimal(10)) - object.DecimalField = Decimal.One - self.assertTrue(object.DecimalField == Decimal.One) + ob.DecimalField = Decimal.One + self.assertTrue(ob.DecimalField == Decimal.One) - object.DecimalField = Decimal.Zero - self.assertTrue(object.DecimalField == Decimal.Zero) + ob.DecimalField = Decimal.Zero + self.assertTrue(ob.DecimalField == Decimal.Zero) - object.DecimalField = max_d - self.assertTrue(object.DecimalField == max_d) + ob.DecimalField = max_d + self.assertTrue(ob.DecimalField == max_d) - object.DecimalField = min_d - self.assertTrue(object.DecimalField == min_d) + ob.DecimalField = min_d + self.assertTrue(ob.DecimalField == min_d) - def test(): + with self.assertRaises(TypeError): ConversionTest().DecimalField = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().DecimalField = "spam" - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().DecimalField = 1 - self.assertRaises(TypeError, test) - - def testStringConversion(self): + def test_string_conversion(self): """Test string / unicode conversion.""" - object = ConversionTest() + ob = ConversionTest() - self.assertTrue(object.StringField == "spam") - self.assertTrue(object.StringField == six.u("spam")) + self.assertTrue(ob.StringField == "spam") + self.assertTrue(ob.StringField == u"spam") - object.StringField = "eggs" - self.assertTrue(object.StringField == "eggs") - self.assertTrue(object.StringField == six.u("eggs")) + ob.StringField = "eggs" + self.assertTrue(ob.StringField == "eggs") + self.assertTrue(ob.StringField == u"eggs") - object.StringField = six.u("spam") - self.assertTrue(object.StringField == "spam") - self.assertTrue(object.StringField == six.u("spam")) + ob.StringField = u"spam" + self.assertTrue(ob.StringField == "spam") + self.assertTrue(ob.StringField == u"spam") - object.StringField = six.u('\uffff\uffff') - self.assertTrue(object.StringField == six.u('\uffff\uffff')) + ob.StringField = u'\uffff\uffff' + self.assertTrue(ob.StringField == u'\uffff\uffff') - object.StringField = System.String("spam") - self.assertTrue(object.StringField == "spam") - self.assertTrue(object.StringField == six.u("spam")) + ob.StringField = System.String("spam") + self.assertTrue(ob.StringField == "spam") + self.assertTrue(ob.StringField == u"spam") - object.StringField = System.String(six.u('\uffff\uffff')) - self.assertTrue(object.StringField == six.u('\uffff\uffff')) + ob.StringField = System.String(u'\uffff\uffff') + self.assertTrue(ob.StringField == u'\uffff\uffff') - object.StringField = None - self.assertTrue(object.StringField == None) + ob.StringField = None + self.assertTrue(ob.StringField is None) - def test(): + with self.assertRaises(TypeError): ConversionTest().StringField = 1 - self.assertRaises(TypeError, test) - - def testInterfaceConversion(self): + def test_interface_conversion(self): """Test interface conversion.""" from Python.Test import Spam, ISpam - object = ConversionTest() + ob = ConversionTest() - self.assertTrue(ISpam(object.SpamField).GetValue() == "spam") - self.assertTrue(object.SpamField.GetValue() == "spam") + self.assertTrue(ISpam(ob.SpamField).GetValue() == "spam") + self.assertTrue(ob.SpamField.GetValue() == "spam") - object.SpamField = Spam("eggs") - self.assertTrue(ISpam(object.SpamField).GetValue() == "eggs") - self.assertTrue(object.SpamField.GetValue() == "eggs") + ob.SpamField = Spam("eggs") + self.assertTrue(ISpam(ob.SpamField).GetValue() == "eggs") + self.assertTrue(ob.SpamField.GetValue() == "eggs") # need to test spam subclass here. - object.SpamField = None - self.assertTrue(object.SpamField == None) - - def test(): - object = ConversionTest() - object.SpamField = System.String("bad") + ob.SpamField = None + self.assertTrue(ob.SpamField is None) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = ConversionTest() + ob.SpamField = System.String("bad") - def test(): - object = ConversionTest() - object.SpamField = System.Int32(1) + with self.assertRaises(TypeError): + ob = ConversionTest() + ob.SpamField = System.Int32(1) - self.assertRaises(TypeError, test) - - def testObjectConversion(self): - """Test object conversion.""" + def test_object_conversion(self): + """Test ob conversion.""" from Python.Test import Spam - object = ConversionTest() - self.assertTrue(object.ObjectField == None) + ob = ConversionTest() + self.assertTrue(ob.ObjectField is None) - object.ObjectField = Spam("eggs") - self.assertTrue(object.ObjectField.__class__.__name__ == "Spam") - self.assertTrue(object.ObjectField.GetValue() == "eggs") + ob.ObjectField = Spam("eggs") + self.assertTrue(ob.ObjectField.__class__.__name__ == "Spam") + self.assertTrue(ob.ObjectField.GetValue() == "eggs") - object.ObjectField = None - self.assertTrue(object.ObjectField == None) + ob.ObjectField = None + self.assertTrue(ob.ObjectField is None) - object.ObjectField = System.String("spam") - self.assertTrue(object.ObjectField == "spam") + ob.ObjectField = System.String("spam") + self.assertTrue(ob.ObjectField == "spam") - object.ObjectField = System.Int32(1) - self.assertTrue(object.ObjectField == 1) + ob.ObjectField = System.Int32(1) + self.assertTrue(ob.ObjectField == 1) # need to test subclass here - def test(): - object = ConversionTest() - object.ObjectField = self - - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = ConversionTest() + ob.ObjectField = self - def testEnumConversion(self): + def test_enum_conversion(self): """Test enum conversion.""" from Python.Test import ShortEnum - object = ConversionTest() - self.assertTrue(object.EnumField == ShortEnum.Zero) + ob = ConversionTest() + self.assertTrue(ob.EnumField == ShortEnum.Zero) - object.EnumField = ShortEnum.One - self.assertTrue(object.EnumField == ShortEnum.One) + ob.EnumField = ShortEnum.One + self.assertTrue(ob.EnumField == ShortEnum.One) - object.EnumField = 0 - self.assertTrue(object.EnumField == ShortEnum.Zero) - self.assertTrue(object.EnumField == 0) + ob.EnumField = 0 + self.assertTrue(ob.EnumField == ShortEnum.Zero) + self.assertTrue(ob.EnumField == 0) - object.EnumField = 1 - self.assertTrue(object.EnumField == ShortEnum.One) - self.assertTrue(object.EnumField == 1) + ob.EnumField = 1 + self.assertTrue(ob.EnumField == ShortEnum.One) + self.assertTrue(ob.EnumField == 1) - def test(): - object = ConversionTest() - object.EnumField = 10 + with self.assertRaises(ValueError): + ob = ConversionTest() + ob.EnumField = 10 - self.assertRaises(ValueError, test) + with self.assertRaises(ValueError): + ob = ConversionTest() + ob.EnumField = 255 - def test(): - object = ConversionTest() - object.EnumField = 255 + with self.assertRaises(OverflowError): + ob = ConversionTest() + ob.EnumField = 1000000 - self.assertRaises(ValueError, test) + with self.assertRaises(TypeError): + ob = ConversionTest() + ob.EnumField = "spam" - def test(): - object = ConversionTest() - object.EnumField = 1000000 - - self.assertRaises(OverflowError, test) - - def test(): - object = ConversionTest() - object.EnumField = "spam" - - self.assertRaises(TypeError, test) - - def testNullConversion(self): + def test_null_conversion(self): """Test null conversion.""" - object = ConversionTest() + ob = ConversionTest() - object.StringField = None - self.assertTrue(object.StringField == None) + ob.StringField = None + self.assertTrue(ob.StringField is None) - object.ObjectField = None - self.assertTrue(object.ObjectField == None) + ob.ObjectField = None + self.assertTrue(ob.ObjectField is None) - object.SpamField = None - self.assertTrue(object.SpamField == None) + ob.SpamField = None + self.assertTrue(ob.SpamField is None) # Primitive types and enums should not be set to null. - def test(): + with self.assertRaises(TypeError): ConversionTest().Int32Field = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): ConversionTest().EnumField = None - self.assertRaises(TypeError, test) - - def testByteArrayConversion(self): + def test_byte_array_conversion(self): """Test byte array conversion.""" - object = ConversionTest() + ob = ConversionTest() - self.assertTrue(object.ByteArrayField == None) + self.assertTrue(ob.ByteArrayField is None) - object.ByteArrayField = [0, 1, 2, 3, 4] - array = object.ByteArrayField + 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) - value = six.b("testing") - object.ByteArrayField = value - array = object.ByteArrayField - for i in range(len(value)): - self.assertTrue(array[i] == six.indexbytes(value, i)) + value = b"testing" + ob.ByteArrayField = value + array = ob.ByteArrayField + for i, _ in enumerate(value): + self.assertTrue(array[i] == indexbytes(value, i)) - def testSByteArrayConversion(self): + def test_sbyte_array_conversion(self): """Test sbyte array conversion.""" - object = ConversionTest() + ob = ConversionTest() - self.assertTrue(object.SByteArrayField == None) + self.assertTrue(ob.SByteArrayField is None) - object.SByteArrayField = [0, 1, 2, 3, 4] - array = object.SByteArrayField + 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) - value = six.b("testing") - object.SByteArrayField = value - array = object.SByteArrayField - for i in range(len(value)): - self.assertTrue(array[i] == six.indexbytes(value, i)) + value = b"testing" + ob.SByteArrayField = value + array = ob.SByteArrayField + for i, _ in enumerate(value): + self.assertTrue(array[i] == indexbytes(value, i)) def test_suite(): return unittest.makeSuite(ConversionTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_delegate.py b/src/tests/test_delegate.py index 26b85ec5e..4963a09b8 100644 --- a/src/tests/test_delegate.py +++ b/src/tests/test_delegate.py @@ -1,49 +1,43 @@ -import clr +# -*- coding: utf-8 -*- +# TODO: Add test for ObjectDelegate -clr.AddReference('Python.Test') +import unittest -from Python.Test import DelegateTest, PublicDelegate -from Python.Test import StringDelegate, ObjectDelegate -from Python.Test import BoolDelegate -import sys, os, string, unittest, types import Python.Test as Test import System -import six +from Python.Test import DelegateTest, StringDelegate -if six.PY3: - DictProxyType = type(object.__dict__) -else: - DictProxyType = types.DictProxyType +from _compat import DictProxyType +from utils import HelloClass, hello_func, MultipleHandler class DelegateTests(unittest.TestCase): """Test CLR delegate support.""" - def testDelegateStandardAttrs(self): + def test_delegate_standard_attrs(self): """Test standard delegate attributes.""" + from Python.Test import PublicDelegate + self.assertTrue(PublicDelegate.__name__ == 'PublicDelegate') self.assertTrue(PublicDelegate.__module__ == 'Python.Test') - self.assertTrue(type(PublicDelegate.__dict__) == DictProxyType) - self.assertTrue(PublicDelegate.__doc__ == None) + self.assertTrue(isinstance(PublicDelegate.__dict__, DictProxyType)) + self.assertTrue(PublicDelegate.__doc__ is None) - def testGlobalDelegateVisibility(self): + def test_global_delegate_visibility(self): """Test visibility of module-level delegates.""" from Python.Test import PublicDelegate self.assertTrue(PublicDelegate.__name__ == 'PublicDelegate') self.assertTrue(Test.PublicDelegate.__name__ == 'PublicDelegate') - def test(): + with self.assertRaises(ImportError): from Python.Test import InternalDelegate + _ = InternalDelegate - self.assertRaises(ImportError, test) - - def test(): - i = Test.InternalDelegate - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = Test.InternalDelegate - def testNestedDelegateVisibility(self): + def test_nested_delegate_visibility(self): """Test visibility of nested delegates.""" ob = DelegateTest.PublicDelegate self.assertTrue(ob.__name__ == 'PublicDelegate') @@ -51,23 +45,16 @@ def testNestedDelegateVisibility(self): ob = DelegateTest.ProtectedDelegate self.assertTrue(ob.__name__ == 'ProtectedDelegate') - def test(): - ob = DelegateTest.InternalDelegate + with self.assertRaises(AttributeError): + _ = DelegateTest.InternalDelegate - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = DelegateTest.PrivateDelegate - def test(): - ob = DelegateTest.PrivateDelegate - - self.assertRaises(AttributeError, test) - - def testDelegateFromFunction(self): + def test_delegate_from_function(self): """Test delegate implemented with a Python function.""" - def sayhello(): - return "hello" - - d = StringDelegate(sayhello) + d = StringDelegate(hello_func) ob = DelegateTest() self.assertTrue(ob.CallStringDelegate(d) == "hello") @@ -77,15 +64,11 @@ def sayhello(): self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") self.assertTrue(ob.stringDelegate() == "hello") - def testDelegateFromMethod(self): + def test_delegate_from_method(self): """Test delegate implemented with a Python instance method.""" - class Hello: - def sayhello(self): - return "hello" - - inst = Hello() - d = StringDelegate(inst.sayhello) + inst = HelloClass() + d = StringDelegate(inst.hello) ob = DelegateTest() self.assertTrue(ob.CallStringDelegate(d) == "hello") @@ -95,29 +78,17 @@ def sayhello(self): self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") self.assertTrue(ob.stringDelegate() == "hello") - def testDelegateFromUnboundMethod(self): + def test_delegate_from_unbound_method(self): """Test failure mode for unbound methods.""" - class Hello: - def sayhello(self): - return "hello" - - def test(): - d = StringDelegate(Hello.sayhello) + with self.assertRaises(TypeError): + d = StringDelegate(HelloClass.hello) d() - self.assertRaises(TypeError, test) - - def testDelegateFromStaticMethod(self): + def test_delegate_from_static_method(self): """Test delegate implemented with a Python static method.""" - class Hello: - def sayhello(): - return "hello" - - sayhello = staticmethod(sayhello) - - d = StringDelegate(Hello.sayhello) + d = StringDelegate(HelloClass.s_hello) ob = DelegateTest() self.assertTrue(ob.CallStringDelegate(d) == "hello") @@ -127,8 +98,8 @@ def sayhello(): self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") self.assertTrue(ob.stringDelegate() == "hello") - inst = Hello() - d = StringDelegate(inst.sayhello) + inst = HelloClass() + d = StringDelegate(inst.s_hello) ob = DelegateTest() self.assertTrue(ob.CallStringDelegate(d) == "hello") @@ -138,16 +109,10 @@ def sayhello(): self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") self.assertTrue(ob.stringDelegate() == "hello") - def testDelegateFromClassMethod(self): + def test_delegate_from_class_method(self): """Test delegate implemented with a Python class method.""" - class Hello: - def sayhello(self): - return "hello" - - sayhello = classmethod(sayhello) - - d = StringDelegate(Hello.sayhello) + d = StringDelegate(HelloClass.c_hello) ob = DelegateTest() self.assertTrue(ob.CallStringDelegate(d) == "hello") @@ -157,8 +122,8 @@ def sayhello(self): self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") self.assertTrue(ob.stringDelegate() == "hello") - inst = Hello() - d = StringDelegate(inst.sayhello) + inst = HelloClass() + d = StringDelegate(inst.c_hello) ob = DelegateTest() self.assertTrue(ob.CallStringDelegate(d) == "hello") @@ -168,14 +133,10 @@ def sayhello(self): self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") self.assertTrue(ob.stringDelegate() == "hello") - def testDelegateFromCallable(self): + def test_delegate_from_callable(self): """Test delegate implemented with a Python callable object.""" - class Hello: - def __call__(self): - return "hello" - - inst = Hello() + inst = HelloClass() d = StringDelegate(inst) ob = DelegateTest() @@ -186,7 +147,7 @@ def __call__(self): self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") self.assertTrue(ob.stringDelegate() == "hello") - def testDelegateFromManagedInstanceMethod(self): + def test_delegate_from_managed_instance_method(self): """Test delegate implemented with a managed instance method.""" ob = DelegateTest() d = StringDelegate(ob.SayHello) @@ -198,7 +159,7 @@ def testDelegateFromManagedInstanceMethod(self): self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") self.assertTrue(ob.stringDelegate() == "hello") - def testDelegateFromManagedStaticMethod(self): + def test_delegate_from_managed_static_method(self): """Test delegate implemented with a managed static method.""" d = StringDelegate(DelegateTest.StaticSayHello) ob = DelegateTest() @@ -210,13 +171,9 @@ def testDelegateFromManagedStaticMethod(self): self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") self.assertTrue(ob.stringDelegate() == "hello") - def testDelegateFromDelegate(self): + def test_delegate_from_delegate(self): """Test delegate implemented with another delegate.""" - - def sayhello(): - return "hello" - - d1 = StringDelegate(sayhello) + d1 = StringDelegate(hello_func) d2 = StringDelegate(d1) ob = DelegateTest() @@ -227,36 +184,22 @@ def sayhello(): self.assertTrue(ob.CallStringDelegate(ob.stringDelegate) == "hello") self.assertTrue(ob.stringDelegate() == "hello") - def testDelegateWithInvalidArgs(self): + def test_delegate_with_invalid_args(self): """Test delegate instantiation with invalid (non-callable) args.""" - def test(): - d = StringDelegate(None) - - self.assertRaises(TypeError, test) - - def test(): - d = StringDelegate("spam") + with self.assertRaises(TypeError): + _ = StringDelegate(None) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + _ = StringDelegate("spam") - def test(): - d = StringDelegate(1) + with self.assertRaises(TypeError): + _ = StringDelegate(1) - self.assertRaises(TypeError, test) - - def testMulticastDelegate(self): + def test_multicast_delegate(self): """Test multicast delegates.""" - class Multi: - def __init__(self): - self.value = 0 - - def count(self): - self.value += 1 - return 'ok' - - inst = Multi() + inst = MultipleHandler() d1 = StringDelegate(inst.count) d2 = StringDelegate(inst.count) @@ -269,28 +212,26 @@ def count(self): self.assertTrue(md() == "ok") self.assertTrue(inst.value == 4) - def testSubclassDelegateFails(self): + def test_subclass_delegate_fails(self): """Test that subclassing of a delegate type fails.""" + from Python.Test import PublicDelegate - def test(): + with self.assertRaises(TypeError): class Boom(PublicDelegate): pass + _ = Boom - self.assertRaises(TypeError, test) - - def testDelegateEquality(self): + def test_delegate_equality(self): """Test delegate equality.""" - def sayhello(): - return "hello" - - d = StringDelegate(sayhello) + d = StringDelegate(hello_func) ob = DelegateTest() ob.stringDelegate = d self.assertTrue(ob.stringDelegate == d) - def testBoolDelegate(self): + def test_bool_delegate(self): """Test boolean delegate.""" + from Python.Test import BoolDelegate def always_so_negative(): return 0 @@ -300,7 +241,6 @@ def always_so_negative(): ob.CallBoolDelegate(d) self.assertTrue(not d()) - self.assertTrue(not ob.CallBoolDelegate(d)) # test async delegates @@ -316,11 +256,3 @@ def always_so_negative(): def test_suite(): return unittest.makeSuite(DelegateTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_docstring.py b/src/tests/test_docstring.py index 9eaea09bb..f2bc3302b 100644 --- a/src/tests/test_docstring.py +++ b/src/tests/test_docstring.py @@ -1,25 +1,28 @@ -import unittest -import clr - -clr.AddReference('Python.Test') +# -*- coding: utf-8 -*- -from Python.Test import DocWithCtorTest, DocWithoutCtorTest, DocWithCtorNoDocTest +import unittest class DocStringTests(unittest.TestCase): """Test doc strings support.""" - def testDocWithCtor(self): + def test_doc_with_ctor(self): + from Python.Test import DocWithCtorTest + self.assertEqual(DocWithCtorTest.__doc__, 'DocWithCtorTest Class') self.assertEqual(DocWithCtorTest.TestMethod.__doc__, 'DocWithCtorTest TestMethod') self.assertEqual(DocWithCtorTest.StaticTestMethod.__doc__, 'DocWithCtorTest StaticTestMethod') - def testDocWithCtorNoDoc(self): + def test_doc_with_ctor_no_doc(self): + 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)') - def testDocWithoutCtor(self): + 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') @@ -27,11 +30,3 @@ def testDocWithoutCtor(self): def test_suite(): return unittest.makeSuite(DocStringTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_engine.py b/src/tests/test_engine.py index 43437c779..b605a3796 100644 --- a/src/tests/test_engine.py +++ b/src/tests/test_engine.py @@ -1,25 +1,33 @@ -import sys, os, string, unittest, types -from Python.Runtime import PythonEngine +# -*- coding: utf-8 -*- + +import sys +import unittest +import System +from Python.Runtime import PythonEngine -# XXX This test module isn't used! class EngineTests(unittest.TestCase): """Test PythonEngine embedding APIs.""" - def testMultipleCallsToInitialize(self): + def test_multiple_calls_to_initialize(self): """Test that multiple initialize calls are harmless.""" - PythonEngine.Initialize(); - PythonEngine.Initialize(); - PythonEngine.Initialize(); - - def testImportModule(self): + 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") - def testRunString(self): + @unittest.skip(reason="FIXME: test freezes") + def test_run_string(self): """Test the RunString method.""" PythonEngine.AcquireLock() @@ -36,11 +44,3 @@ def testRunString(self): def test_suite(): return unittest.makeSuite(EngineTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_enum.py b/src/tests/test_enum.py index fae32bbe6..e7147e69c 100644 --- a/src/tests/test_enum.py +++ b/src/tests/test_enum.py @@ -1,27 +1,28 @@ -import sys, os, string, unittest, types -from System import DayOfWeek -from Python import Test -import six +# -*- coding: utf-8 -*- -if six.PY3: - DictProxyType = type(object.__dict__) - long = int -else: - DictProxyType = types.DictProxyType +import unittest + +import Python.Test as Test + +from _compat import DictProxyType, long class EnumTests(unittest.TestCase): """Test CLR enum support.""" - def testEnumStandardAttrs(self): + 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(type(DayOfWeek.__dict__) == DictProxyType) - self.assertTrue(DayOfWeek.__doc__ == None) + self.assertTrue(isinstance(DayOfWeek.__dict__, DictProxyType)) + self.assertTrue(DayOfWeek.__doc__ is None) - def testEnumGetMember(self): + 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) @@ -30,126 +31,106 @@ def testEnumGetMember(self): self.assertTrue(DayOfWeek.Friday == 5) self.assertTrue(DayOfWeek.Saturday == 6) - def testByteEnum(self): + 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 testSByteEnum(self): + 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 testShortEnum(self): + 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 testUShortEnum(self): + 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 testIntEnum(self): + 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 testUIntEnum(self): + 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 testLongEnum(self): + 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 testULongEnum(self): + 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 testInstantiateEnumFails(self): + def test_instantiate_enum_fails(self): """Test that instantiation of an enum class fails.""" + from System import DayOfWeek - def test(): - ob = DayOfWeek() + with self.assertRaises(TypeError): + _ = DayOfWeek() - self.assertRaises(TypeError, test) - - def testSubclassEnumFails(self): + def test_subclass_enum_fails(self): """Test that subclassing of an enumeration fails.""" + from System import DayOfWeek - def test(): + with self.assertRaises(TypeError): class Boom(DayOfWeek): pass + _ = Boom - self.assertRaises(TypeError, test) - - def testEnumSetMemberFails(self): + def test_enum_set_member_fails(self): """Test that setattr operations on enumerations fail.""" + from System import DayOfWeek - def test(): + with self.assertRaises(TypeError): DayOfWeek.Sunday = 13 - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del DayOfWeek.Sunday - self.assertRaises(TypeError, test) - - def testEnumWithFlagsAttrConversion(self): + 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. - def test(): + with self.assertRaises(ValueError): Test.FieldTest().EnumField = 99 - self.assertRaises(ValueError, test) - - def testEnumConversion(self): + def test_enum_conversion(self): """Test enumeration conversion.""" - object = Test.FieldTest() - self.assertTrue(object.EnumField == 0) + ob = Test.FieldTest() + self.assertTrue(ob.EnumField == 0) - object.EnumField = Test.ShortEnum.One - self.assertTrue(object.EnumField == 1) + ob.EnumField = Test.ShortEnum.One + self.assertTrue(ob.EnumField == 1) - def test(): + with self.assertRaises(ValueError): Test.FieldTest().EnumField = 20 - self.assertRaises(ValueError, test) - - def test(): + with self.assertRaises(OverflowError): Test.FieldTest().EnumField = 100000 - self.assertRaises(OverflowError, test) - - def test(): + with self.assertRaises(TypeError): Test.FieldTest().EnumField = "str" - self.assertRaises(TypeError, test) - def test_suite(): return unittest.makeSuite(EnumTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_event.py b/src/tests/test_event.py index c68f9629a..047af47f3 100644 --- a/src/tests/test_event.py +++ b/src/tests/test_event.py @@ -1,437 +1,418 @@ -import clr +# -*- coding: utf-8 -*- -clr.AddReference('Python.Test') +import unittest -import sys, os, string, unittest, types -from Python.Test import EventTest, TestEventHandler -from Python.Test import TestEventArgs +from Python.Test import EventTest, EventArgsTest + +from _compat import range +from utils import (CallableHandler, ClassMethodHandler, GenericHandler, + MultipleHandler, StaticMethodHandler, VarCallableHandler, + VariableArgsHandler) class EventTests(unittest.TestCase): """Test CLR event support.""" - def testPublicInstanceEvent(self): + def test_public_instance_event(self): """Test public instance events.""" - object = EventTest() + ob = EventTest() handler = GenericHandler() - self.assertTrue(handler.value == None) + self.assertTrue(handler.value is None) - object.PublicEvent += handler.handler + ob.PublicEvent += handler.handler - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) - object.PublicEvent -= handler.handler + ob.PublicEvent -= handler.handler - def testPublicStaticEvent(self): + def test_public_static_event(self): """Test public static events.""" handler = GenericHandler() - self.assertTrue(handler.value == None) + self.assertTrue(handler.value is None) EventTest.PublicStaticEvent += handler.handler - EventTest.OnPublicStaticEvent(TestEventArgs(10)) + EventTest.OnPublicStaticEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) - def testProtectedInstanceEvent(self): + def test_protected_instance_event(self): """Test protected instance events.""" - object = EventTest() + ob = EventTest() handler = GenericHandler() - self.assertTrue(handler.value == None) + self.assertTrue(handler.value is None) - object.ProtectedEvent += handler.handler + ob.ProtectedEvent += handler.handler - object.OnProtectedEvent(TestEventArgs(10)) + ob.OnProtectedEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) - object.ProtectedEvent -= handler.handler + ob.ProtectedEvent -= handler.handler - def testProtectedStaticEvent(self): + def test_protected_static_event(self): """Test protected static events.""" - object = EventTest - handler = GenericHandler() - self.assertTrue(handler.value == None) + self.assertTrue(handler.value is None) EventTest.ProtectedStaticEvent += handler.handler - EventTest.OnProtectedStaticEvent(TestEventArgs(10)) + EventTest.OnProtectedStaticEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) EventTest.ProtectedStaticEvent -= handler.handler - def testInternalEvents(self): + def test_internal_events(self): """Test internal events.""" - def test(): - f = EventTest().InternalEvent - - self.assertRaises(AttributeError, test) - - def test(): - f = EventTest().InternalStaticEvent + with self.assertRaises(AttributeError): + _ = EventTest().InternalEvent - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = EventTest().InternalStaticEvent - def test(): - f = EventTest.InternalStaticEvent + with self.assertRaises(AttributeError): + _ = EventTest.InternalStaticEvent - self.assertRaises(AttributeError, test) - - def testPrivateEvents(self): + def test_private_events(self): """Test private events.""" - def test(): - f = EventTest().PrivateEvent - - self.assertRaises(AttributeError, test) - - def test(): - f = EventTest().PrivateStaticEvent - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = EventTest().PrivateEvent - def test(): - f = EventTest.PrivateStaticEvent + with self.assertRaises(AttributeError): + _ = EventTest().PrivateStaticEvent - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = EventTest.PrivateStaticEvent - def testMulticastEvent(self): + def test_multicast_event(self): """Test multicast events.""" - object = EventTest() + ob = EventTest() handler1 = GenericHandler() handler2 = GenericHandler() handler3 = GenericHandler() - object.PublicEvent += handler1.handler - object.PublicEvent += handler2.handler - object.PublicEvent += handler3.handler + ob.PublicEvent += handler1.handler + ob.PublicEvent += handler2.handler + ob.PublicEvent += handler3.handler - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler1.value == 10) self.assertTrue(handler2.value == 10) self.assertTrue(handler3.value == 10) - object.OnPublicEvent(TestEventArgs(20)) + ob.OnPublicEvent(EventArgsTest(20)) self.assertTrue(handler1.value == 20) self.assertTrue(handler2.value == 20) self.assertTrue(handler3.value == 20) - object.PublicEvent -= handler1.handler - object.PublicEvent -= handler2.handler - object.PublicEvent -= handler3.handler + ob.PublicEvent -= handler1.handler + ob.PublicEvent -= handler2.handler + ob.PublicEvent -= handler3.handler - def testInstanceMethodHandler(self): + def test_instance_method_handler(self): """Test instance method handlers.""" - object = EventTest() + ob = EventTest() handler = GenericHandler() - object.PublicEvent += handler.handler - self.assertTrue(handler.value == None) + ob.PublicEvent += handler.handler + self.assertTrue(handler.value is None) - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) - object.PublicEvent -= handler.handler + ob.PublicEvent -= handler.handler self.assertTrue(handler.value == 10) - object.OnPublicEvent(TestEventArgs(20)) + ob.OnPublicEvent(EventArgsTest(20)) self.assertTrue(handler.value == 10) - def testVarArgsInstanceMethodHandler(self): + def test_var_args_instance_method_handler(self): """Test vararg instance method handlers.""" - object = EventTest() + ob = EventTest() handler = VariableArgsHandler() - object.PublicEvent += handler.handler - self.assertTrue(handler.value == None) + ob.PublicEvent += handler.handler + self.assertTrue(handler.value is None) - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) - object.PublicEvent -= handler.handler + ob.PublicEvent -= handler.handler self.assertTrue(handler.value == 10) - object.OnPublicEvent(TestEventArgs(20)) + ob.OnPublicEvent(EventArgsTest(20)) self.assertTrue(handler.value == 10) - def testCallableObjectHandler(self): - """Test callable object handlers.""" - object = EventTest() + def test_callableob_handler(self): + """Test callable ob handlers.""" + ob = EventTest() handler = CallableHandler() - object.PublicEvent += handler - self.assertTrue(handler.value == None) + ob.PublicEvent += handler + self.assertTrue(handler.value is None) - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) - object.PublicEvent -= handler + ob.PublicEvent -= handler self.assertTrue(handler.value == 10) - object.OnPublicEvent(TestEventArgs(20)) + ob.OnPublicEvent(EventArgsTest(20)) self.assertTrue(handler.value == 10) - def testVarArgsCallableHandler(self): + def test_var_args_callable_handler(self): """Test varargs callable handlers.""" - object = EventTest() + ob = EventTest() handler = VarCallableHandler() - object.PublicEvent += handler - self.assertTrue(handler.value == None) + ob.PublicEvent += handler + self.assertTrue(handler.value is None) - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) - object.PublicEvent -= handler + ob.PublicEvent -= handler self.assertTrue(handler.value == 10) - object.OnPublicEvent(TestEventArgs(20)) + ob.OnPublicEvent(EventArgsTest(20)) self.assertTrue(handler.value == 10) - def testStaticMethodHandler(self): + def test_static_method_handler(self): """Test static method handlers.""" - object = EventTest() + ob = EventTest() handler = StaticMethodHandler() StaticMethodHandler.value = None - object.PublicEvent += handler.handler - self.assertTrue(handler.value == None) + ob.PublicEvent += handler.handler + self.assertTrue(handler.value is None) - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) - object.PublicEvent -= handler.handler + ob.PublicEvent -= handler.handler self.assertTrue(handler.value == 10) - object.OnPublicEvent(TestEventArgs(20)) + ob.OnPublicEvent(EventArgsTest(20)) self.assertTrue(handler.value == 10) - def testClassMethodHandler(self): + def test_class_method_handler(self): """Test class method handlers.""" - object = EventTest() + ob = EventTest() handler = ClassMethodHandler() ClassMethodHandler.value = None - object.PublicEvent += handler.handler - self.assertTrue(handler.value == None) + ob.PublicEvent += handler.handler + self.assertTrue(handler.value is None) - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) - object.PublicEvent -= handler.handler + ob.PublicEvent -= handler.handler self.assertTrue(handler.value == 10) - object.OnPublicEvent(TestEventArgs(20)) + ob.OnPublicEvent(EventArgsTest(20)) self.assertTrue(handler.value == 10) - def testManagedInstanceMethodHandler(self): + def test_managed_instance_method_handler(self): """Test managed instance method handlers.""" - object = EventTest() + ob = EventTest() - object.PublicEvent += object.GenericHandler - self.assertTrue(object.value == 0) + ob.PublicEvent += ob.GenericHandler + self.assertTrue(ob.value == 0) - object.OnPublicEvent(TestEventArgs(10)) - self.assertTrue(object.value == 10) + ob.OnPublicEvent(EventArgsTest(10)) + self.assertTrue(ob.value == 10) - object.PublicEvent -= object.GenericHandler - self.assertTrue(object.value == 10) + ob.PublicEvent -= ob.GenericHandler + self.assertTrue(ob.value == 10) - object.OnPublicEvent(TestEventArgs(20)) - self.assertTrue(object.value == 10) + ob.OnPublicEvent(EventArgsTest(20)) + self.assertTrue(ob.value == 10) - def testManagedStaticMethodHandler(self): + def test_managed_static_method_handler(self): """Test managed static method handlers.""" - object = EventTest() + ob = EventTest() EventTest.s_value = 0 - object.PublicEvent += object.StaticHandler + ob.PublicEvent += ob.StaticHandler self.assertTrue(EventTest.s_value == 0) - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(EventTest.s_value == 10) - object.PublicEvent -= object.StaticHandler + ob.PublicEvent -= ob.StaticHandler self.assertTrue(EventTest.s_value == 10) - object.OnPublicEvent(TestEventArgs(20)) + ob.OnPublicEvent(EventArgsTest(20)) self.assertTrue(EventTest.s_value == 10) - def testUnboundMethodHandler(self): + def test_unbound_method_handler(self): """Test failure mode for unbound method handlers.""" - object = EventTest() - object.PublicEvent += GenericHandler.handler - try: - object.OnPublicEvent(TestEventArgs(10)) - except TypeError: - object.PublicEvent -= GenericHandler.handler - return + ob = EventTest() + ob.PublicEvent += GenericHandler.handler - raise TypeError("should have raised a TypeError") + with self.assertRaises(TypeError): + ob.OnPublicEvent(EventArgsTest(10)) - def testFunctionHandler(self): + ob.PublicEvent -= GenericHandler.handler + + def test_function_handler(self): """Test function handlers.""" - object = EventTest() - dict = {'value': None} + ob = EventTest() + dict_ = {'value': None} - def handler(sender, args, dict=dict): - dict['value'] = args.value + def handler(sender, args, dict_=dict_): + dict_['value'] = args.value - object.PublicEvent += handler - self.assertTrue(dict['value'] == None) + ob.PublicEvent += handler + self.assertTrue(dict_['value'] is None) - object.OnPublicEvent(TestEventArgs(10)) - self.assertTrue(dict['value'] == 10) + ob.OnPublicEvent(EventArgsTest(10)) + self.assertTrue(dict_['value'] == 10) - object.PublicEvent -= handler - self.assertTrue(dict['value'] == 10) + ob.PublicEvent -= handler + self.assertTrue(dict_['value'] == 10) - object.OnPublicEvent(TestEventArgs(20)) - self.assertTrue(dict['value'] == 10) + ob.OnPublicEvent(EventArgsTest(20)) + self.assertTrue(dict_['value'] == 10) - def testAddNonCallableHandler(self): + def test_add_non_callable_handler(self): """Test handling of attempts to add non-callable handlers.""" - def test(): - object = EventTest() - object.PublicEvent += 10 - - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = EventTest() + ob.PublicEvent += 10 - def test(): - object = EventTest() - object.PublicEvent += "spam" + with self.assertRaises(TypeError): + ob = EventTest() + ob.PublicEvent += "spam" - self.assertRaises(TypeError, test) - - def test(): - class spam: + with self.assertRaises(TypeError): + class Spam(object): pass - object = EventTest() - object.PublicEvent += spam() - - self.assertRaises(TypeError, test) + ob = EventTest() + ob.PublicEvent += Spam() - def testRemoveMultipleHandlers(self): + def test_remove_multiple_handlers(self): """Test removing multiple instances of the same handler.""" - object = EventTest() + ob = EventTest() handler = MultipleHandler() h1 = handler.handler - object.PublicEvent += h1 + ob.PublicEvent += h1 h2 = handler.handler - object.PublicEvent += h2 + ob.PublicEvent += h2 - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 20) - object.PublicEvent -= h1 + ob.PublicEvent -= h1 - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 30) - object.PublicEvent -= h2 + ob.PublicEvent -= h2 - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 30) # try again, removing in a different order. - object = EventTest() + ob = EventTest() handler = MultipleHandler() h1 = handler.handler - object.PublicEvent += h1 + ob.PublicEvent += h1 h2 = handler.handler - object.PublicEvent += h2 + ob.PublicEvent += h2 - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 20) - object.PublicEvent -= h2 + ob.PublicEvent -= h2 - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 30) - object.PublicEvent -= h1 + ob.PublicEvent -= h1 - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 30) - def testRemoveMultipleStaticHandlers(self): + def test_remove_multiple_static_handlers(self): """Test removing multiple instances of a static handler.""" - object = EventTest() + ob = EventTest() handler = MultipleHandler() h1 = handler.handler - object.PublicStaticEvent += h1 + ob.PublicStaticEvent += h1 h2 = handler.handler - object.PublicStaticEvent += h2 + ob.PublicStaticEvent += h2 - object.OnPublicStaticEvent(TestEventArgs(10)) + ob.OnPublicStaticEvent(EventArgsTest(10)) self.assertTrue(handler.value == 20) - object.PublicStaticEvent -= h1 + ob.PublicStaticEvent -= h1 - object.OnPublicStaticEvent(TestEventArgs(10)) + ob.OnPublicStaticEvent(EventArgsTest(10)) self.assertTrue(handler.value == 30) - object.PublicStaticEvent -= h2 + ob.PublicStaticEvent -= h2 - object.OnPublicStaticEvent(TestEventArgs(10)) + ob.OnPublicStaticEvent(EventArgsTest(10)) self.assertTrue(handler.value == 30) # try again, removing in a different order. - object = EventTest() + ob = EventTest() handler = MultipleHandler() h1 = handler.handler - object.PublicStaticEvent += h1 + ob.PublicStaticEvent += h1 h2 = handler.handler - object.PublicStaticEvent += h2 + ob.PublicStaticEvent += h2 - object.OnPublicStaticEvent(TestEventArgs(10)) + ob.OnPublicStaticEvent(EventArgsTest(10)) self.assertTrue(handler.value == 20) - object.PublicStaticEvent -= h2 + ob.PublicStaticEvent -= h2 - object.OnPublicStaticEvent(TestEventArgs(10)) + ob.OnPublicStaticEvent(EventArgsTest(10)) self.assertTrue(handler.value == 30) - object.PublicStaticEvent -= h1 + ob.PublicStaticEvent -= h1 - object.OnPublicStaticEvent(TestEventArgs(10)) + ob.OnPublicStaticEvent(EventArgsTest(10)) self.assertTrue(handler.value == 30) - def testRandomMultipleHandlers(self): + def test_random_multiple_handlers(self): """Test random subscribe / unsubscribe of the same handlers.""" import random - object = EventTest() + ob = EventTest() handler = MultipleHandler() handler2 = MultipleHandler() - object.PublicEvent += handler2.handler - object.PublicEvent += handler2.handler + ob.PublicEvent += handler2.handler + ob.PublicEvent += handler2.handler handlers = [] - for i in range(30): + for _ in range(30): method = handler.handler - object.PublicEvent += method + ob.PublicEvent += method handlers.append(method) - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 300) self.assertTrue(handler2.value == 20) handler.value = 0 @@ -440,247 +421,143 @@ def testRandomMultipleHandlers(self): for i in range(30): item = random.choice(handlers) handlers.remove(item) - object.PublicEvent -= item + ob.PublicEvent -= item handler.value = 0 - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == (len(handlers) * 10)) self.assertTrue(handler2.value == ((i + 1) * 20)) handler2.value = 0 - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler2.value == 20) - object.PublicEvent -= handler2.handler + ob.PublicEvent -= handler2.handler handler2.value = 0 - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler2.value == 10) - object.PublicEvent -= handler2.handler + ob.PublicEvent -= handler2.handler handler2.value = 0 - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler2.value == 0) - def testRemoveInternalCallHandler(self): + def test_remove_internal_call_handler(self): """Test remove on an event sink implemented w/internalcall.""" - object = EventTest() + ob = EventTest() def h(sender, args): pass - object.PublicEvent += h - object.PublicEvent -= h + ob.PublicEvent += h + ob.PublicEvent -= h - def testRemoveUnknownHandler(self): + def test_remove_unknown_handler(self): """Test removing an event handler that was never added.""" - def test(): - object = EventTest() + with self.assertRaises(ValueError): + ob = EventTest() handler = GenericHandler() - object.PublicEvent -= handler.handler - - self.assertRaises(ValueError, test) + ob.PublicEvent -= handler.handler - def testHandlerCallbackFailure(self): + def test_handler_callback_failure(self): """Test failure mode for inappropriate handlers.""" - class BadHandler: + class BadHandler(object): def handler(self, one): return 'too many' - object = EventTest() + ob = EventTest() handler = BadHandler() - def test(): - object.PublicEvent += handler.handler - object.OnPublicEvent(TestEventArgs(10)) - - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob.PublicEvent += handler.handler + ob.OnPublicEvent(EventArgsTest(10)) - object.PublicEvent -= handler.handler + ob.PublicEvent -= handler.handler - class BadHandler: + class BadHandler(object): def handler(self, one, two, three, four, five): return 'not enough' - object = EventTest() + ob = EventTest() handler = BadHandler() - def test(): - object.PublicEvent += handler.handler - object.OnPublicEvent(TestEventArgs(10)) + with self.assertRaises(TypeError): + ob.PublicEvent += handler.handler + ob.OnPublicEvent(EventArgsTest(10)) - self.assertRaises(TypeError, test) + ob.PublicEvent -= handler.handler - object.PublicEvent -= handler.handler - - def testIncorrectInvokation(self): - """Test incorrect invokation of events.""" - object = EventTest() + def test_incorrect_invokation(self): + """Test incorrect invocation of events.""" + ob = EventTest() handler = GenericHandler() - object.PublicEvent += handler.handler - - def test(): - object.OnPublicEvent() + ob.PublicEvent += handler.handler - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob.OnPublicEvent() - def test(): - object.OnPublicEvent(32) + with self.assertRaises(TypeError): + ob.OnPublicEvent(32) - self.assertRaises(TypeError, test) + ob.PublicEvent -= handler.handler - object.PublicEvent -= handler.handler - - def testExplicitCLSEventRegistration(self): + def test_explicit_cls_event_registration(self): """Test explicit CLS event registration.""" - object = EventTest() + from Python.Test import EventHandlerTest + + ob = EventTest() handler = GenericHandler() - delegate = TestEventHandler(handler.handler) - object.add_PublicEvent(delegate) - self.assertTrue(handler.value == None) + delegate = EventHandlerTest(handler.handler) + ob.add_PublicEvent(delegate) + self.assertTrue(handler.value is None) - object.OnPublicEvent(TestEventArgs(10)) + ob.OnPublicEvent(EventArgsTest(10)) self.assertTrue(handler.value == 10) - object.remove_PublicEvent(delegate) + ob.remove_PublicEvent(delegate) self.assertTrue(handler.value == 10) - object.OnPublicEvent(TestEventArgs(20)) + ob.OnPublicEvent(EventArgsTest(20)) self.assertTrue(handler.value == 10) - def testImplicitCLSEventRegistration(self): + def test_implicit_cls_event_registration(self): """Test implicit CLS event registration.""" - def test(): - object = EventTest() + with self.assertRaises(TypeError): + ob = EventTest() handler = GenericHandler() - object.add_PublicEvent(handler.handler) + ob.add_PublicEvent(handler.handler) - self.assertRaises(TypeError, test) - - def testEventDescriptorAbuse(self): + def test_event_descriptor_abuse(self): """Test event descriptor abuse.""" - def test(): + with self.assertRaises(TypeError): del EventTest.PublicEvent - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del EventTest.__dict__['PublicEvent'] - self.assertRaises(TypeError, test) - desc = EventTest.__dict__['PublicEvent'] - def test(): + with self.assertRaises(TypeError): desc.__get__(0, 0) - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): desc.__set__(0, 0) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = EventTest() + ob.PublicEvent = 0 - def test(): - object = EventTest() - object.PublicEvent = 0 - - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): EventTest.PublicStaticEvent = 0 - self.assertRaises(TypeError, test) - - -class GenericHandler: - """A generic handler to test event callbacks.""" - - def __init__(self): - self.value = None - - def handler(self, sender, args): - self.value = args.value - - -class VariableArgsHandler: - """A variable args handler to test event callbacks.""" - - def __init__(self): - self.value = None - - def handler(self, *args): - ob, eventargs = args - self.value = eventargs.value - - -class CallableHandler: - """A callable handler to test event callbacks.""" - - def __init__(self): - self.value = None - - def __call__(self, sender, args): - self.value = args.value - - -class VarCallableHandler: - """A variable args callable handler to test event callbacks.""" - - def __init__(self): - self.value = None - - def __call__(self, *args): - ob, eventargs = args - self.value = eventargs.value - - -class StaticMethodHandler(object): - """A static method handler to test event callbacks.""" - - value = None - - def handler(sender, args): - StaticMethodHandler.value = args.value - - handler = staticmethod(handler) - - -class ClassMethodHandler(object): - """A class method handler to test event callbacks.""" - - value = None - - def handler(cls, sender, args): - cls.value = args.value - - handler = classmethod(handler) - - -class MultipleHandler: - """A generic handler to test multiple callbacks.""" - - def __init__(self): - self.value = 0 - - def handler(self, sender, args): - self.value += args.value - def test_suite(): return unittest.makeSuite(EventTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_exceptions.py b/src/tests/test_exceptions.py index eedf2aa61..2fb55589c 100644 --- a/src/tests/test_exceptions.py +++ b/src/tests/test_exceptions.py @@ -1,25 +1,23 @@ -import sys, os, string, unittest, types +# -*- coding: utf-8 -*- + +import sys +import unittest + import System -import six -if six.PY3: - unicode = str +from _compat import PY2, PY3, pickle, text_type class ExceptionTests(unittest.TestCase): """Test exception support.""" - def testUnifiedExceptionSemantics(self): + def test_unified_exception_semantics(self): """Test unified exception semantics.""" - from System import Exception, Object - - e = Exception('Something bad happened') - if not six.PY3: - import exceptions - self.assertTrue(isinstance(e, exceptions.Exception)) + e = System.Exception('Something bad happened') self.assertTrue(isinstance(e, Exception)) + self.assertTrue(isinstance(e, System.Exception)) - def testStandardExceptionAttributes(self): + def test_standard_exception_attributes(self): """Test accessing standard exception attributes.""" from System import OverflowException from Python.Test import ExceptionTest @@ -35,15 +33,15 @@ def testStandardExceptionAttributes(self): v = e.ToString() self.assertTrue(len(v) > 0) - def testExtendedExceptionAttributes(self): + def test_extended_exception_attributes(self): """Test accessing extended exception attributes.""" from Python.Test import ExceptionTest, ExtendedException - from System import Exception, OverflowException + from System import OverflowException e = ExceptionTest.GetExtendedException() self.assertTrue(isinstance(e, ExtendedException)) self.assertTrue(isinstance(e, OverflowException)) - self.assertTrue(isinstance(e, Exception)) + self.assertTrue(isinstance(e, System.Exception)) self.assertTrue(e.Message == 'error') @@ -59,99 +57,88 @@ def testExtendedExceptionAttributes(self): self.assertTrue(e.GetExtraInfo() == 'changed') - def testRaiseClassException(self): + def test_raise_class_exception(self): """Test class exception propagation.""" from System import NullReferenceException - def test(): + with self.assertRaises(NullReferenceException) as cm: raise NullReferenceException - self.assertRaises(NullReferenceException, test) + exc = cm.exception + self.assertTrue(isinstance(exc, NullReferenceException)) + 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 - except: - type, value, tb = sys.exc_info() - self.assertTrue(type is NullReferenceException) - self.assertTrue(isinstance(value, NullReferenceException)) - - def testRaiseClassExceptionWithValue(self): + 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) + + def test_raise_class_exception_with_value(self): """Test class exception propagation with associated value.""" from System import NullReferenceException - def test(): + with self.assertRaises(NullReferenceException) as cm: raise NullReferenceException('Aiiieee!') - self.assertRaises(NullReferenceException, test) - - try: - raise NullReferenceException('Aiiieee!') - except: - type, value, tb = sys.exc_info() - self.assertTrue(type is NullReferenceException) - self.assertTrue(isinstance(value, NullReferenceException)) - self.assertTrue(value.Message == 'Aiiieee!') + exc = cm.exception + self.assertTrue(isinstance(exc, NullReferenceException)) + self.assertTrue(exc.Message == 'Aiiieee!') - def testRaiseInstanceException(self): + def test_raise_instance_exception(self): """Test instance exception propagation.""" from System import NullReferenceException - def test(): + with self.assertRaises(NullReferenceException) as cm: raise NullReferenceException() - self.assertRaises(NullReferenceException, test) - - try: - raise NullReferenceException() - except: - type, value, tb = sys.exc_info() - self.assertTrue(type is NullReferenceException) - self.assertTrue(isinstance(value, NullReferenceException)) - self.assertTrue(len(value.Message) > 0) + exc = cm.exception + self.assertTrue(isinstance(exc, NullReferenceException)) + self.assertTrue(len(exc.Message) > 0) - def testRaiseInstanceExceptionWithArgs(self): + def test_raise_instance_exception_with_args(self): """Test instance exception propagation with args.""" from System import NullReferenceException - def test(): - raise NullReferenceException("Aiieeee!") - - self.assertRaises(NullReferenceException, test) + with self.assertRaises(NullReferenceException) as cm: + raise NullReferenceException("Aiiieee!") - try: - raise NullReferenceException('Aiiieee!') - except: - type, value, tb = sys.exc_info() - self.assertTrue(type is NullReferenceException) - self.assertTrue(isinstance(value, NullReferenceException)) - self.assertTrue(value.Message == 'Aiiieee!') + exc = cm.exception + self.assertTrue(isinstance(exc, NullReferenceException)) + self.assertTrue(exc.Message == 'Aiiieee!') - def testManagedExceptionPropagation(self): + def test_managed_exception_propagation(self): """Test propagation of exceptions raised in managed code.""" from System import Decimal, OverflowException - def test(): - l = Decimal.ToInt64(Decimal.MaxValue) - - self.assertRaises(OverflowException, test) + with self.assertRaises(OverflowException): + Decimal.ToInt64(Decimal.MaxValue) - def testManagedExceptionConversion(self): + def test_managed_exception_conversion(self): """Test conversion of managed exceptions.""" - from System import Exception, OverflowException + from System import OverflowException from Python.Test import ExceptionTest e = ExceptionTest.GetBaseException() - self.assertTrue(isinstance(e, Exception)) + self.assertTrue(isinstance(e, System.Exception)) e = ExceptionTest.GetExplicitException() self.assertTrue(isinstance(e, OverflowException)) - self.assertTrue(isinstance(e, Exception)) + self.assertTrue(isinstance(e, System.Exception)) e = ExceptionTest.GetWidenedException() self.assertTrue(isinstance(e, OverflowException)) - self.assertTrue(isinstance(e, Exception)) + self.assertTrue(isinstance(e, System.Exception)) - v = ExceptionTest.SetBaseException(Exception('error')) + v = ExceptionTest.SetBaseException(System.Exception('error')) self.assertTrue(v) v = ExceptionTest.SetExplicitException(OverflowException('error')) @@ -160,152 +147,133 @@ def testManagedExceptionConversion(self): v = ExceptionTest.SetWidenedException(OverflowException('error')) self.assertTrue(v) - def testCatchExceptionFromManagedMethod(self): + 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 - try: + with self.assertRaises(OverflowException) as cm: ExceptionTest().ThrowException() - except OverflowException: - e = sys.exc_info()[1] - self.assertTrue(isinstance(e, OverflowException)) - return - raise SystemError('failed to catch exception from managed method') + e = cm.exception + self.assertTrue(isinstance(e, OverflowException)) - def testCatchExceptionFromManagedProperty(self): + 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: - v = ExceptionTest().ThrowProperty - except OverflowException: - e = sys.exc_info()[1] - self.assertTrue(isinstance(e, OverflowException)) - return + with self.assertRaises(OverflowException) as cm: + _ = ExceptionTest().ThrowProperty - try: + e = cm.exception + self.assertTrue(isinstance(e, OverflowException)) + + with self.assertRaises(OverflowException) as cm: ExceptionTest().ThrowProperty = 1 - except OverflowException: - e = sys.exc_info()[1] - self.assertTrue(isinstance(e, OverflowException)) - return - raise SystemError('failed to catch exception from managed property') + e = cm.exception + self.assertTrue(isinstance(e, OverflowException)) - def testCatchExceptionManagedClass(self): + def test_catch_exception_managed_class(self): """Test catching the managed class of an exception.""" from System import OverflowException - try: + with self.assertRaises(OverflowException): raise OverflowException('overflow') - except OverflowException: - return - raise SystemError('failed to catch managed class exception') - - def testCatchExceptionPythonClass(self): + def test_catch_exception_python_class(self): """Test catching the python class of an exception.""" from System import OverflowException - if six.PY3: - from builtins import Exception - else: - from exceptions import Exception - try: + with self.assertRaises(Exception): raise OverflowException('overflow') - except Exception: - return - - raise SystemError('failed to catch python class exception') - def testCatchExceptionBaseClass(self): + def test_catch_exception_base_class(self): """Test catching the base of an exception.""" from System import OverflowException, ArithmeticException - try: + with self.assertRaises(ArithmeticException): raise OverflowException('overflow') - except ArithmeticException: - return - - raise SystemError('failed to catch base exception') - def testCatchExceptionNestedBaseClass(self): + def test_catch_exception_nested_base_class(self): """Test catching the nested base of an exception.""" from System import OverflowException, SystemException - try: + with self.assertRaises(SystemException): raise OverflowException('overflow') - except SystemException: - return - - raise SystemError('failed to catch nested base exception') - def testCatchExceptionWithAssignment(self): + def test_catch_exception_with_assignment(self): """Test catching an exception with assignment.""" from System import OverflowException - try: + with self.assertRaises(OverflowException) as cm: raise OverflowException('overflow') - except OverflowException: - e = sys.exc_info()[1] - self.assertTrue(isinstance(e, OverflowException)) - def testCatchExceptionUnqualified(self): + e = cm.exception + self.assertTrue(isinstance(e, OverflowException)) + + def test_catch_exception_unqualified(self): """Test catching an unqualified exception.""" from System import OverflowException try: raise OverflowException('overflow') except: - return + 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 - raise SystemError('failed to catch unqualified exception') + with self.assertRaises(BaseException): + raise OverflowException('overflow') - def testApparentModuleOfException(self): + def test_apparent_module_of_exception(self): """Test the apparent module of an exception.""" - from System import Exception, OverflowException + from System import OverflowException - self.assertTrue(Exception.__module__ == 'System') + self.assertTrue(System.Exception.__module__ == 'System') self.assertTrue(OverflowException.__module__ == 'System') - def testStrOfException(self): + def test_str_of_exception(self): """Test the str() representation of an exception.""" - from System import NullReferenceException - from System import Convert, FormatException + from System import NullReferenceException, Convert, FormatException + e = NullReferenceException('') self.assertEqual(str(e), '') e = NullReferenceException('Something bad happened') self.assertTrue(str(e).startswith('Something bad happened')) - try: + with self.assertRaises(FormatException) as cm: Convert.ToDateTime('this will fail') - except FormatException: - e = sys.exc_info()[1] - msg = unicode(e).encode("utf8") # fix for international installation - self.assertTrue(msg.find(unicode('System.Convert.ToDateTime').encode("utf8")) > -1, msg) - - def testPythonCompatOfManagedExceptions(self): - """Test if managed exceptions are compatible with Python's implementation - """ + + 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) + + def test_python_compat_of_managed_exceptions(self): + """Test managed exceptions compatible with Python's implementation""" from System import OverflowException - msg = "A simple message" + msg = "Simple message" e = OverflowException(msg) self.assertEqual(str(e), msg) - self.assertEqual(unicode(e), msg) + self.assertEqual(text_type(e), msg) self.assertEqual(e.args, (msg,)) self.assertTrue(isinstance(e.args, tuple)) - if six.PY2: - self.assertEqual(repr(e), "OverflowException(u'A simple message',)") - else: - self.assertEqual(repr(e), "OverflowException('A simple message',)") + if PY3: + self.assertEqual(repr(e), "OverflowException('Simple message',)") + elif PY2: + self.assertEqual(repr(e), "OverflowException(u'Simple message',)") - def testExceptionIsInstanceOfSystemObject(self): + 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 @@ -318,12 +286,11 @@ def testExceptionIsInstanceOfSystemObject(self): # here mainly to remind me to update the caveat in the documentation # one day when when exceptions can be new-style classes. - # This behaviour is now over-shadowed by the implementation of + # 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 - from System import Object + from System import OverflowException, Object o = OverflowException('error') @@ -332,48 +299,30 @@ def testExceptionIsInstanceOfSystemObject(self): else: self.assertFalse(isinstance(o, Object)) - def testPicklingExceptions(self): - from System import Exception - try: - import cPickle as pickle - except ImportError: - import pickle - - exc = Exception("test") + def test_pickling_exceptions(self): + exc = System.Exception("test") dumped = pickle.dumps(exc) loaded = pickle.loads(dumped) self.assertEqual(exc.args, loaded.args) - def testChainedExceptions(self): - if six.PY3: - from Python.Test import ExceptionTest + @unittest.skipIf(PY2, "__cause__ isn't implemented in PY2") + def test_chained_exceptions(self): + from Python.Test import ExceptionTest - try: - ExceptionTest.ThrowChainedExceptions() - except Exception as exc: - msgs = [ - "Outer exception", - "Inner exception", - "Innermost exception" - ] + with self.assertRaises(Exception) as cm: + ExceptionTest.ThrowChainedExceptions() - for msg in msgs: - self.assertEqual(exc.Message, msg) - self.assertEqual(exc.__cause__, exc.InnerException) - exc = exc.__cause__ + exc = cm.exception - else: - self.fail("Test should raise an 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) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_field.py b/src/tests/test_field.py index d765e3888..b1d596fea 100644 --- a/src/tests/test_field.py +++ b/src/tests/test_field.py @@ -1,433 +1,369 @@ -import sys, os, string, unittest, types -from Python.Test import FieldTest -from Python.Test import ShortEnum -import System -import six +# -*- coding: utf-8 -*- + +import unittest -if six.PY3: - IntType = int -else: - IntType = types.IntType +import System +from Python.Test import FieldTest class FieldTests(unittest.TestCase): """Test CLR field support.""" - def testPublicInstanceField(self): + def test_public_instance_field(self): """Test public instance fields.""" - object = FieldTest(); - self.assertTrue(object.PublicField == 0) + ob = FieldTest() + self.assertTrue(ob.PublicField == 0) - object.PublicField = 1 - self.assertTrue(object.PublicField == 1) + ob.PublicField = 1 + self.assertTrue(ob.PublicField == 1) - def test(): + with self.assertRaises(TypeError): del FieldTest().PublicField - self.assertRaises(TypeError, test) - - def testPublicStaticField(self): + def test_public_static_field(self): """Test public static fields.""" - object = FieldTest(); + ob = FieldTest() self.assertTrue(FieldTest.PublicStaticField == 0) FieldTest.PublicStaticField = 1 self.assertTrue(FieldTest.PublicStaticField == 1) - self.assertTrue(object.PublicStaticField == 1) - object.PublicStaticField = 0 - self.assertTrue(object.PublicStaticField == 0) + self.assertTrue(ob.PublicStaticField == 1) + ob.PublicStaticField = 0 + self.assertTrue(ob.PublicStaticField == 0) - def test(): + with self.assertRaises(TypeError): del FieldTest.PublicStaticField - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del FieldTest().PublicStaticField - self.assertRaises(TypeError, test) - - def testProtectedInstanceField(self): + def test_protected_instance_field(self): """Test protected instance fields.""" - object = FieldTest(); - self.assertTrue(object.ProtectedField == 0) + ob = FieldTest() + self.assertTrue(ob.ProtectedField == 0) - object.ProtectedField = 1 - self.assertTrue(object.ProtectedField == 1) + ob.ProtectedField = 1 + self.assertTrue(ob.ProtectedField == 1) - def test(): + with self.assertRaises(TypeError): del FieldTest().ProtectedField - self.assertRaises(TypeError, test) - - def testProtectedStaticField(self): + def test_protected_static_field(self): """Test protected static fields.""" - object = FieldTest(); + ob = FieldTest() self.assertTrue(FieldTest.ProtectedStaticField == 0) FieldTest.ProtectedStaticField = 1 self.assertTrue(FieldTest.ProtectedStaticField == 1) - self.assertTrue(object.ProtectedStaticField == 1) - object.ProtectedStaticField = 0 - self.assertTrue(object.ProtectedStaticField == 0) + self.assertTrue(ob.ProtectedStaticField == 1) + ob.ProtectedStaticField = 0 + self.assertTrue(ob.ProtectedStaticField == 0) - def test(): + with self.assertRaises(TypeError): del FieldTest.ProtectedStaticField - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del FieldTest().ProtectedStaticField - self.assertRaises(TypeError, test) - - def testReadOnlyInstanceField(self): + def test_read_only_instance_field(self): """Test readonly instance fields.""" self.assertTrue(FieldTest().ReadOnlyField == 0) - def test(): + with self.assertRaises(TypeError): FieldTest().ReadOnlyField = 1 - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del FieldTest().ReadOnlyField - self.assertRaises(TypeError, test) - - def testReadOnlyStaticField(self): + def test_read_only_static_field(self): """Test readonly static fields.""" - object = FieldTest(); + ob = FieldTest() self.assertTrue(FieldTest.ReadOnlyStaticField == 0) - self.assertTrue(object.ReadOnlyStaticField == 0) + self.assertTrue(ob.ReadOnlyStaticField == 0) - def test(): + with self.assertRaises(TypeError): FieldTest.ReadOnlyStaticField = 1 - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): FieldTest().ReadOnlyStaticField = 1 - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del FieldTest.ReadOnlyStaticField - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del FieldTest().ReadOnlyStaticField - self.assertRaises(TypeError, test) - - def testConstantField(self): + def test_constant_field(self): """Test const fields.""" - object = FieldTest(); + ob = FieldTest() self.assertTrue(FieldTest.ConstField == 0) - self.assertTrue(object.ConstField == 0) + self.assertTrue(ob.ConstField == 0) - def test(): + with self.assertRaises(TypeError): FieldTest().ConstField = 1 - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): FieldTest.ConstField = 1 - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del FieldTest().ConstField - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del FieldTest.ConstField - self.assertRaises(TypeError, test) - - def testInternalField(self): + def test_internal_field(self): """Test internal fields.""" - def test(): - f = FieldTest().InternalField - - self.assertRaises(AttributeError, test) - - def test(): - f = FieldTest().InternalStaticField - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = FieldTest().InternalField - def test(): - f = FieldTest.InternalStaticField + with self.assertRaises(AttributeError): + _ = FieldTest().InternalStaticField - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = FieldTest.InternalStaticField - def testPrivateField(self): + def test_private_field(self): """Test private fields.""" - def test(): - f = FieldTest().PrivateField + with self.assertRaises(AttributeError): + _ = FieldTest().PrivateField - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = FieldTest().PrivateStaticField - def test(): - f = FieldTest().PrivateStaticField + with self.assertRaises(AttributeError): + _ = FieldTest.PrivateStaticField - self.assertRaises(AttributeError, test) - - def test(): - f = FieldTest.PrivateStaticField - - self.assertRaises(AttributeError, test) - - def testFieldDescriptorGetSet(self): + def test_field_descriptor_get_set(self): """Test field descriptor get / set.""" # 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. - object = FieldTest() + ob = FieldTest() self.assertTrue(FieldTest.PublicStaticField == 0) - self.assertTrue(object.PublicStaticField == 0) + self.assertTrue(ob.PublicStaticField == 0) descriptor = FieldTest.__dict__['PublicStaticField'] - self.assertTrue(type(descriptor) != IntType) + self.assertTrue(type(descriptor) != int) - object.PublicStaticField = 0 + ob.PublicStaticField = 0 descriptor = FieldTest.__dict__['PublicStaticField'] - self.assertTrue(type(descriptor) != IntType) + self.assertTrue(type(descriptor) != int) FieldTest.PublicStaticField = 0 descriptor = FieldTest.__dict__['PublicStaticField'] - self.assertTrue(type(descriptor) != IntType) + self.assertTrue(type(descriptor) != int) - def testFieldDescriptorWrongType(self): + def test_field_descriptor_wrong_type(self): """Test setting a field using a value of the wrong type.""" - def test(): + with self.assertRaises(TypeError): FieldTest().PublicField = "spam" - self.assertRaises(TypeError, test) - - def testFieldDescriptorAbuse(self): + def test_field_descriptor_abuse(self): """Test field descriptor abuse.""" desc = FieldTest.__dict__['PublicField'] - def test(): + with self.assertRaises(TypeError): desc.__get__(0, 0) - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): desc.__set__(0, 0) - self.assertRaises(TypeError, test) - - def testBooleanField(self): + def test_boolean_field(self): """Test boolean fields.""" # change this to true / false later for Python 2.3? - object = FieldTest() - self.assertTrue(object.BooleanField == False) + ob = FieldTest() + self.assertTrue(ob.BooleanField is False) - object.BooleanField = True - self.assertTrue(object.BooleanField == True) + ob.BooleanField = True + self.assertTrue(ob.BooleanField is True) - object.BooleanField = False - self.assertTrue(object.BooleanField == False) + ob.BooleanField = False + self.assertTrue(ob.BooleanField is False) - object.BooleanField = 1 - self.assertTrue(object.BooleanField == True) + ob.BooleanField = 1 + self.assertTrue(ob.BooleanField is True) - object.BooleanField = 0 - self.assertTrue(object.BooleanField == False) + ob.BooleanField = 0 + self.assertTrue(ob.BooleanField is False) - def testSByteField(self): + def test_sbyte_field(self): """Test sbyte fields.""" - object = FieldTest() - self.assertTrue(object.SByteField == 0) + ob = FieldTest() + self.assertTrue(ob.SByteField == 0) - object.SByteField = 1 - self.assertTrue(object.SByteField == 1) + ob.SByteField = 1 + self.assertTrue(ob.SByteField == 1) - def testByteField(self): + def test_byte_field(self): """Test byte fields.""" - object = FieldTest() - self.assertTrue(object.ByteField == 0) + ob = FieldTest() + self.assertTrue(ob.ByteField == 0) - object.ByteField = 1 - self.assertTrue(object.ByteField == 1) + ob.ByteField = 1 + self.assertTrue(ob.ByteField == 1) - def testCharField(self): + def test_char_field(self): """Test char fields.""" - object = FieldTest() - self.assertTrue(object.CharField == six.u('A')) - self.assertTrue(object.CharField == 'A') + ob = FieldTest() + self.assertTrue(ob.CharField == u'A') + self.assertTrue(ob.CharField == 'A') - object.CharField = 'B' - self.assertTrue(object.CharField == six.u('B')) - self.assertTrue(object.CharField == 'B') + ob.CharField = 'B' + self.assertTrue(ob.CharField == u'B') + self.assertTrue(ob.CharField == 'B') - object.CharField = six.u('C') - self.assertTrue(object.CharField == six.u('C')) - self.assertTrue(object.CharField == 'C') + ob.CharField = u'C' + self.assertTrue(ob.CharField == u'C') + self.assertTrue(ob.CharField == 'C') - def testInt16Field(self): + def test_int16_field(self): """Test int16 fields.""" - object = FieldTest() - self.assertTrue(object.Int16Field == 0) + ob = FieldTest() + self.assertTrue(ob.Int16Field == 0) - object.Int16Field = 1 - self.assertTrue(object.Int16Field == 1) + ob.Int16Field = 1 + self.assertTrue(ob.Int16Field == 1) - def testInt32Field(self): + def test_int32_field(self): """Test int32 fields.""" - object = FieldTest() - self.assertTrue(object.Int32Field == 0) + ob = FieldTest() + self.assertTrue(ob.Int32Field == 0) - object.Int32Field = 1 - self.assertTrue(object.Int32Field == 1) + ob.Int32Field = 1 + self.assertTrue(ob.Int32Field == 1) - def testInt64Field(self): + def test_int64_field(self): """Test int64 fields.""" - object = FieldTest() - self.assertTrue(object.Int64Field == 0) + ob = FieldTest() + self.assertTrue(ob.Int64Field == 0) - object.Int64Field = 1 - self.assertTrue(object.Int64Field == 1) + ob.Int64Field = 1 + self.assertTrue(ob.Int64Field == 1) - def testUInt16Field(self): + def test_uint16_field(self): """Test uint16 fields.""" - object = FieldTest() - self.assertTrue(object.UInt16Field == 0) + ob = FieldTest() + self.assertTrue(ob.UInt16Field == 0) - object.UInt16Field = 1 - self.assertTrue(object.UInt16Field == 1) + ob.UInt16Field = 1 + self.assertTrue(ob.UInt16Field == 1) - def testUInt32Field(self): + def test_uint32_field(self): """Test uint32 fields.""" - object = FieldTest() - self.assertTrue(object.UInt32Field == 0) + ob = FieldTest() + self.assertTrue(ob.UInt32Field == 0) - object.UInt32Field = 1 - self.assertTrue(object.UInt32Field == 1) + ob.UInt32Field = 1 + self.assertTrue(ob.UInt32Field == 1) - def testUInt64Field(self): + def test_uint64_field(self): """Test uint64 fields.""" - object = FieldTest() - self.assertTrue(object.UInt64Field == 0) + ob = FieldTest() + self.assertTrue(ob.UInt64Field == 0) - object.UInt64Field = 1 - self.assertTrue(object.UInt64Field == 1) + ob.UInt64Field = 1 + self.assertTrue(ob.UInt64Field == 1) - def testSingleField(self): + def test_single_field(self): """Test single fields.""" - object = FieldTest() - self.assertTrue(object.SingleField == 0.0) + ob = FieldTest() + self.assertTrue(ob.SingleField == 0.0) - object.SingleField = 1.1 - self.assertTrue(object.SingleField == 1.1) + ob.SingleField = 1.1 + self.assertTrue(ob.SingleField == 1.1) - def testDoubleField(self): + def test_double_field(self): """Test double fields.""" - object = FieldTest() - self.assertTrue(object.DoubleField == 0.0) + ob = FieldTest() + self.assertTrue(ob.DoubleField == 0.0) - object.DoubleField = 1.1 - self.assertTrue(object.DoubleField == 1.1) + ob.DoubleField = 1.1 + self.assertTrue(ob.DoubleField == 1.1) - def testDecimalField(self): + def test_decimal_field(self): """Test decimal fields.""" - object = FieldTest() - self.assertTrue(object.DecimalField == System.Decimal(0)) + ob = FieldTest() + self.assertTrue(ob.DecimalField == System.Decimal(0)) - object.DecimalField = System.Decimal(1) - self.assertTrue(object.DecimalField == System.Decimal(1)) + ob.DecimalField = System.Decimal(1) + self.assertTrue(ob.DecimalField == System.Decimal(1)) - def testStringField(self): + def test_string_field(self): """Test string fields.""" - object = FieldTest() - self.assertTrue(object.StringField == "spam") + ob = FieldTest() + self.assertTrue(ob.StringField == "spam") - object.StringField = "eggs" - self.assertTrue(object.StringField == "eggs") + ob.StringField = "eggs" + self.assertTrue(ob.StringField == "eggs") - def testInterfaceField(self): + def test_interface_field(self): """Test interface fields.""" from Python.Test import Spam, ISpam - object = FieldTest() + ob = FieldTest() - self.assertTrue(ISpam(object.SpamField).GetValue() == "spam") - self.assertTrue(object.SpamField.GetValue() == "spam") + self.assertTrue(ISpam(ob.SpamField).GetValue() == "spam") + self.assertTrue(ob.SpamField.GetValue() == "spam") - object.SpamField = Spam("eggs") - self.assertTrue(ISpam(object.SpamField).GetValue() == "eggs") - self.assertTrue(object.SpamField.GetValue() == "eggs") + ob.SpamField = Spam("eggs") + self.assertTrue(ISpam(ob.SpamField).GetValue() == "eggs") + self.assertTrue(ob.SpamField.GetValue() == "eggs") - def testObjectField(self): - """Test object fields.""" - object = FieldTest() - self.assertTrue(object.ObjectField == None) + def test_object_field(self): + """Test ob fields.""" + ob = FieldTest() + self.assertTrue(ob.ObjectField is None) - object.ObjectField = System.String("spam") - self.assertTrue(object.ObjectField == "spam") + ob.ObjectField = System.String("spam") + self.assertTrue(ob.ObjectField == "spam") - object.ObjectField = System.Int32(1) - self.assertTrue(object.ObjectField == 1) + ob.ObjectField = System.Int32(1) + self.assertTrue(ob.ObjectField == 1) - object.ObjectField = None - self.assertTrue(object.ObjectField == None) + ob.ObjectField = None + self.assertTrue(ob.ObjectField is None) - def testEnumField(self): + def test_enum_field(self): """Test enum fields.""" - object = FieldTest() - self.assertTrue(object.EnumField == ShortEnum.Zero) + from Python.Test import ShortEnum + + ob = FieldTest() + self.assertTrue(ob.EnumField == ShortEnum.Zero) - object.EnumField = ShortEnum.One - self.assertTrue(object.EnumField == ShortEnum.One) + ob.EnumField = ShortEnum.One + self.assertTrue(ob.EnumField == ShortEnum.One) - def testNullableField(self): + def test_nullable_field(self): """Test nullable fields.""" - object = FieldTest() + ob = FieldTest() - object.StringField = None - self.assertTrue(object.StringField == None) + ob.StringField = None + self.assertTrue(ob.StringField is None) - object.ObjectField = None - self.assertTrue(object.ObjectField == None) + ob.ObjectField = None + self.assertTrue(ob.ObjectField is None) - object.SpamField = None - self.assertTrue(object.SpamField == None) + ob.SpamField = None + self.assertTrue(ob.SpamField is None) # Primitive types and enums should not be set to null. - def test(): + with self.assertRaises(TypeError): FieldTest().Int32Field = None - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): FieldTest().EnumField = None - self.assertRaises(TypeError, test) - def test_suite(): return unittest.makeSuite(FieldTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_generic.py b/src/tests/test_generic.py index 1e8b58f21..8d5ea4c4c 100644 --- a/src/tests/test_generic.py +++ b/src/tests/test_generic.py @@ -1,153 +1,18 @@ -import clr +# -*- coding: utf-8 -*- -clr.AddReference('Python.Test') +import clr +import unittest -from System.Collections.Generic import Dictionary, List -import sys, os, string, unittest, types -import Python.Test as Test import System -import six -if six.PY3: - long = int - unichr = chr - unicode = str +from _compat import PY2, long, unicode, unichr, zip class GenericTests(unittest.TestCase): """Test CLR generics support.""" - def testPythonTypeAliasing(self): - """Test python type alias support with generics.""" - 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] == False) - - dict = Dictionary[System.Boolean, System.Boolean]() - self.assertEquals(dict.Count, 0) - dict.Add(True, False) - self.assertTrue(dict[True] == False) - - def testGenericReferenceType(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 testGenericValueType(self): - """Test usage of generic value type definitions.""" - inst = System.Nullable[System.Int32](10) - self.assertTrue(inst.HasValue) - self.assertTrue(inst.Value == 10) - - def testGenericInterface(self): - pass - - def testGenericDelegate(self): - pass - - def testOpenGenericType(self): - """ - Test behavior of reflected open constructed generic types. - """ - from Python.Test import DerivedFromOpenGeneric - - OpenGenericType = DerivedFromOpenGeneric.__bases__[0] - - def test(): - inst = OpenGenericType() - - self.assertRaises(TypeError, test) - - def test(): - type = OpenGenericType[System.String] - - self.assertRaises(TypeError, test) - - def testDerivedFromOpenGenericType(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 testGenericTypeNameResolution(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. - - def test(): - inst = GenericNameTest2() - - self.assertRaises(TypeError, test) - - _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 _testGenericWrapperByType(self, ptype, value, test_type=0): + def _assert_generic_wrapper_by_type(self, ptype, value): + """Test Helper""" from Python.Test import GenericWrapper import System @@ -161,41 +26,8 @@ def _testGenericWrapperByType(self, ptype, value, test_type=0): self.assertTrue(inst.value[0] == value) self.assertTrue(inst.value[1] == value) - def testGenericTypeBinding(self): - """ - Test argument conversion / binding for generic methods. - """ - from Python.Test import InterfaceTest, ISayHello1, ShortEnum - import System - - self._testGenericWrapperByType(System.Boolean, True) - self._testGenericWrapperByType(bool, True) - self._testGenericWrapperByType(System.Byte, 255) - self._testGenericWrapperByType(System.SByte, 127) - self._testGenericWrapperByType(System.Char, six.u('A')) - self._testGenericWrapperByType(System.Int16, 32767) - self._testGenericWrapperByType(System.Int32, 2147483647) - self._testGenericWrapperByType(int, 2147483647) - self._testGenericWrapperByType(System.Int64, long(9223372036854775807)) - # Python 3 has no explicit long type, use System.Int64 instead - if not six.PY3: - self._testGenericWrapperByType(long, long(9223372036854775807)) - self._testGenericWrapperByType(System.UInt16, 65000) - self._testGenericWrapperByType(System.UInt32, long(4294967295)) - self._testGenericWrapperByType(System.UInt64, long(18446744073709551615)) - self._testGenericWrapperByType(System.Single, 3.402823e38) - self._testGenericWrapperByType(System.Double, 1.7976931348623157e308) - self._testGenericWrapperByType(float, 1.7976931348623157e308) - self._testGenericWrapperByType(System.Decimal, System.Decimal.One) - self._testGenericWrapperByType(System.String, "test") - self._testGenericWrapperByType(unicode, "test") - self._testGenericWrapperByType(str, "test") - self._testGenericWrapperByType(ShortEnum, ShortEnum.Zero) - self._testGenericWrapperByType(System.Object, InterfaceTest()) - self._testGenericWrapperByType(InterfaceTest, InterfaceTest()) - self._testGenericWrapperByType(ISayHello1, InterfaceTest()) - - def _testGenericMethodByType(self, ptype, value, test_type=0): + def _assert_generic_method_by_type(self, ptype, value, test_type=0): + """Test Helper""" from Python.Test import GenericMethodTest, GenericStaticMethodTest import System @@ -280,7 +112,162 @@ def _testGenericMethodByType(self, ptype, value, test_type=0): self.assertTrue(result[0] == value) self.assertTrue(result[1] == value) - def testGenericMethodBinding(self): + 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 @@ -288,66 +275,56 @@ def testGenericMethodBinding(self): value = GenericStaticMethodTest[str].Overloaded() self.assertTrue(value == 1) - def test(): + with self.assertRaises(InvalidOperationException): # Cannot invoke a static member on an open type. GenericStaticMethodTest.Overloaded() - self.assertRaises(InvalidOperationException, test) - # Can invoke an instance member on a closed generic type. value = GenericMethodTest[str]().Overloaded() self.assertTrue(value == 1) - def test(): + with self.assertRaises(TypeError): # Cannot invoke an instance member on an open type, # because the open type cannot be instantiated. GenericMethodTest().Overloaded() - self.assertRaises(TypeError, test) - - def testGenericMethodTypeHandling(self): - """ - Test argument conversion / binding for generic methods. - """ + def test_generic_method_type_handling(self): + """Test argument conversion / binding for generic methods.""" from Python.Test import InterfaceTest, ISayHello1, ShortEnum import System - # XXX BUG: The value doesn't fit into Int64 and PythonNet doesn't + # FIXME: The value doesn't fit into Int64 and PythonNet doesn't # recognize it as UInt64 for unknown reasons. - ## self._testGenericMethodByType(System.UInt64, 18446744073709551615L) - self._testGenericMethodByType(System.Boolean, True) - self._testGenericMethodByType(bool, True) - self._testGenericMethodByType(System.Byte, 255) - self._testGenericMethodByType(System.SByte, 127) - self._testGenericMethodByType(System.Char, six.u('A')) - self._testGenericMethodByType(System.Int16, 32767) - self._testGenericMethodByType(System.Int32, 2147483647) - self._testGenericMethodByType(int, 2147483647) + # 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 not six.PY3: - self._testGenericMethodByType(System.Int64, long(9223372036854775807)) - self._testGenericMethodByType(long, long(9223372036854775807)) - self._testGenericMethodByType(System.UInt32, long(4294967295)) - self._testGenericMethodByType(System.Int64, long(1844674407370955161)) - self._testGenericMethodByType(System.UInt16, 65000) - self._testGenericMethodByType(System.Single, 3.402823e38) - self._testGenericMethodByType(System.Double, 1.7976931348623157e308) - self._testGenericMethodByType(float, 1.7976931348623157e308) - self._testGenericMethodByType(System.Decimal, System.Decimal.One) - self._testGenericMethodByType(System.String, "test") - self._testGenericMethodByType(unicode, "test") - self._testGenericMethodByType(str, "test") - self._testGenericMethodByType(ShortEnum, ShortEnum.Zero) - self._testGenericMethodByType(System.Object, InterfaceTest()) - self._testGenericMethodByType(InterfaceTest, InterfaceTest(), 1) - self._testGenericMethodByType(ISayHello1, InterfaceTest(), 1) - - def testCorrectOverloadSelection(self): - """ - Test correct overloading selection for common types. - """ - from System.Drawing import Font - + 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 @@ -366,27 +343,24 @@ def testCorrectOverloadSelection(self): self.assertTrue( Math.Max(atype(value1), atype(value2)) == Math.Max.__overloads__[atype, atype]( - atype(value1), - atype(value2))) - if (atype is Int64) and six.PY2: + 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))) + atype(value1), atype(value2))) clr.AddReference("System.Runtime.InteropServices") from System.Runtime.InteropServices import GCHandle, GCHandleType from System import Array, Byte - CSArray = Array.CreateInstance(Byte, 1000) - handler = GCHandle.Alloc(CSArray, GCHandleType.Pinned) + cs_array = Array.CreateInstance(Byte, 1000) + handler = GCHandle.Alloc(cs_array, GCHandleType.Pinned) - def testGenericMethodOverloadSelection(self): - """ - Test explicit overload selection with generic methods. - """ + 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]() @@ -424,11 +398,11 @@ def testGenericMethodOverloadSelection(self): # public static Q Overloaded(Q arg) value = type.Overloaded[bool](True) - self.assertTrue(value == True) + self.assertTrue(value is True) # public Q Overloaded(Q arg) value = inst.Overloaded[bool](True) - self.assertTrue(value == True) + self.assertTrue(value is True) # public static U Overloaded(Q arg1, U arg2) value = type.Overloaded[bool, str](True, "true") @@ -440,11 +414,11 @@ def testGenericMethodOverloadSelection(self): # public static U Overloaded(Q arg1, U arg2) value = type.Overloaded[str, bool]("true", True) - self.assertTrue(value == True) + self.assertTrue(value is True) # public U Overloaded(Q arg1, U arg2) value = inst.Overloaded[str, bool]("true", True) - self.assertTrue(value == True) + self.assertTrue(value is True) # public static string Overloaded(int arg1, int arg2, string arg3) value = type.Overloaded[str](123, 456, "success") @@ -454,350 +428,340 @@ def testGenericMethodOverloadSelection(self): value = inst.Overloaded[str](123, 456, "success") self.assertTrue(value == "success") - def test(): - value = type.Overloaded[str, bool, int]("true", True, 1) - - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + _ = type.Overloaded[str, bool, int]("true", True, 1) - def test(): - value = inst.Overloaded[str, bool, int]("true", True, 1) + with self.assertRaises(TypeError): + _ = inst.Overloaded[str, bool, int]("true", True, 1) - self.assertRaises(TypeError, test) - - def testMethodOverloadSelectionWithGenericTypes(self): + 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 == True) + 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 == True) + 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) + 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) + input_ = vtype(127) + value = MethodTest.Overloaded.__overloads__[vtype](input_) self.assertTrue(value.value == 127) vtype = GenericWrapper[System.Char] - input = vtype(six.u('A')) - value = MethodTest.Overloaded.__overloads__[vtype](input) - self.assertTrue(value.value == six.u('A')) + 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) + 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) + 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) + 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) + input_ = vtype(2147483647) + value = MethodTest.Overloaded.__overloads__[vtype](input_) self.assertTrue(value.value == 2147483647) vtype = GenericWrapper[System.Int64] - input = vtype(long(9223372036854775807)) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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 not six.PY3: + if PY2: vtype = GenericWrapper[long] - input = vtype(long(9223372036854775807)) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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) + 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 testOverloadSelectionWithArraysOfGenericTypes(self): + 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 == True) + 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 == True) + 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) + 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) + 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(six.u('A')), gtype(six.u('A'))]) - value = MethodTest.Overloaded.__overloads__[vtype](input) - self.assertTrue(value[0].value == six.u('A')) + 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) + 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) + 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) + 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) + 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] vtype = System.Array[gtype] - input = vtype([gtype(long(9223372036854775807)), + input_ = vtype([gtype(long(9223372036854775807)), gtype(long(9223372036854775807))]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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 not six.PY3: + if PY2: gtype = GenericWrapper[long] vtype = System.Array[gtype] - input = vtype([gtype(long(9223372036854775807)), + input_ = vtype([gtype(long(9223372036854775807)), gtype(long(9223372036854775807))]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + 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) + 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)), + input_ = vtype([gtype(long(18446744073709551615)), gtype(long(18446744073709551615))]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + 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), + input_ = vtype([gtype(1.7976931348623157e308), gtype(1.7976931348623157e308)]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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), + input_ = vtype([gtype(1.7976931348623157e308), gtype(1.7976931348623157e308)]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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), + input_ = vtype([gtype(System.Decimal.One), gtype(System.Decimal.One)]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + 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) + 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) + 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) + 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) + 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) + 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 testGenericOverloadSelectionMagicNameOnly(self): + def test_generic_overload_selection_magic_name_only(self): """Test using only __overloads__ to select on type & sig""" - # XXX NotImplemented + # TODO NotImplemented pass - def testNestedGenericClass(self): + def test_nested_generic_class(self): """Check nested generic classes.""" - # XXX NotImplemented + # TODO NotImplemented pass def test_suite(): return unittest.makeSuite(GenericTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_indexer.py b/src/tests/test_indexer.py index 5e74c76f0..422f7282e 100644 --- a/src/tests/test_indexer.py +++ b/src/tests/test_indexer.py @@ -1,687 +1,577 @@ -import sys, os, string, unittest, types -import clr +# -*- coding: utf-8 -*- + +import unittest -clr.AddReference("Python.Test") import Python.Test as Test -import six -if six.PY3: - long = int - unichr = chr +from _compat import long, unichr class IndexerTests(unittest.TestCase): """Test support for indexer properties.""" - def testPublicIndexer(self): + def test_public_indexer(self): """Test public indexers.""" - object = Test.PublicIndexerTest() + ob = Test.PublicIndexerTest() - object[0] = "zero" - self.assertTrue(object[0] == "zero") + ob[0] = "zero" + self.assertTrue(ob[0] == "zero") - object[1] = "one" - self.assertTrue(object[1] == "one") + ob[1] = "one" + self.assertTrue(ob[1] == "one") - self.assertTrue(object[10] == None) + self.assertTrue(ob[10] is None) - def testProtectedIndexer(self): + def test_protected_indexer(self): """Test protected indexers.""" - object = Test.ProtectedIndexerTest() + ob = Test.ProtectedIndexerTest() - object[0] = "zero" - self.assertTrue(object[0] == "zero") + ob[0] = "zero" + self.assertTrue(ob[0] == "zero") - object[1] = "one" - self.assertTrue(object[1] == "one") + ob[1] = "one" + self.assertTrue(ob[1] == "one") - self.assertTrue(object[10] == None) + self.assertTrue(ob[10] is None) - def testInternalIndexer(self): + def test_internal_indexer(self): """Test internal indexers.""" - object = Test.InternalIndexerTest() - - def test(): - object[0] = "zero" - - self.assertRaises(TypeError, test) - - def test(): - Test.InternalIndexerTest.__getitem__(object, 0) + ob = Test.InternalIndexerTest() - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob[0] = "zero" - def test(): - object.__getitem__(0) + with self.assertRaises(TypeError): + Test.InternalIndexerTest.__getitem__(ob, 0) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob.__getitem__(0) - def testPrivateIndexer(self): + def test_private_indexer(self): """Test private indexers.""" - object = Test.PrivateIndexerTest() - - def test(): - object[0] = "zero" - - self.assertRaises(TypeError, test) - - def test(): - Test.PrivateIndexerTest.__getitem__(object, 0) + ob = Test.PrivateIndexerTest() - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob[0] = "zero" - def test(): - object.__getitem__(0) + with self.assertRaises(TypeError): + Test.PrivateIndexerTest.__getitem__(ob, 0) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob.__getitem__(0) - def testBooleanIndexer(self): + def test_boolean_indexer(self): """Test boolean indexers.""" - object = Test.BooleanIndexerTest() + ob = Test.BooleanIndexerTest() - self.assertTrue(object[True] == None) - self.assertTrue(object[1] == None) + self.assertTrue(ob[True] is None) + self.assertTrue(ob[1] is None) - object[0] = "false" - self.assertTrue(object[0] == "false") + ob[0] = "false" + self.assertTrue(ob[0] == "false") - object[1] = "true" - self.assertTrue(object[1] == "true") + ob[1] = "true" + self.assertTrue(ob[1] == "true") - object[False] = "false" - self.assertTrue(object[False] == "false") + ob[False] = "false" + self.assertTrue(ob[False] == "false") - object[True] = "true" - self.assertTrue(object[True] == "true") + ob[True] = "true" + self.assertTrue(ob[True] == "true") - def testByteIndexer(self): + def test_byte_indexer(self): """Test byte indexers.""" - object = Test.ByteIndexerTest() - max = 255 - min = 0 + ob = Test.ByteIndexerTest() + max_ = 255 + min_ = 0 - self.assertTrue(object[max] == None) + self.assertTrue(ob[max_] is None) - object[max] = str(max) - self.assertTrue(object[max] == str(max)) + ob[max_] = str(max_) + self.assertTrue(ob[max_] == str(max_)) - object[min] = str(min) - self.assertTrue(object[min] == str(min)) + ob[min_] = str(min_) + self.assertTrue(ob[min_] == str(min_)) - def test(): - object = Test.ByteIndexerTest() - object["wrong"] + with self.assertRaises(TypeError): + ob = Test.ByteIndexerTest() + ob["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.ByteIndexerTest() + ob["wrong"] = "wrong" - def test(): - object = Test.ByteIndexerTest() - object["wrong"] = "wrong" - - self.assertRaises(TypeError, test) - - def testSByteIndexer(self): + def test_sbyte_indexer(self): """Test sbyte indexers.""" - object = Test.SByteIndexerTest() - max = 127 - min = -128 - - self.assertTrue(object[max] == None) - - object[max] = str(max) - self.assertTrue(object[max] == str(max)) + ob = Test.SByteIndexerTest() + max_ = 127 + min_ = -128 - object[min] = str(min) - self.assertTrue(object[min] == str(min)) + self.assertTrue(ob[max_] is None) - def test(): - object = Test.SByteIndexerTest() - object["wrong"] + ob[max_] = str(max_) + self.assertTrue(ob[max_] == str(max_)) - self.assertRaises(TypeError, test) + ob[min_] = str(min_) + self.assertTrue(ob[min_] == str(min_)) - def test(): - object = Test.SByteIndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.SByteIndexerTest() + ob["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.SByteIndexerTest() + ob["wrong"] = "wrong" - def testCharIndexer(self): + def test_char_indexer(self): """Test char indexers.""" - object = Test.CharIndexerTest() - max = unichr(65535) - min = unichr(0) + ob = Test.CharIndexerTest() + max_ = unichr(65535) + min_ = unichr(0) - self.assertTrue(object[max] == None) + self.assertTrue(ob[max_] is None) - object[max] = "max" - self.assertTrue(object[max] == "max") + ob[max_] = "max_" + self.assertTrue(ob[max_] == "max_") - object[min] = "min" - self.assertTrue(object[min] == "min") + ob[min_] = "min_" + self.assertTrue(ob[min_] == "min_") - def test(): - object = Test.CharIndexerTest() - object["wrong"] + with self.assertRaises(TypeError): + ob = Test.CharIndexerTest() + ob["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.CharIndexerTest() + ob["wrong"] = "wrong" - def test(): - object = Test.CharIndexerTest() - object["wrong"] = "wrong" - - self.assertRaises(TypeError, test) - - def testInt16Indexer(self): + def test_int16_indexer(self): """Test Int16 indexers.""" - object = Test.Int16IndexerTest() - max = 32767 - min = -32768 - - self.assertTrue(object[max] == None) + ob = Test.Int16IndexerTest() + max_ = 32767 + min_ = -32768 - object[max] = str(max) - self.assertTrue(object[max] == str(max)) + self.assertTrue(ob[max_] is None) - object[min] = str(min) - self.assertTrue(object[min] == str(min)) + ob[max_] = str(max_) + self.assertTrue(ob[max_] == str(max_)) - def test(): - object = Test.Int16IndexerTest() - object["wrong"] + ob[min_] = str(min_) + self.assertTrue(ob[min_] == str(min_)) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.Int16IndexerTest() + ob["wrong"] - def test(): - object = Test.Int16IndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.Int16IndexerTest() + ob["wrong"] = "wrong" - self.assertRaises(TypeError, test) - - def testInt32Indexer(self): + def test_int32_indexer(self): """Test Int32 indexers.""" - object = Test.Int32IndexerTest() - max = 2147483647 - min = -2147483648 - - self.assertTrue(object[max] == None) + ob = Test.Int32IndexerTest() + max_ = 2147483647 + min_ = -2147483648 - object[max] = str(max) - self.assertTrue(object[max] == str(max)) + self.assertTrue(ob[max_] is None) - object[min] = str(min) - self.assertTrue(object[min] == str(min)) + ob[max_] = str(max_) + self.assertTrue(ob[max_] == str(max_)) - def test(): - object = Test.Int32IndexerTest() - object["wrong"] + ob[min_] = str(min_) + self.assertTrue(ob[min_] == str(min_)) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.Int32IndexerTest() + ob["wrong"] - def test(): - object = Test.Int32IndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.Int32IndexerTest() + ob["wrong"] = "wrong" - self.assertRaises(TypeError, test) - - def testInt64Indexer(self): + def test_int64_indexer(self): """Test Int64 indexers.""" - object = Test.Int64IndexerTest() - max = long(9223372036854775807) - min = long(-9223372036854775808) - - self.assertTrue(object[max] == None) + ob = Test.Int64IndexerTest() + max_ = long(9223372036854775807) + min_ = long(-9223372036854775808) - object[max] = str(max) - self.assertTrue(object[max] == str(max)) + self.assertTrue(ob[max_] is None) - object[min] = str(min) - self.assertTrue(object[min] == str(min)) + ob[max_] = str(max_) + self.assertTrue(ob[max_] == str(max_)) - def test(): - object = Test.Int64IndexerTest() - object["wrong"] + ob[min_] = str(min_) + self.assertTrue(ob[min_] == str(min_)) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.Int64IndexerTest() + ob["wrong"] - def test(): - object = Test.Int64IndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.Int64IndexerTest() + ob["wrong"] = "wrong" - self.assertRaises(TypeError, test) - - def testUInt16Indexer(self): + def test_uint16_indexer(self): """Test UInt16 indexers.""" - object = Test.UInt16IndexerTest() - max = 65535 - min = 0 - - self.assertTrue(object[max] == None) - - object[max] = str(max) - self.assertTrue(object[max] == str(max)) + ob = Test.UInt16IndexerTest() + max_ = 65535 + min_ = 0 - object[min] = str(min) - self.assertTrue(object[min] == str(min)) + self.assertTrue(ob[max_] is None) - def test(): - object = Test.UInt16IndexerTest() - object["wrong"] + ob[max_] = str(max_) + self.assertTrue(ob[max_] == str(max_)) - self.assertRaises(TypeError, test) + ob[min_] = str(min_) + self.assertTrue(ob[min_] == str(min_)) - def test(): - object = Test.UInt16IndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.UInt16IndexerTest() + ob["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.UInt16IndexerTest() + ob["wrong"] = "wrong" - def testUInt32Indexer(self): + def test_uint32_indexer(self): """Test UInt32 indexers.""" - object = Test.UInt32IndexerTest() - max = long(4294967295) - min = 0 + ob = Test.UInt32IndexerTest() + max_ = long(4294967295) + min_ = 0 - self.assertTrue(object[max] == None) + self.assertTrue(ob[max_] is None) - object[max] = str(max) - self.assertTrue(object[max] == str(max)) + ob[max_] = str(max_) + self.assertTrue(ob[max_] == str(max_)) - object[min] = str(min) - self.assertTrue(object[min] == str(min)) + ob[min_] = str(min_) + self.assertTrue(ob[min_] == str(min_)) - def test(): - object = Test.UInt32IndexerTest() - object["wrong"] + with self.assertRaises(TypeError): + ob = Test.UInt32IndexerTest() + ob["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.UInt32IndexerTest() + ob["wrong"] = "wrong" - def test(): - object = Test.UInt32IndexerTest() - object["wrong"] = "wrong" - - self.assertRaises(TypeError, test) - - def testUInt64Indexer(self): + def test_uint64_indexer(self): """Test UInt64 indexers.""" - object = Test.UInt64IndexerTest() - max = long(18446744073709551615) - min = 0 - - self.assertTrue(object[max] == None) - - object[max] = str(max) - self.assertTrue(object[max] == str(max)) + ob = Test.UInt64IndexerTest() + max_ = long(18446744073709551615) + min_ = 0 - object[min] = str(min) - self.assertTrue(object[min] == str(min)) + self.assertTrue(ob[max_] is None) - def test(): - object = Test.UInt64IndexerTest() - object["wrong"] + ob[max_] = str(max_) + self.assertTrue(ob[max_] == str(max_)) - self.assertRaises(TypeError, test) + ob[min_] = str(min_) + self.assertTrue(ob[min_] == str(min_)) - def test(): - object = Test.UInt64IndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.UInt64IndexerTest() + ob["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.UInt64IndexerTest() + ob["wrong"] = "wrong" - def testSingleIndexer(self): + def test_single_indexer(self): """Test Single indexers.""" - object = Test.SingleIndexerTest() - max = 3.402823e38 - min = -3.402823e38 + ob = Test.SingleIndexerTest() + max_ = 3.402823e38 + min_ = -3.402823e38 - self.assertTrue(object[max] == None) + self.assertTrue(ob[max_] is None) - object[max] = "max" - self.assertTrue(object[max] == "max") + ob[max_] = "max_" + self.assertTrue(ob[max_] == "max_") - object[min] = "min" - self.assertTrue(object[min] == "min") + ob[min_] = "min_" + self.assertTrue(ob[min_] == "min_") - def test(): - object = Test.SingleIndexerTest() - object["wrong"] + with self.assertRaises(TypeError): + ob = Test.SingleIndexerTest() + ob["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.SingleIndexerTest() + ob["wrong"] = "wrong" - def test(): - object = Test.SingleIndexerTest() - object["wrong"] = "wrong" - - self.assertRaises(TypeError, test) - - def testDoubleIndexer(self): + def test_double_indexer(self): """Test Double indexers.""" - object = Test.DoubleIndexerTest() - max = 1.7976931348623157e308 - min = -1.7976931348623157e308 - - self.assertTrue(object[max] == None) + ob = Test.DoubleIndexerTest() + max_ = 1.7976931348623157e308 + min_ = -1.7976931348623157e308 - object[max] = "max" - self.assertTrue(object[max] == "max") + self.assertTrue(ob[max_] is None) - object[min] = "min" - self.assertTrue(object[min] == "min") + ob[max_] = "max_" + self.assertTrue(ob[max_] == "max_") - def test(): - object = Test.DoubleIndexerTest() - object["wrong"] + ob[min_] = "min_" + self.assertTrue(ob[min_] == "min_") - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.DoubleIndexerTest() + ob["wrong"] - def test(): - object = Test.DoubleIndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.DoubleIndexerTest() + ob["wrong"] = "wrong" - self.assertRaises(TypeError, test) - - def testDecimalIndexer(self): + def test_decimal_indexer(self): """Test Decimal indexers.""" - object = Test.DecimalIndexerTest() + ob = Test.DecimalIndexerTest() from System import Decimal max_d = Decimal.Parse("79228162514264337593543950335") min_d = Decimal.Parse("-79228162514264337593543950335") - self.assertTrue(object[max_d] == None) - - object[max_d] = "max" - self.assertTrue(object[max_d] == "max") + self.assertTrue(ob[max_d] is None) - object[min_d] = "min" - self.assertTrue(object[min_d] == "min") + ob[max_d] = "max_" + self.assertTrue(ob[max_d] == "max_") - def test(): - object = Test.DecimalIndexerTest() - object["wrong"] + ob[min_d] = "min_" + self.assertTrue(ob[min_d] == "min_") - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.DecimalIndexerTest() + ob["wrong"] - def test(): - object = Test.DecimalIndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.DecimalIndexerTest() + ob["wrong"] = "wrong" - self.assertRaises(TypeError, test) - - def testStringIndexer(self): + def test_string_indexer(self): """Test String indexers.""" - object = Test.StringIndexerTest() - - self.assertTrue(object["spam"] == None) - self.assertTrue(object[six.u("spam")] == None) + ob = Test.StringIndexerTest() - object["spam"] = "spam" - self.assertTrue(object["spam"] == "spam") - self.assertTrue(object["spam"] == six.u("spam")) - self.assertTrue(object[six.u("spam")] == "spam") - self.assertTrue(object[six.u("spam")] == six.u("spam")) + self.assertTrue(ob["spam"] is None) + self.assertTrue(ob[u"spam"] is None) - object[six.u("eggs")] = six.u("eggs") - self.assertTrue(object["eggs"] == "eggs") - self.assertTrue(object["eggs"] == six.u("eggs")) - self.assertTrue(object[six.u("eggs")] == "eggs") - self.assertTrue(object[six.u("eggs")] == six.u("eggs")) + 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") - def test(): - object = Test.StringIndexerTest() - object[1] + 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") - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.StringIndexerTest() + ob[1] - def test(): - object = Test.StringIndexerTest() - object[1] = "wrong" + with self.assertRaises(TypeError): + ob = Test.StringIndexerTest() + ob[1] = "wrong" - self.assertRaises(TypeError, test) - - def testEnumIndexer(self): + def test_enum_indexer(self): """Test enum indexers.""" - object = Test.EnumIndexerTest() + ob = Test.EnumIndexerTest() key = Test.ShortEnum.One - self.assertTrue(object[key] == None) - - object[key] = "spam" - self.assertTrue(object[key] == "spam") - - object[key] = "eggs" - self.assertTrue(object[key] == "eggs") + self.assertTrue(ob[key] is None) - object[1] = "spam" - self.assertTrue(object[1] == "spam") + ob[key] = "spam" + self.assertTrue(ob[key] == "spam") - def test(): - object = Test.EnumIndexerTest() - object["wrong"] + ob[key] = "eggs" + self.assertTrue(ob[key] == "eggs") - self.assertRaises(TypeError, test) + ob[1] = "spam" + self.assertTrue(ob[1] == "spam") - def test(): - object = Test.EnumIndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.EnumIndexerTest() + ob["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.EnumIndexerTest() + ob["wrong"] = "wrong" - def testObjectIndexer(self): - """Test object indexers.""" - object = Test.ObjectIndexerTest() + def test_object_indexer(self): + """Test ob indexers.""" + ob = Test.ObjectIndexerTest() from Python.Test import Spam spam = Spam("spam") - self.assertTrue(object[spam] == None) - self.assertTrue(object["spam"] == None) - self.assertTrue(object[1] == None) - self.assertTrue(object[None] == None) + self.assertTrue(ob[spam] is None) + self.assertTrue(ob["spam"] is None) + self.assertTrue(ob[1] is None) + self.assertTrue(ob[None] is None) - object[spam] = "spam" - self.assertTrue(object[spam] == "spam") + ob[spam] = "spam" + self.assertTrue(ob[spam] == "spam") - object["spam"] = "eggs" - self.assertTrue(object["spam"] == "eggs") + ob["spam"] = "eggs" + self.assertTrue(ob["spam"] == "eggs") - object[1] = "one" - self.assertTrue(object[1] == "one") + ob[1] = "one" + self.assertTrue(ob[1] == "one") - object[long(1)] = "long" - self.assertTrue(object[long(1)] == "long") + ob[long(1)] = "long" + self.assertTrue(ob[long(1)] == "long") - def test(): - class eggs: + with self.assertRaises(TypeError): + class Eggs(object): pass - key = eggs() - object = Test.ObjectIndexerTest() - object[key] = "wrong" + key = Eggs() + ob = Test.ObjectIndexerTest() + ob[key] = "wrong" - self.assertRaises(TypeError, test) - - def testInterfaceIndexer(self): + def test_interface_indexer(self): """Test interface indexers.""" - object = Test.InterfaceIndexerTest() + ob = Test.InterfaceIndexerTest() from Python.Test import Spam spam = Spam("spam") - self.assertTrue(object[spam] == None) - - object[spam] = "spam" - self.assertTrue(object[spam] == "spam") + self.assertTrue(ob[spam] is None) - object[spam] = "eggs" - self.assertTrue(object[spam] == "eggs") + ob[spam] = "spam" + self.assertTrue(ob[spam] == "spam") - def test(): - object = Test.InterfaceIndexerTest() - object["wrong"] + ob[spam] = "eggs" + self.assertTrue(ob[spam] == "eggs") - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.InterfaceIndexerTest() + ob["wrong"] - def test(): - object = Test.InterfaceIndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.InterfaceIndexerTest() + ob["wrong"] = "wrong" - self.assertRaises(TypeError, test) - - def testTypedIndexer(self): + def test_typed_indexer(self): """Test typed indexers.""" - object = Test.TypedIndexerTest() + ob = Test.TypedIndexerTest() from Python.Test import Spam spam = Spam("spam") - self.assertTrue(object[spam] == None) - - object[spam] = "spam" - self.assertTrue(object[spam] == "spam") + self.assertTrue(ob[spam] is None) - object[spam] = "eggs" - self.assertTrue(object[spam] == "eggs") + ob[spam] = "spam" + self.assertTrue(ob[spam] == "spam") - def test(): - object = Test.TypedIndexerTest() - object["wrong"] + ob[spam] = "eggs" + self.assertTrue(ob[spam] == "eggs") - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.TypedIndexerTest() + ob["wrong"] - def test(): - object = Test.TypedIndexerTest() - object["wrong"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.TypedIndexerTest() + ob["wrong"] = "wrong" - self.assertRaises(TypeError, test) - - def testMultiArgIndexer(self): + def test_multi_arg_indexer(self): """Test indexers that take multiple index arguments.""" - object = Test.MultiArgIndexerTest() - - object[0, 1] = "zero one" - self.assertTrue(object[0, 1] == "zero one") - - object[1, 9] = "one nine" - self.assertTrue(object[1, 9] == "one nine") + ob = Test.MultiArgIndexerTest() - self.assertTrue(object[10, 50] == None) + ob[0, 1] = "zero one" + self.assertTrue(ob[0, 1] == "zero one") - def test(): - object = Test.MultiArgIndexerTest() - v = object[0, "one"] + ob[1, 9] = "one nine" + self.assertTrue(ob[1, 9] == "one nine") - self.assertRaises(TypeError, test) + self.assertTrue(ob[10, 50] is None) - def test(): - object = Test.MultiArgIndexerTest() - object[0, "one"] = "wrong" + with self.assertRaises(TypeError): + ob = Test.MultiArgIndexerTest() + _ = ob[0, "one"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.MultiArgIndexerTest() + ob[0, "one"] = "wrong" - def testMultiTypeIndexer(self): + def test_multi_type_indexer(self): """Test indexers that take multiple indices of different types.""" - object = Test.MultiTypeIndexerTest() + ob = Test.MultiTypeIndexerTest() spam = Test.Spam("spam") - object[0, "one", spam] = "zero one spam" - self.assertTrue(object[0, "one", spam] == "zero one spam") + ob[0, "one", spam] = "zero one spam" + self.assertTrue(ob[0, "one", spam] == "zero one spam") - object[1, "nine", spam] = "one nine spam" - self.assertTrue(object[1, "nine", spam] == "one nine spam") + ob[1, "nine", spam] = "one nine spam" + self.assertTrue(ob[1, "nine", spam] == "one nine spam") - def test(): - object = Test.MultiTypeIndexerTest() - v = object[0, 1, spam] + with self.assertRaises(TypeError): + ob = Test.MultiTypeIndexerTest() + _ = ob[0, 1, spam] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.MultiTypeIndexerTest() + ob[0, 1, spam] = "wrong" - def test(): - object = Test.MultiTypeIndexerTest() - object[0, 1, spam] = "wrong" - - self.assertRaises(TypeError, test) - - def testMultiDefaultKeyIndexer(self): - """Test indexers that take multiple indices with a default key arguments.""" + 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 - object = Test.MultiDefaultKeyIndexerTest() - object[0, 2] = "zero one spam" - self.assertTrue(object[0] == "zero one spam") + ob = Test.MultiDefaultKeyIndexerTest() + ob[0, 2] = "zero one spam" + self.assertTrue(ob[0] == "zero one spam") - object[1] = "one nine spam" - self.assertTrue(object[1, 2] == "one nine spam") + ob[1] = "one nine spam" + self.assertTrue(ob[1, 2] == "one nine spam") - def testIndexerWrongKeyType(self): + def test_indexer_wrong_key_type(self): """Test calling an indexer using a key of the wrong type.""" - def test(): - object = Test.PublicIndexerTest() - v = object["wrong"] - - self.assertRaises(TypeError, test) - - def test(): - object = Test.PublicIndexerTest() - object["wrong"] = "spam" + with self.assertRaises(TypeError): + ob = Test.PublicIndexerTest() + _ = ob["wrong"] - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + ob = Test.PublicIndexerTest() + ob["wrong"] = "spam" - def testIndexerWrongValueType(self): + def test_indexer_wrong_value_type(self): """Test calling an indexer using a value of the wrong type.""" - def test(): - object = Test.PublicIndexerTest() - object[1] = 9993.9 + with self.assertRaises(TypeError): + ob = Test.PublicIndexerTest() + ob[1] = 9993.9 - self.assertRaises(TypeError, test) - - def testUnboundIndexer(self): + def test_unbound_indexer(self): """Test calling an unbound indexer.""" - object = Test.PublicIndexerTest() + ob = Test.PublicIndexerTest() - Test.PublicIndexerTest.__setitem__(object, 0, "zero") - self.assertTrue(object[0] == "zero") + Test.PublicIndexerTest.__setitem__(ob, 0, "zero") + self.assertTrue(ob[0] == "zero") - Test.PublicIndexerTest.__setitem__(object, 1, "one") - self.assertTrue(object[1] == "one") + Test.PublicIndexerTest.__setitem__(ob, 1, "one") + self.assertTrue(ob[1] == "one") - self.assertTrue(object[10] == None) + self.assertTrue(ob[10] is None) - def testIndexerAbuse(self): + def test_indexer_abuse(self): """Test indexer abuse.""" _class = Test.PublicIndexerTest - object = Test.PublicIndexerTest() + ob = Test.PublicIndexerTest() - def test(): + with self.assertRaises(AttributeError): del _class.__getitem__ - self.assertRaises(AttributeError, test) - - def test(): - del object.__getitem__ - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + del ob.__getitem__ - def test(): + with self.assertRaises(AttributeError): del _class.__setitem__ - self.assertRaises(AttributeError, test) - - def test(): - del object.__setitem__ - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + del ob.__setitem__ def test_suite(): return unittest.makeSuite(IndexerTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_interface.py b/src/tests/test_interface.py index 1e495fe25..1fac36eb8 100644 --- a/src/tests/test_interface.py +++ b/src/tests/test_interface.py @@ -1,60 +1,56 @@ -from Python.Test import InterfaceTest -import sys, os, string, unittest, types +# -*- coding: utf-8 -*- + +import unittest + import Python.Test as Test -import System -import six -if six.PY3: - DictProxyType = type(object.__dict__) -else: - DictProxyType = types.DictProxyType +from _compat import DictProxyType class InterfaceTests(unittest.TestCase): """Test CLR interface support.""" - def testInterfaceStandardAttrs(self): + def test_interface_standard_attrs(self): """Test standard class attributes.""" - from Python.Test import IPublicInterface as ip - self.assertTrue(ip.__name__ == 'IPublicInterface') - self.assertTrue(ip.__module__ == 'Python.Test') - self.assertTrue(type(ip.__dict__) == DictProxyType) + from Python.Test import IPublicInterface + + self.assertTrue(IPublicInterface.__name__ == 'IPublicInterface') + self.assertTrue(IPublicInterface.__module__ == 'Python.Test') + self.assertTrue(isinstance(IPublicInterface.__dict__, DictProxyType)) - def testGlobalInterfaceVisibility(self): + def test_global_interface_visibility(self): """Test visibility of module-level interfaces.""" from Python.Test import IPublicInterface + self.assertTrue(IPublicInterface.__name__ == 'IPublicInterface') - def test(): + with self.assertRaises(ImportError): from Python.Test import IInternalInterface + _ = IInternalInterface - self.assertRaises(ImportError, test) - - def test(): - i = Test.IInternalInterface - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = Test.IInternalInterface - def testNestedInterfaceVisibility(self): + def test_nested_interface_visibility(self): """Test visibility of nested interfaces.""" + from Python.Test import InterfaceTest + ob = InterfaceTest.IPublic self.assertTrue(ob.__name__ == 'IPublic') ob = InterfaceTest.IProtected self.assertTrue(ob.__name__ == 'IProtected') - def test(): - ob = InterfaceTest.IInternal - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = InterfaceTest.IInternal - def test(): - ob = InterfaceTest.IPrivate + with self.assertRaises(AttributeError): + _ = InterfaceTest.IPrivate - self.assertRaises(AttributeError, test) - - def testExplicitCastToInterface(self): + def test_explicit_cast_to_interface(self): """Test explicit cast to an interface.""" + from Python.Test import InterfaceTest + ob = InterfaceTest() self.assertTrue(type(ob).__name__ == 'InterfaceTest') self.assertTrue(hasattr(ob, 'HelloProperty')) @@ -74,11 +70,3 @@ def testExplicitCastToInterface(self): def test_suite(): return unittest.makeSuite(InterfaceTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_method.py b/src/tests/test_method.py index 4728d13e4..6c4454004 100644 --- a/src/tests/test_method.py +++ b/src/tests/test_method.py @@ -1,187 +1,143 @@ -import sys, os, string, unittest, types -import clr +# -*- coding: utf-8 -*- -clr.AddReference("Python.Test") +import unittest -from Python.Test import MethodTest, MethodTestSub import System -import six +from Python.Test import MethodTest -if six.PY3: - long = int - unichr = chr +from _compat import PY2, long, unichr class MethodTests(unittest.TestCase): """Test CLR method support.""" - def testInstanceMethodDescriptor(self): + def test_instance_method_descriptor(self): """Test instance method descriptor behavior.""" - def test(): + with self.assertRaises(AttributeError): MethodTest().PublicMethod = 0 - self.assertRaises(AttributeError, test) - - def test(): + with self.assertRaises(AttributeError): MethodTest.PublicMethod = 0 - self.assertRaises(AttributeError, test) - - def test(): + with self.assertRaises(AttributeError): del MethodTest().PublicMethod - self.assertRaises(AttributeError, test) - - def test(): + with self.assertRaises(AttributeError): del MethodTest.PublicMethod - self.assertRaises(AttributeError, test) - - def testStaticMethodDescriptor(self): + def test_static_method_descriptor(self): """Test static method descriptor behavior.""" - def test(): + with self.assertRaises(AttributeError): MethodTest().PublicStaticMethod = 0 - self.assertRaises(AttributeError, test) - - def test(): + with self.assertRaises(AttributeError): MethodTest.PublicStaticMethod = 0 - self.assertRaises(AttributeError, test) - - def test(): + with self.assertRaises(AttributeError): del MethodTest().PublicStaticMethod - self.assertRaises(AttributeError, test) - - def test(): + with self.assertRaises(AttributeError): del MethodTest.PublicStaticMethod - self.assertRaises(AttributeError, test) - - def testPublicInstanceMethod(self): + def test_public_instance_method(self): """Test public instance method visibility.""" - object = MethodTest(); - self.assertTrue(object.PublicMethod() == "public") + ob = MethodTest() + self.assertTrue(ob.PublicMethod() == "public") - def testPublicStaticMethod(self): + def test_public_static_method(self): """Test public static method visibility.""" - object = MethodTest(); + ob = MethodTest() self.assertTrue(MethodTest.PublicStaticMethod() == "public static") - self.assertTrue(object.PublicStaticMethod() == "public static") + self.assertTrue(ob.PublicStaticMethod() == "public static") - def testProtectedInstanceMethod(self): + def test_protected_instance_method(self): """Test protected instance method visibility.""" - object = MethodTest(); - self.assertTrue(object.ProtectedMethod() == "protected") + ob = MethodTest() + self.assertTrue(ob.ProtectedMethod() == "protected") - def testProtectedStaticMethod(self): + def test_protected_static_method(self): """Test protected static method visibility.""" - object = MethodTest(); + ob = MethodTest() result = "protected static" self.assertTrue(MethodTest.ProtectedStaticMethod() == result) - self.assertTrue(object.ProtectedStaticMethod() == result) + self.assertTrue(ob.ProtectedStaticMethod() == result) - def testInternalMethod(self): + def test_internal_method(self): """Test internal method visibility.""" - def test(): - f = MethodTest().InternalMethod - - self.assertRaises(AttributeError, test) - - def test(): - f = MethodTest.InternalMethod - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = MethodTest().InternalMethod - def test(): - f = MethodTest().InternalStaticMethod + with self.assertRaises(AttributeError): + _ = MethodTest.InternalMethod - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = MethodTest().InternalStaticMethod - def test(): - f = MethodTest.InternalStaticMethod + with self.assertRaises(AttributeError): + _ = MethodTest.InternalStaticMethod - self.assertRaises(AttributeError, test) - - def testPrivateMethod(self): + def test_private_method(self): """Test private method visibility.""" - def test(): - f = MethodTest().PrivateMethod - - self.assertRaises(AttributeError, test) - - def test(): - f = MethodTest.PrivateMethod + with self.assertRaises(AttributeError): + _ = MethodTest().PrivateMethod - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = MethodTest.PrivateMethod - def test(): - f = MethodTest().PrivateStaticMethod + with self.assertRaises(AttributeError): + _ = MethodTest().PrivateStaticMethod - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = MethodTest.PrivateStaticMethod - def test(): - f = MethodTest.PrivateStaticMethod - - self.assertRaises(AttributeError, test) - - def testUnboundManagedMethodCall(self): + def test_unbound_managed_method_call(self): """Test calling unbound managed methods.""" + from Python.Test import MethodTestSub - object = MethodTest() - self.assertTrue(MethodTest.PublicMethod(object) == "public") + ob = MethodTest() + self.assertTrue(MethodTest.PublicMethod(ob) == "public") - def test(): + with self.assertRaises(TypeError): MethodTest.PublicMethod() - self.assertRaises(TypeError, test) + ob = MethodTestSub() + self.assertTrue(MethodTestSub.PublicMethod(ob) == "public") + self.assertTrue(MethodTestSub.PublicMethod(ob, "echo") == "echo") - object = MethodTestSub(); - self.assertTrue(MethodTestSub.PublicMethod(object) == "public") - self.assertTrue(MethodTestSub.PublicMethod(object, "echo") == "echo") - - def test(): + with self.assertRaises(TypeError): MethodTestSub.PublicMethod("echo") - self.assertRaises(TypeError, test) - - def testOverloadedMethodInheritance(self): + def test_overloaded_method_inheritance(self): """Test that overloads are inherited properly.""" + from Python.Test import MethodTestSub - object = MethodTest() - self.assertTrue(object.PublicMethod() == "public") + ob = MethodTest() + self.assertTrue(ob.PublicMethod() == "public") - def test(): - object = MethodTest() - object.PublicMethod("echo") + with self.assertRaises(TypeError): + ob = MethodTest() + ob.PublicMethod("echo") - self.assertRaises(TypeError, test) + ob = MethodTestSub() + self.assertTrue(ob.PublicMethod() == "public") - object = MethodTestSub(); - self.assertTrue(object.PublicMethod() == "public") + self.assertTrue(ob.PublicMethod("echo") == "echo") - self.assertTrue(object.PublicMethod("echo") == "echo") - - def testMethodDescriptorAbuse(self): + def test_method_descriptor_abuse(self): """Test method descriptor abuse.""" desc = MethodTest.__dict__['PublicMethod'] - def test(): + with self.assertRaises(TypeError): desc.__get__(0, 0) - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(AttributeError): desc.__set__(0, 0) - self.assertRaises(AttributeError, test) - - def testMethodDocstrings(self): + def test_method_docstrings(self): """Test standard method docstring generation""" method = MethodTest.GetType value = 'System.Type GetType()' @@ -191,53 +147,51 @@ def testMethodDocstrings(self): # Tests of specific argument and result conversion scenarios # ====================================================================== - def testMethodCallEnumConversion(self): + def test_method_call_enum_conversion(self): """Test enum conversion in method call.""" from System import TypeCode - object = MethodTest() - r = object.TestEnumConversion(TypeCode.Int32) + ob = MethodTest() + r = ob.TestEnumConversion(TypeCode.Int32) self.assertTrue(r == TypeCode.Int32) - def testMethodCallFlagsConversion(self): + def test_method_call_flags_conversion(self): """Test flags conversion in method call.""" from System.IO import FileAccess - object = MethodTest() + ob = MethodTest() flags = FileAccess.Read | FileAccess.Write - r = object.TestFlagsConversion(flags) + r = ob.TestFlagsConversion(flags) self.assertTrue(r == flags) - def testMethodCallStructConversion(self): + def test_method_call_struct_conversion(self): """Test struct conversion in method call.""" from System import Guid - object = MethodTest() + ob = MethodTest() guid = Guid.NewGuid() temp = guid.ToString() - r = object.TestStructConversion(guid) + r = ob.TestStructConversion(guid) self.assertTrue(r.ToString() == temp) - def testSubclassInstanceConversion(self): + def test_subclass_instance_conversion(self): """Test subclass instance conversion in method call.""" class TestSubException(System.Exception): pass - object = MethodTest() + ob = MethodTest() instance = TestSubException() - result = object.TestSubclassConversion(instance) + result = ob.TestSubclassConversion(instance) self.assertTrue(isinstance(result, System.Exception)) - def testNullArrayConversion(self): + def test_null_array_conversion(self): """Test null array conversion in method call.""" - from System import Type + ob = MethodTest() + r = ob.TestNullArrayConversion(None) + self.assertTrue(r is None) - object = MethodTest() - r = object.TestNullArrayConversion(None) - self.assertTrue(r == None) - - def testStringParamsArgs(self): + def test_string_params_args(self): """Test use of string params.""" result = MethodTest.TestStringParamsArg('one', 'two', 'three') self.assertEqual(result.Length, 3) @@ -252,7 +206,7 @@ def testStringParamsArgs(self): self.assertTrue(result[1] == 'two') self.assertTrue(result[2] == 'three') - def testObjectParamsArgs(self): + def test_object_params_args(self): """Test use of object params.""" result = MethodTest.TestObjectParamsArg('one', 'two', 'three') self.assertEqual(len(result), 3, result) @@ -266,7 +220,7 @@ def testObjectParamsArgs(self): self.assertTrue(result[1] == 'two') self.assertTrue(result[2] == 'three') - def testValueParamsArgs(self): + def test_value_params_args(self): """Test use of value type params.""" result = MethodTest.TestValueParamsArg(1, 2, 3) self.assertEqual(len(result), 3) @@ -280,151 +234,140 @@ def testValueParamsArgs(self): self.assertTrue(result[1] == 2) self.assertTrue(result[2] == 3) - def testNonParamsArrayInLastPlace(self): - """Test overload resolution with of non-"params" array as last parameter.""" + 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 testStringOutParams(self): + def test_string_out_params(self): """Test use of string out-parameters.""" result = MethodTest.TestStringOutParams("hi", "there") - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertEqual(len(result), 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(result[1] == "output string") result = MethodTest.TestStringOutParams("hi", None) - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertEqual(len(result), 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(result[1] == "output string") - def testStringRefParams(self): + def test_string_ref_params(self): """Test use of string byref parameters.""" result = MethodTest.TestStringRefParams("hi", "there") - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertEqual(len(result), 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(result[1] == "output string") result = MethodTest.TestStringRefParams("hi", None) - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertEqual(len(result), 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(result[1] == "output string") - def testValueOutParams(self): + def test_value_out_params(self): """Test use of value type out-parameters.""" result = MethodTest.TestValueOutParams("hi", 1) - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertEqual(len(result), 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(result[1] == 42) - def test(): - MethodTest.TestValueOutParams("hi", None) - # None cannot be converted to a value type like int, long, etc. - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + MethodTest.TestValueOutParams("hi", None) - def testValueRefParams(self): + def test_value_ref_params(self): """Test use of value type byref parameters.""" result = MethodTest.TestValueRefParams("hi", 1) - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertEqual(len(result), 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(result[1] == 42) - def test(): - MethodTest.TestValueRefParams("hi", None) - # None cannot be converted to a value type like int, long, etc. - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + MethodTest.TestValueRefParams("hi", None) - def testObjectOutParams(self): + def test_object_out_params(self): """Test use of object out-parameters.""" result = MethodTest.TestObjectOutParams("hi", MethodTest()) - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertTrue(len(result) == 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(isinstance(result[1], System.Exception)) result = MethodTest.TestObjectOutParams("hi", None) - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertEqual(len(result), 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(isinstance(result[1], System.Exception)) - def testObjectRefParams(self): + def test_object_ref_params(self): """Test use of object byref parameters.""" result = MethodTest.TestObjectRefParams("hi", MethodTest()) - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertEqual(len(result), 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(isinstance(result[1], System.Exception)) result = MethodTest.TestObjectRefParams("hi", None) - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertEqual(len(result), 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(isinstance(result[1], System.Exception)) - def testStructOutParams(self): + def test_struct_out_params(self): """Test use of struct out-parameters.""" result = MethodTest.TestStructOutParams("hi", System.Guid.NewGuid()) - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertEqual(len(result), 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(isinstance(result[1], System.Guid)) - def test(): - MethodTest.TestValueRefParams("hi", None) - # None cannot be converted to a value type like a struct - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + MethodTest.TestValueRefParams("hi", None) - def testStructRefParams(self): + def test_struct_ref_params(self): """Test use of struct byref parameters.""" result = MethodTest.TestStructRefParams("hi", System.Guid.NewGuid()) - self.assertTrue(type(result) == type(())) + self.assertTrue(isinstance(result, tuple)) self.assertTrue(len(result) == 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(isinstance(result[1], System.Guid)) - def test(): - MethodTest.TestValueRefParams("hi", None) - # None cannot be converted to a value type like a struct - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + MethodTest.TestValueRefParams("hi", None) - def testVoidSingleOutParam(self): + def test_void_single_out_param(self): """Test void method with single out-parameter.""" result = MethodTest.TestVoidSingleOutParam(9) self.assertTrue(result == 42) - def test(): - MethodTest.TestVoidSingleOutParam(None) - # None cannot be converted to a value type - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + MethodTest.TestVoidSingleOutParam(None) - def testVoidSingleRefParam(self): + def test_void_single_ref_param(self): """Test void method with single ref-parameter.""" result = MethodTest.TestVoidSingleRefParam(9) self.assertTrue(result == 42) - def test(): - MethodTest.TestVoidSingleRefParam(None) - # None cannot be converted to a value type - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + MethodTest.TestVoidSingleRefParam(None) - def testSingleDefaultParam(self): + def test_single_default_param(self): """Test void method with single ref-parameter.""" result = MethodTest.TestSingleDefaultParam() self.assertTrue(result == 5) - def testOneArgAndTwoDefaultParam(self): + def test_one_arg_and_two_default_param(self): """Test void method with single ref-parameter.""" result = MethodTest.TestOneArgAndTwoDefaultParam(11) self.assertTrue(result == 22) @@ -435,60 +378,57 @@ def testOneArgAndTwoDefaultParam(self): result = MethodTest.TestOneArgAndTwoDefaultParam(20) self.assertTrue(result == 31) - def testTwoDefaultParam(self): + def test_two_default_param(self): """Test void method with single ref-parameter.""" result = MethodTest.TestTwoDefaultParam() self.assertTrue(result == 11) - def testExplicitSelectionWithOutModifier(self): + 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(type(result) == type(())) + "hi", "there") + self.assertTrue(isinstance(result, tuple)) self.assertTrue(len(result) == 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(result[1] == "output string") result = MethodTest.TestStringOutParams.__overloads__[str, refstr]( - "hi", None - ) - self.assertTrue(type(result) == type(())) + "hi", None) + self.assertTrue(isinstance(result, tuple)) self.assertTrue(len(result) == 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(result[1] == "output string") - def testExplicitSelectionWithRefModifier(self): + 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(type(result) == type(())) + "hi", "there") + self.assertTrue(isinstance(result, tuple)) self.assertTrue(len(result) == 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(result[1] == "output string") result = MethodTest.TestStringRefParams.__overloads__[str, refstr]( - "hi", None - ) - self.assertTrue(type(result) == type(())) + "hi", None) + self.assertTrue(isinstance(result, tuple)) self.assertTrue(len(result) == 2) - self.assertTrue(result[0] == True) + self.assertTrue(result[0] is True) self.assertTrue(result[1] == "output string") - def testExplicitOverloadSelection(self): + 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 == True) + self.assertTrue(value is True) value = MethodTest.Overloaded.__overloads__[bool](True) - self.assertTrue(value == True) + self.assertTrue(value is True) value = MethodTest.Overloaded.__overloads__[System.Byte](255) self.assertTrue(value == 255) @@ -496,8 +436,8 @@ def testExplicitOverloadSelection(self): value = MethodTest.Overloaded.__overloads__[System.SByte](127) self.assertTrue(value == 127) - value = MethodTest.Overloaded.__overloads__[System.Char](six.u('A')) - self.assertTrue(value == six.u('A')) + 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)) @@ -512,44 +452,39 @@ def testExplicitOverloadSelection(self): self.assertTrue(value == 2147483647) value = MethodTest.Overloaded.__overloads__[System.Int64]( - long(9223372036854775807) - ) + long(9223372036854775807)) self.assertTrue(value == long(9223372036854775807)) # Python 3 has no explicit long type, use System.Int64 instead - if not six.PY3: + if PY2: value = MethodTest.Overloaded.__overloads__[long]( - long(9223372036854775807) - ) + long(9223372036854775807)) self.assertTrue(value == long(9223372036854775807)) value = MethodTest.Overloaded.__overloads__[System.UInt16](65000) self.assertTrue(value == 65000) - value = MethodTest.Overloaded.__overloads__[System.UInt32](long(4294967295)) + value = MethodTest.Overloaded.__overloads__[System.UInt32]( + long(4294967295)) self.assertTrue(value == long(4294967295)) value = MethodTest.Overloaded.__overloads__[System.UInt64]( - long(18446744073709551615) - ) + long(18446744073709551615)) self.assertTrue(value == long(18446744073709551615)) value = MethodTest.Overloaded.__overloads__[System.Single](3.402823e38) self.assertTrue(value == 3.402823e38) value = MethodTest.Overloaded.__overloads__[System.Double]( - 1.7976931348623157e308 - ) + 1.7976931348623157e308) self.assertTrue(value == 1.7976931348623157e308) value = MethodTest.Overloaded.__overloads__[float]( - 1.7976931348623157e308 - ) + 1.7976931348623157e308) self.assertTrue(value == 1.7976931348623157e308) value = MethodTest.Overloaded.__overloads__[System.Decimal]( - System.Decimal.One - ) + System.Decimal.One) self.assertTrue(value == System.Decimal.One) value = MethodTest.Overloaded.__overloads__[System.String]("spam") @@ -572,8 +507,7 @@ def testExplicitOverloadSelection(self): atype = Array[System.Object] value = MethodTest.Overloaded.__overloads__[str, int, atype]( - "one", 1, atype([1, 2, 3]) - ) + "one", 1, atype([1, 2, 3])) self.assertTrue(value == 3) value = MethodTest.Overloaded.__overloads__[str, int]("one", 1) @@ -582,193 +516,185 @@ def testExplicitOverloadSelection(self): value = MethodTest.Overloaded.__overloads__[int, str](1, "one") self.assertTrue(value == 1) - def testOverloadSelectionWithArrayTypes(self): + 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 + inst = InterfaceTest() vtype = Array[System.Boolean] - input = vtype([True, True]) - value = MethodTest.Overloaded.__overloads__[vtype](input) - self.assertTrue(value[0] == True) - self.assertTrue(value[1] == True) + input_ = vtype([True, True]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + self.assertTrue(value[0] is True) + self.assertTrue(value[1] is True) vtype = Array[bool] - input = vtype([True, True]) - value = MethodTest.Overloaded.__overloads__[vtype](input) - self.assertTrue(value[0] == True) - self.assertTrue(value[1] == True) + input_ = vtype([True, True]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + self.assertTrue(value[0] is True) + self.assertTrue(value[1] is True) vtype = Array[System.Byte] - input = vtype([0, 255]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + input_ = vtype([0, 127]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) self.assertTrue(value[0] == 0) self.assertTrue(value[1] == 127) vtype = Array[System.Char] - input = vtype([six.u('A'), six.u('Z')]) - value = MethodTest.Overloaded.__overloads__[vtype](input) - self.assertTrue(value[0] == six.u('A')) - self.assertTrue(value[1] == six.u('Z')) + input_ = vtype([u'A', u'Z']) + value = MethodTest.Overloaded.__overloads__[vtype](input_) + self.assertTrue(value[0] == u'A') + self.assertTrue(value[1] == u'Z') vtype = Array[System.Char] - input = vtype([0, 65535]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + input_ = vtype([0, 32767]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) self.assertTrue(value[0] == 0) self.assertTrue(value[1] == 32767) vtype = Array[System.Int32] - input = vtype([0, 2147483647]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + input_ = vtype([0, 2147483647]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) self.assertTrue(value[0] == 0) self.assertTrue(value[1] == 2147483647) vtype = Array[System.Int64] - input = vtype([0, long(9223372036854775807)]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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 not six.PY3: + if PY2: vtype = Array[long] - input = vtype([0, long(9223372036854775807)]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + input_ = vtype([0, 65000]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) self.assertTrue(value[0] == 0) self.assertTrue(value[1] == 65000) vtype = Array[System.UInt32] - input = vtype([0, long(4294967295)]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + input_ = vtype([0, long(4294967295)]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) self.assertTrue(value[0] == 0) self.assertTrue(value[1] == long(4294967295)) vtype = Array[System.UInt64] - input = vtype([0, long(18446744073709551615)]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + input_ = vtype([0.0, 3.402823e38]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) self.assertTrue(value[0] == 0.0) self.assertTrue(value[1] == 3.402823e38) vtype = Array[System.Double] - input = vtype([0.0, 1.7976931348623157e308]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + 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[System.Decimal] - input = vtype([System.Decimal.Zero, System.Decimal.One]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) vtype = Array[System.String] - input = vtype(["one", "two"]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + input_ = vtype(["one", "two"]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) self.assertTrue(value[0] == "one") self.assertTrue(value[1] == "two") vtype = Array[ShortEnum] - input = vtype([ShortEnum.Zero, ShortEnum.One]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + input_ = vtype([ShortEnum.Zero, ShortEnum.One]) + value = MethodTest.Overloaded.__overloads__[vtype](input_) self.assertTrue(value[0] == ShortEnum.Zero) self.assertTrue(value[1] == ShortEnum.One) vtype = Array[System.Object] - input = vtype([inst, inst]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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) + 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[ISayHello1] - input = vtype([inst, inst]) - value = MethodTest.Overloaded.__overloads__[vtype](input) + 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 testExplicitOverloadSelectionFailure(self): + def test_explicit_overload_selection_failure(self): """Check that overload selection fails correctly.""" - def test(): - value = MethodTest.Overloaded.__overloads__[System.Type](True) - - self.assertRaises(TypeError, test) - - def test(): - value = MethodTest.Overloaded.__overloads__[int, int](1, 1) + with self.assertRaises(TypeError): + _ = MethodTest.Overloaded.__overloads__[System.Type](True) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + _ = MethodTest.Overloaded.__overloads__[int, int](1, 1) - def test(): - value = MethodTest.Overloaded.__overloads__[str, int, int]( - "", 1, 1 - ) + with self.assertRaises(TypeError): + _ = MethodTest.Overloaded.__overloads__[str, int, int]("", 1, 1) - self.assertRaises(TypeError, test) + with self.assertRaises(TypeError): + _ = MethodTest.Overloaded.__overloads__[int, long](1) - def test(): - value = MethodTest.Overloaded.__overloads__[int, long](1) - - self.assertRaises(TypeError, test) - - def testWeCanBindToEncodingGetString(self): - """Check that we can bind to the Encoding.GetString method with variables.""" - + 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 - myBytes = Encoding.UTF8.GetBytes('Some testing string') + + my_bytes = Encoding.UTF8.GetBytes('Some testing string') stream = MemoryStream() - stream.Write(myBytes, 0, myBytes.Length) + stream.Write(my_bytes, 0, my_bytes.Length) stream.Position = 0 - + buff = System.Array.CreateInstance(System.Byte, 3) buff.Initialize() data = [] @@ -782,13 +708,6 @@ def testWeCanBindToEncodingGetString(self): data = ''.join(data) self.assertEqual(data, 'Some testing string') + def test_suite(): return unittest.makeSuite(MethodTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_module.py b/src/tests/test_module.py index fff044f0c..5ee8e6fc2 100644 --- a/src/tests/test_module.py +++ b/src/tests/test_module.py @@ -1,51 +1,37 @@ -import clr - -clr.AddReference('Python.Test') -clr.AddReference('System.Data') +# -*- coding: utf-8 -*- -# testImplicitAssemblyLoad() passes on deprecation warning; perfect! # -##clr.AddReference('System.Windows.Forms') -import sys, os, string, unittest, types, warnings +import clr +import time +import types +import unittest +import warnings from fnmatch import fnmatch -import six -if six.PY3: - ClassType = type -else: - ClassType = types.ClassType +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 isCLRModule(self, object): - return type(object).__name__ == 'ModuleObject' - - def isCLRRootModule(self, object): - if six.PY3: - # in Python 3 the clr module is a normal python module - return object.__name__ == "clr" - return type(object).__name__ == 'CLRModule' - - def isCLRClass(self, object): - return type(object).__name__ == 'CLR Metatype' # for now - - def testAAAImportHookWorks(self): + 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 test000importClr(self): + def test_import_clr(self): import clr - self.assertTrue(self.isCLRRootModule(clr)) + self.assertTrue(is_clr_root_module(clr)) - def testVersionClr(self): + def test_version_clr(self): import clr self.assertTrue(clr.__version__ >= "2.2.0") - def testPreloadVar(self): + def test_preload_var(self): import clr self.assertTrue(clr.getPreload() is False, clr.getPreload()) clr.setPreload(False) @@ -64,7 +50,7 @@ def testPreloadVar(self): finally: clr.setPreload(False) - def testModuleInterface(self): + def test_module_interface(self): """Test the interface exposed by CLR module objects.""" import System self.assertEquals(type(System.__dict__), type({})) @@ -75,143 +61,142 @@ def testModuleInterface(self): 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(self.isCLRClass(System.String)) - self.assertTrue(self.isCLRClass(System.Int32)) + self.assertTrue(is_clr_class(System.String)) + self.assertTrue(is_clr_class(System.Int32)) - def testSimpleImport(self): + def test_simple_import(self): """Test simple import.""" import System - self.assertTrue(self.isCLRModule(System)) + self.assertTrue(is_clr_module(System)) self.assertTrue(System.__name__ == 'System') import sys - self.assertTrue(type(sys) == types.ModuleType) + self.assertTrue(isinstance(sys, types.ModuleType)) self.assertTrue(sys.__name__ == 'sys') - if six.PY3: + if PY3: import http.client as httplib - self.assertTrue(type(httplib) == types.ModuleType) + self.assertTrue(isinstance(httplib, types.ModuleType)) self.assertTrue(httplib.__name__ == 'http.client') - else: + elif PY2: import httplib - self.assertTrue(type(httplib) == types.ModuleType) + self.assertTrue(isinstance(httplib, types.ModuleType)) self.assertTrue(httplib.__name__ == 'httplib') - def testSimpleImportWithAlias(self): + def test_simple_import_with_alias(self): """Test simple import with aliasing.""" import System as mySystem - self.assertTrue(self.isCLRModule(mySystem)) + self.assertTrue(is_clr_module(mySystem)) self.assertTrue(mySystem.__name__ == 'System') import sys as mySys - self.assertTrue(type(mySys) == types.ModuleType) + self.assertTrue(isinstance(mySys, types.ModuleType)) self.assertTrue(mySys.__name__ == 'sys') - if six.PY3: + if PY3: import http.client as myHttplib - self.assertTrue(type(myHttplib) == types.ModuleType) + self.assertTrue(isinstance(myHttplib, types.ModuleType)) self.assertTrue(myHttplib.__name__ == 'http.client') - else: + elif PY2: import httplib as myHttplib - self.assertTrue(type(myHttplib) == types.ModuleType) + self.assertTrue(isinstance(myHttplib, types.ModuleType)) self.assertTrue(myHttplib.__name__ == 'httplib') - def testDottedNameImport(self): + def test_dotted_name_import(self): """Test dotted-name import.""" import System.Reflection - self.assertTrue(self.isCLRModule(System.Reflection)) + self.assertTrue(is_clr_module(System.Reflection)) self.assertTrue(System.Reflection.__name__ == 'System.Reflection') import xml.dom - self.assertTrue(type(xml.dom) == types.ModuleType) + self.assertTrue(isinstance(xml.dom, types.ModuleType)) self.assertTrue(xml.dom.__name__ == 'xml.dom') - def testMultipleDottedNameImport(self): + def test_multiple_dotted_name_import(self): """Test an import bug with multiple dotted imports.""" import System.Data - self.assertTrue(self.isCLRModule(System.Data)) + self.assertTrue(is_clr_module(System.Data)) self.assertTrue(System.Data.__name__ == 'System.Data') import System.Data - self.assertTrue(self.isCLRModule(System.Data)) + self.assertTrue(is_clr_module(System.Data)) self.assertTrue(System.Data.__name__ == 'System.Data') - def testDottedNameImportWithAlias(self): + def test_dotted_name_import_with_alias(self): """Test dotted-name import with aliasing.""" import System.Reflection as SysRef - self.assertTrue(self.isCLRModule(SysRef)) + self.assertTrue(is_clr_module(SysRef)) self.assertTrue(SysRef.__name__ == 'System.Reflection') import xml.dom as myDom - self.assertTrue(type(myDom) == types.ModuleType) + self.assertTrue(isinstance(myDom, types.ModuleType)) self.assertTrue(myDom.__name__ == 'xml.dom') - def testSimpleImportFrom(self): + def test_simple_import_from(self): """Test simple 'import from'.""" from System import Reflection - self.assertTrue(self.isCLRModule(Reflection)) + self.assertTrue(is_clr_module(Reflection)) self.assertTrue(Reflection.__name__ == 'System.Reflection') from xml import dom - self.assertTrue(type(dom) == types.ModuleType) + self.assertTrue(isinstance(dom, types.ModuleType)) self.assertTrue(dom.__name__ == 'xml.dom') - def testSimpleImportFromWithAlias(self): + def test_simple_import_from_with_alias(self): """Test simple 'import from' with aliasing.""" from System import Collections as Coll - self.assertTrue(self.isCLRModule(Coll)) + self.assertTrue(is_clr_module(Coll)) self.assertTrue(Coll.__name__ == 'System.Collections') from xml import dom as myDom - self.assertTrue(type(myDom) == types.ModuleType) + self.assertTrue(isinstance(myDom, types.ModuleType)) self.assertTrue(myDom.__name__ == 'xml.dom') - def testDottedNameImportFrom(self): + def test_dotted_name_import_from(self): """Test dotted-name 'import from'.""" from System.Collections import Specialized - self.assertTrue(self.isCLRModule(Specialized)) + self.assertTrue(is_clr_module(Specialized)) self.assertTrue( - Specialized.__name__ == 'System.Collections.Specialized' - ) + Specialized.__name__ == 'System.Collections.Specialized') from System.Collections.Specialized import StringCollection - self.assertTrue(self.isCLRClass(StringCollection)) + self.assertTrue(is_clr_class(StringCollection)) self.assertTrue(StringCollection.__name__ == 'StringCollection') from xml.dom import pulldom - self.assertTrue(type(pulldom) == types.ModuleType) + self.assertTrue(isinstance(pulldom, types.ModuleType)) self.assertTrue(pulldom.__name__ == 'xml.dom.pulldom') from xml.dom.pulldom import PullDOM - self.assertTrue(type(PullDOM) == ClassType) + self.assertTrue(isinstance(PullDOM, ClassType)) self.assertTrue(PullDOM.__name__ == 'PullDOM') - def testDottedNameImportFromWithAlias(self): + 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(self.isCLRModule(Spec)) + self.assertTrue(is_clr_module(Spec)) self.assertTrue(Spec.__name__ == 'System.Collections.Specialized') from System.Collections.Specialized import StringCollection as SC - self.assertTrue(self.isCLRClass(SC)) + self.assertTrue(is_clr_class(SC)) self.assertTrue(SC.__name__ == 'StringCollection') from xml.dom import pulldom as myPulldom - self.assertTrue(type(myPulldom) == types.ModuleType) + self.assertTrue(isinstance(myPulldom, types.ModuleType)) self.assertTrue(myPulldom.__name__ == 'xml.dom.pulldom') from xml.dom.pulldom import PullDOM as myPullDOM - self.assertTrue(type(myPullDOM) == ClassType) + self.assertTrue(isinstance(myPullDOM, ClassType)) self.assertTrue(myPullDOM.__name__ == 'PullDOM') - def testFromModuleImportStar(self): + 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(self.isCLRModule(m)) + self.assertTrue(is_clr_module(m)) self.assertTrue(len(locals().keys()) > count + 1) - def testImplicitAssemblyLoad(self): + def test_implicit_assembly_load(self): """Test implicit assembly loading via import.""" with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") @@ -226,28 +211,28 @@ def testImplicitAssemblyLoad(self): with warnings.catch_warnings(record=True) as w: clr.AddReference("System.Windows.Forms") import System.Windows.Forms as Forms - self.assertTrue(self.isCLRModule(Forms)) + self.assertTrue(is_clr_module(Forms)) self.assertTrue(Forms.__name__ == 'System.Windows.Forms') from System.Windows.Forms import Form - self.assertTrue(self.isCLRClass(Form)) + self.assertTrue(is_clr_class(Form)) self.assertTrue(Form.__name__ == 'Form') self.assertEqual(len(w), 0) - def testExplicitAssemblyLoad(self): + 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 != None) + self.assertTrue(assembly is not None) import System.Data self.assertTrue('System.Data' in sys.modules) assembly = Assembly.LoadWithPartialName('SpamSpamSpamSpamEggsAndSpam') - self.assertTrue(assembly == None) + self.assertTrue(assembly is None) - def testImplicitLoadAlreadyValidNamespace(self): + 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 @@ -256,57 +241,46 @@ def testImplicitLoadAlreadyValidNamespace(self): # Python runtime to "do the right thing", allowing types from both # assemblies to be found in the System module implicitly. import System - self.assertTrue(self.isCLRClass(System.UriBuilder)) + self.assertTrue(is_clr_class(System.UriBuilder)) - def testImportNonExistantModule(self): - """Test import failure for a non-existant module.""" - - def test(): + def test_import_non_existant_module(self): + """Test import failure for a non-existent module.""" + with self.assertRaises(ImportError): import System.SpamSpamSpam - self.assertTrue(ImportError, test) - - def testLookupNoNamespaceType(self): + def test_lookup_no_namespace_type(self): """Test lookup of types without a qualified namespace.""" import Python.Test import clr - self.assertTrue(self.isCLRClass(clr.NoNamespaceType)) + self.assertTrue(is_clr_class(clr.NoNamespaceType)) - def testModuleLookupRecursion(self): + def test_module_lookup_recursion(self): """Test for recursive lookup handling.""" - def test1(): + with self.assertRaises(ImportError): from System import System - self.assertTrue(ImportError, test1) - - def test2(): + with self.assertRaises(AttributeError): import System - x = System.System - - self.assertTrue(AttributeError, test2) + _ = System.System - def testModuleGetAttr(self): + def test_module_get_attr(self): """Test module getattr behavior.""" import System int_type = System.Int32 - self.assertTrue(self.isCLRClass(int_type)) + self.assertTrue(is_clr_class(int_type)) module = System.Xml - self.assertTrue(self.isCLRModule(module)) + self.assertTrue(is_clr_module(module)) - def test(): - spam = System.Spam - - self.assertTrue(AttributeError, test) - - def test(): - spam = getattr(System, 1) + with self.assertRaises(AttributeError): + _ = System.Spam - self.assertTrue(TypeError, test) + with self.assertRaises(TypeError): + _ = getattr(System, 1) - def testModuleAttrAbuse(self): + def test_module_attr_abuse(self): """Test handling of attempts to set module attributes.""" # It would be safer to use a dict-proxy as the __dict__ for CLR @@ -320,70 +294,55 @@ def test(): self.assertTrue(test()) - def testModuleTypeAbuse(self): + def test_module_type_abuse(self): """Test handling of attempts to break the module type.""" import System mtype = type(System) - def test(): + with self.assertRaises(TypeError): mtype.__getattribute__(0, 'spam') - self.assertTrue(TypeError, test) - - def test(): + with self.assertRaises(TypeError): mtype.__setattr__(0, 'spam', 1) - self.assertTrue(TypeError, test) - - def test(): + with self.assertRaises(TypeError): mtype.__repr__(0) - self.assertTrue(TypeError, test) - - def test_ClrListAssemblies(self): + def test_clr_list_assemblies(self): from clr import ListAssemblies verbose = list(ListAssemblies(True)) short = list(ListAssemblies(False)) - self.assertTrue(six.u('mscorlib') in short) - self.assertTrue(six.u('System') in short) - self.assertTrue(six.u('Culture=') in verbose[0]) - self.assertTrue(six.u('Version=') in verbose[0]) + 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_ClrAddReference(self): + def test_clr_add_reference(self): from clr import AddReference from System.IO import FileNotFoundException for name in ("System", "Python.Runtime"): assy = AddReference(name) - assyName = assy.GetName().Name - self.assertEqual(assyName, name) + assy_name = assy.GetName().Name + self.assertEqual(assy_name, name) - self.assertRaises(FileNotFoundException, - AddReference, "somethingtotallysilly") + with self.assertRaises(FileNotFoundException): + AddReference("somethingtotallysilly") - def test_AssemblyLoadThreadSafety(self): - import time + 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 i in range(1, 100): + 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 - dict = Dictionary[Guid,DateTime]() + _ = Dictionary[Guid, DateTime]() ModuleTest.JoinThreads() def test_suite(): return unittest.makeSuite(ModuleTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_property.py b/src/tests/test_property.py index 5bb653848..8fb37768a 100644 --- a/src/tests/test_property.py +++ b/src/tests/test_property.py @@ -1,174 +1,141 @@ -import sys, os, string, unittest, types -from Python.Test import PropertyTest -import six +# -*- coding: utf-8 -*- + +import unittest -if six.PY3: - IntType = int -else: - IntType = types.IntType +from Python.Test import PropertyTest class PropertyTests(unittest.TestCase): """Test CLR property support.""" - def testPublicInstanceProperty(self): + def test_public_instance_property(self): """Test public instance properties.""" - object = PropertyTest(); + ob = PropertyTest() - self.assertTrue(object.PublicProperty == 0) - object.PublicProperty = 1 - self.assertTrue(object.PublicProperty == 1) + self.assertTrue(ob.PublicProperty == 0) + ob.PublicProperty = 1 + self.assertTrue(ob.PublicProperty == 1) - def test(): + with self.assertRaises(TypeError): del PropertyTest().PublicProperty - self.assertRaises(TypeError, test) - - def testPublicStaticProperty(self): + def test_public_static_property(self): """Test public static properties.""" - object = PropertyTest(); + ob = PropertyTest() self.assertTrue(PropertyTest.PublicStaticProperty == 0) PropertyTest.PublicStaticProperty = 1 self.assertTrue(PropertyTest.PublicStaticProperty == 1) - self.assertTrue(object.PublicStaticProperty == 1) - object.PublicStaticProperty = 0 - self.assertTrue(object.PublicStaticProperty == 0) + self.assertTrue(ob.PublicStaticProperty == 1) + ob.PublicStaticProperty = 0 + self.assertTrue(ob.PublicStaticProperty == 0) - def test(): + with self.assertRaises(TypeError): del PropertyTest.PublicStaticProperty - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del PropertyTest().PublicStaticProperty - self.assertRaises(TypeError, test) - - def testProtectedInstanceProperty(self): + def test_protected_instance_property(self): """Test protected instance properties.""" - object = PropertyTest(); + ob = PropertyTest() - self.assertTrue(object.ProtectedProperty == 0) - object.ProtectedProperty = 1 - self.assertTrue(object.ProtectedProperty == 1) + self.assertTrue(ob.ProtectedProperty == 0) + ob.ProtectedProperty = 1 + self.assertTrue(ob.ProtectedProperty == 1) - def test(): + with self.assertRaises(TypeError): del PropertyTest().ProtectedProperty - self.assertRaises(TypeError, test) - - def testProtectedStaticProperty(self): + def test_protected_static_property(self): """Test protected static properties.""" - object = PropertyTest(); + ob = PropertyTest() self.assertTrue(PropertyTest.ProtectedStaticProperty == 0) PropertyTest.ProtectedStaticProperty = 1 self.assertTrue(PropertyTest.ProtectedStaticProperty == 1) - self.assertTrue(object.ProtectedStaticProperty == 1) - object.ProtectedStaticProperty = 0 - self.assertTrue(object.ProtectedStaticProperty == 0) + self.assertTrue(ob.ProtectedStaticProperty == 1) + ob.ProtectedStaticProperty = 0 + self.assertTrue(ob.ProtectedStaticProperty == 0) - def test(): + with self.assertRaises(TypeError): del PropertyTest.ProtectedStaticProperty - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): del PropertyTest().ProtectedStaticProperty - self.assertRaises(TypeError, test) - - def testInternalProperty(self): + def test_internal_property(self): """Test internal properties.""" - def test(): - f = PropertyTest().InternalProperty - - self.assertRaises(AttributeError, test) - - def test(): - f = PropertyTest().InternalStaticProperty - - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = PropertyTest().InternalProperty - def test(): - f = PropertyTest.InternalStaticProperty + with self.assertRaises(AttributeError): + _ = PropertyTest().InternalStaticProperty - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = PropertyTest.InternalStaticProperty - def testPrivateProperty(self): + def test_private_property(self): """Test private properties.""" - def test(): - f = PropertyTest().PrivateProperty + with self.assertRaises(AttributeError): + _ = PropertyTest().PrivateProperty - self.assertRaises(AttributeError, test) + with self.assertRaises(AttributeError): + _ = PropertyTest().PrivateStaticProperty - def test(): - f = PropertyTest().PrivateStaticProperty + with self.assertRaises(AttributeError): + _ = PropertyTest.PrivateStaticProperty - self.assertRaises(AttributeError, test) - - def test(): - f = PropertyTest.PrivateStaticProperty - - self.assertRaises(AttributeError, test) - - def testPropertyDescriptorGetSet(self): + def test_property_descriptor_get_set(self): """Test property descriptor get / set.""" # 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. - object = PropertyTest() + ob = PropertyTest() self.assertTrue(PropertyTest.PublicStaticProperty == 0) - self.assertTrue(object.PublicStaticProperty == 0) + self.assertTrue(ob.PublicStaticProperty == 0) descriptor = PropertyTest.__dict__['PublicStaticProperty'] - self.assertTrue(type(descriptor) != IntType) + self.assertTrue(type(descriptor) != int) - object.PublicStaticProperty = 0 + ob.PublicStaticProperty = 0 descriptor = PropertyTest.__dict__['PublicStaticProperty'] - self.assertTrue(type(descriptor) != IntType) + self.assertTrue(type(descriptor) != int) PropertyTest.PublicStaticProperty = 0 descriptor = PropertyTest.__dict__['PublicStaticProperty'] - self.assertTrue(type(descriptor) != IntType) + self.assertTrue(type(descriptor) != int) - def testPropertyDescriptorWrongType(self): + def test_property_descriptor_wrong_type(self): """Test setting a property using a value of the wrong type.""" - def test(): - object = PropertyTest() - object.PublicProperty = "spam" + with self.assertRaises(TypeError): + ob = PropertyTest() + ob.PublicProperty = "spam" - self.assertTrue(TypeError, test) - - def testPropertyDescriptorAbuse(self): + def test_property_descriptor_abuse(self): """Test property descriptor abuse.""" desc = PropertyTest.__dict__['PublicProperty'] - def test(): + with self.assertRaises(TypeError): desc.__get__(0, 0) - self.assertRaises(TypeError, test) - - def test(): + with self.assertRaises(TypeError): desc.__set__(0, 0) - self.assertRaises(TypeError, test) - - def testInterfaceProperty(self): + 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 + mapping = Hashtable() coll = ICollection(mapping) self.assertTrue(coll.Count == 0) @@ -176,11 +143,3 @@ def testInterfaceProperty(self): def test_suite(): return unittest.makeSuite(PropertyTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_subclass.py b/src/tests/test_subclass.py index c486a0fc3..34ec86d9a 100644 --- a/src/tests/test_subclass.py +++ b/src/tests/test_subclass.py @@ -1,133 +1,162 @@ -import clr +# -*- coding: utf-8 -*- +# FIXME: This test module randomly passes/fails even if all tests are skipped. +# Something fishy is going on with the Test fixtures. Behavior seen on CI on +# both Linux and Windows +# TODO: Remove delay of class creations. Adding SetUp/TearDown may help -clr.AddReference('Python.Test') -clr.AddReference('System') +import unittest -import sys, os, string, unittest, types -from Python.Test import TestFunctions, SubClassTest, IInterfaceTest, TestEventArgs +import System +from Python.Test import (IInterfaceTest, SubClassTest, EventArgsTest, + FunctionsTest) from System.Collections.Generic import List -from System import NotImplementedException +from _compat import range -# class that implements the test interface -class InterfaceTestClass(IInterfaceTest): - __namespace__ = "Python.Test" - def foo(self): - return "InterfaceTestClass" +def interface_test_class_fixture(): + """Delay creation of class until test starts.""" - def bar(self, x, i): - return "/".join([x] * i) + class InterfaceTestClass(IInterfaceTest): + """class that implements the test interface""" + __namespace__ = "Python.Test" + def foo(self): + return "InterfaceTestClass" -# class that derives from a class deriving from IInterfaceTest -class DerivedClass(SubClassTest): - __namespace__ = "Python.Test" + def bar(self, x, i): + return "/".join([x] * i) - def foo(self): - return "DerivedClass" + return InterfaceTestClass - def base_foo(self): - return SubClassTest.foo(self) - def super_foo(self): - return super(DerivedClass, self).foo() +def derived_class_fixture(): + """Delay creation of class until test starts.""" - def bar(self, x, i): - return "_".join([x] * i) + class DerivedClass(SubClassTest): + """class that derives from a class deriving from IInterfaceTest""" + __namespace__ = "Python.Test" - def return_list(self): - l = List[str]() - l.Add("A") - l.Add("B") - l.Add("C") - return l + def foo(self): + return "DerivedClass" + def base_foo(self): + return SubClassTest.foo(self) -# class that implements IInterfaceTest.TestEvent -class DerivedEventTest(IInterfaceTest): - __namespace__ = "Python.Test" + def super_foo(self): + return super(DerivedClass, self).foo() - def __init__(self): - self.event_handlers = [] + def bar(self, x, i): + return "_".join([x] * i) - # event handling - def add_TestEvent(self, handler): - self.event_handlers.append(handler) + def return_list(self): + l = List[str]() + l.Add("A") + l.Add("B") + l.Add("C") + return l - def remove_TestEvent(self, handler): - self.event_handlers.remove(handler) + return DerivedClass - def OnTestEvent(self, value): - args = TestEventArgs(value) - for handler in self.event_handlers: - handler(self, args) + +def derived_event_test_class_fixture(): + """Delay creation of class until test starts.""" + + class DerivedEventTest(IInterfaceTest): + """class that implements IInterfaceTest.TestEvent""" + __namespace__ = "Python.Test" + + def __init__(self): + self.event_handlers = [] + + # event handling + def add_TestEvent(self, handler): + self.event_handlers.append(handler) + + def remove_TestEvent(self, handler): + self.event_handlers.remove(handler) + + def OnTestEvent(self, value): + args = EventArgsTest(value) + for handler in self.event_handlers: + handler(self, args) + + return DerivedEventTest class SubClassTests(unittest.TestCase): - """Test subclassing managed types""" + """Test sub-classing managed types""" - def testBaseClass(self): + @unittest.skip(reason="FIXME: test randomly pass/fails") + def test_base_class(self): """Test base class managed type""" - object = SubClassTest() - self.assertEqual(object.foo(), "foo") - self.assertEqual(TestFunctions.test_foo(object), "foo") - self.assertEqual(object.bar("bar", 2), "bar") - self.assertEqual(TestFunctions.test_bar(object, "bar", 2), "bar") - self.assertEqual(object.not_overriden(), "not_overriden") - self.assertEqual(list(object.return_list()), ["a", "b", "c"]) - self.assertEqual(list(SubClassTest.test_list(object)), ["a", "b", "c"]) - - def testInterface(self): + 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""" - object = InterfaceTestClass() - self.assertEqual(object.foo(), "InterfaceTestClass") - self.assertEqual(TestFunctions.test_foo(object), "InterfaceTestClass") - self.assertEqual(object.bar("bar", 2), "bar/bar") - self.assertEqual(TestFunctions.test_bar(object, "bar", 2), "bar/bar") - - x = TestFunctions.pass_through(object) - self.assertEqual(id(x), id(object)) - - def testDerivedClass(self): + 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""" - object = DerivedClass() - self.assertEqual(object.foo(), "DerivedClass") - self.assertEqual(object.base_foo(), "foo") - self.assertEqual(object.super_foo(), "foo") - self.assertEqual(TestFunctions.test_foo(object), "DerivedClass") - self.assertEqual(object.bar("bar", 2), "bar_bar") - self.assertEqual(TestFunctions.test_bar(object, "bar", 2), "bar_bar") - self.assertEqual(object.not_overriden(), "not_overriden") - self.assertEqual(list(object.return_list()), ["A", "B", "C"]) - self.assertEqual(list(SubClassTest.test_list(object)), ["A", "B", "C"]) - - x = TestFunctions.pass_through(object) - self.assertEqual(id(x), id(object)) - - def testCreateInstance(self): + 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""" - object = TestFunctions.create_instance(DerivedClass) - self.assertEqual(object.foo(), "DerivedClass") - self.assertEqual(TestFunctions.test_foo(object), "DerivedClass") - self.assertEqual(object.bar("bar", 2), "bar_bar") - self.assertEqual(TestFunctions.test_bar(object, "bar", 2), "bar_bar") - self.assertEqual(object.not_overriden(), "not_overriden") - - x = TestFunctions.pass_through(object) - self.assertEqual(id(x), id(object)) - - object2 = TestFunctions.create_instance(InterfaceTestClass) - self.assertEqual(object2.foo(), "InterfaceTestClass") - self.assertEqual(TestFunctions.test_foo(object2), "InterfaceTestClass") - self.assertEqual(object2.bar("bar", 2), "bar/bar") - self.assertEqual(TestFunctions.test_bar(object2, "bar", 2), "bar/bar") - - y = TestFunctions.pass_through(object2) - self.assertEqual(id(y), id(object2)) - - def testEvents(self): - class EventHandler: + 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 @@ -135,41 +164,33 @@ def handler(self, x, args): x = SubClassTest() x.TestEvent += event_handler.handler - self.assertEqual(TestFunctions.test_event(x, 1), 1) + self.assertEqual(FunctionsTest.test_event(x, 1), 1) self.assertEqual(event_handler.value, 1) + InterfaceTestClass = interface_test_class_fixture() i = InterfaceTestClass() - self.assertRaises(NotImplementedException, TestFunctions.test_event, i, 2) + 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(TestFunctions.test_event(d, 3), 3) + 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): - from System import Object - from System import String - a = [str(x) for x in range(0, 1000)] - b = [String(x) for x in a] + b = [System.String(x) for x in a] for x in a: - self.assertFalse(isinstance(x, Object)) - self.assertFalse(isinstance(x, String)) + self.assertFalse(isinstance(x, System.Object)) + self.assertFalse(isinstance(x, System.String)) for x in b: - self.assertTrue(isinstance(x, Object)) - self.assertTrue(isinstance(x, String)) + self.assertTrue(isinstance(x, System.Object)) + self.assertTrue(isinstance(x, System.String)) def test_suite(): return unittest.makeSuite(SubClassTests) - - -def main(): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/test_suite/__init__.py b/src/tests/test_suite/__init__.py index 5b1cc4ae4..ecc1c858f 100644 --- a/src/tests/test_suite/__init__.py +++ b/src/tests/test_suite/__init__.py @@ -1,14 +1,15 @@ -import unittest +# -*- coding: utf-8 -*- -__all__ = ['test_suite'] +import unittest -from .test_import import test_suite as import_tests from .test_callback import test_suite as callback_tests -from .test_recursiveTypes import test_suite as recursiveTypes_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((recursiveTypes_tests(),)) - return suite \ No newline at end of file + suite.addTests((recursive_types_tests(),)) + return suite diff --git a/src/tests/test_suite/_missing_import.py b/src/tests/test_suite/_missing_import.py index 629ff95be..a104cda49 100644 --- a/src/tests/test_suite/_missing_import.py +++ b/src/tests/test_suite/_missing_import.py @@ -1,2 +1,3 @@ +# -*- coding: utf-8 -*- -import this_package_should_never_exist_ever \ No newline at end of file +import this_package_should_never_exist_ever diff --git a/src/tests/test_suite/test_callback.py b/src/tests/test_suite/test_callback.py index 16c45914d..2cb234442 100644 --- a/src/tests/test_suite/test_callback.py +++ b/src/tests/test_suite/test_callback.py @@ -1,30 +1,33 @@ -import unittest, sys -import clr +# -*- coding: utf-8 -*- -this_module = sys.modules[__name__] -clr.AddReference("Python.Test") -import Python.Test as Test -from Python.Test import CallbackTest -test_instance = CallbackTest() +import unittest -def simpleDefaultArg(arg = 'test'): + +def simpleDefaultArg(arg='test'): return arg + class CallbackTests(unittest.TestCase): """Test that callbacks from C# into python work.""" - def testDefaultForNull(self): + def test_default_for_null(self): """Test that C# can use null for an optional python argument""" - retVal = test_instance.Call_simpleDefaultArg_WithNull(__name__) - pythonRetVal = simpleDefaultArg(None) - self.assertEquals(retVal, pythonRetVal) + 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 testDefaultForNone(self): + def test_default_for_none(self): """Test that C# can use no argument for an optional python argument""" - retVal = test_instance.Call_simpleDefaultArg_WithEmptyArgs(__name__) - pythonRetVal = simpleDefaultArg() - self.assertEquals(retVal, pythonRetVal) + 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 index b6d155af3..9bae9ca5f 100644 --- a/src/tests/test_suite/test_import.py +++ b/src/tests/test_suite/test_import.py @@ -1,16 +1,18 @@ +# -*- coding: utf-8 -*- + import unittest + class ImportTests(unittest.TestCase): """Test the import statement.""" - def testRealtiveMissingImport(self): - """Test that a relative missing import doesn't crash. Some modules use this to check if a package is installed (realtive import in the site-packages folder""" - try: + 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 - except ImportError: - pass def test_suite(): return unittest.makeSuite(ImportTests) - diff --git a/src/tests/test_suite/test_recursiveTypes.py b/src/tests/test_suite/test_recursive_types.py similarity index 54% rename from src/tests/test_suite/test_recursiveTypes.py rename to src/tests/test_suite/test_recursive_types.py index 290d7236a..a213937a5 100644 --- a/src/tests/test_suite/test_recursiveTypes.py +++ b/src/tests/test_suite/test_recursive_types.py @@ -1,20 +1,19 @@ -import unittest, sys -import clr +# -*- coding: utf-8 -*- + +import unittest + -this_module = sys.modules[__name__] -clr.AddReference("Python.Test") class RecursiveTypesTests(unittest.TestCase): """Test if interop with recursive type inheritance works.""" - def testRecursiveTypeCreation(self): - """Test that a recursive types don't crash with a StackOverflowException""" - import Python.Test as Test + 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() - pass def test_suite(): return unittest.makeSuite(RecursiveTypesTests) - diff --git a/src/tests/test_thread.py b/src/tests/test_thread.py index 67873d83c..623be60a0 100644 --- a/src/tests/test_thread.py +++ b/src/tests/test_thread.py @@ -1,41 +1,39 @@ -import sys, os, string, unittest, types -from Python.Test import ThreadTest -import six +# -*- coding: utf-8 -*- -if six.PY3: - import _thread as thread -else: - import thread +import threading +import time +import unittest - -def dprint(msg): - # Debugging helper to trace thread-related tests. - if 0: print(msg) +from _compat import range, thread +from utils import dprint class ThreadTests(unittest.TestCase): """Test CLR bridge threading and GIL handling.""" - def testSimpleCallbackToPython(self): + 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 testDoubleCallbackToPython(self): + 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 DoubleCallBack" % thread.get_ident()) result = ThreadTest.CallEchoString2("spam") self.assertTrue(result == "spam") dprint("thread %s DoubleCallBack ret" % thread.get_ident()) - def testPythonThreadCallsToCLR(self): + 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 threading, time - from System import String + import System done = [] @@ -43,15 +41,15 @@ def run_thread(): for i in range(10): time.sleep(0.1) dprint("thread %s %d" % (thread.get_ident(), i)) - mstr = String("thread %s %d" % (thread.get_ident(), i)) - pstr = mstr.ToString() + 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 i in range(count): - thread = threading.Thread(target=run_thread) - thread.start() + for _ in range(count): + thread_ = threading.Thread(target=run_thread) + thread_.start() start_threads(5) @@ -59,17 +57,6 @@ def start_threads(count): dprint(len(done)) time.sleep(0.1) - return - def test_suite(): return unittest.makeSuite(ThreadTests) - - -def main(): - for i in range(50): - unittest.TextTestRunner().run(test_suite()) - - -if __name__ == '__main__': - main() diff --git a/src/tests/utils.py b/src/tests/utils.py new file mode 100644 index 000000000..6729d7b30 --- /dev/null +++ b/src/tests/utils.py @@ -0,0 +1,140 @@ +# -*- coding: utf-8 -*- + +"""Tests Utilities + +Refactor utility functions and classes +""" + +from __future__ import print_function + +from _compat import PY2, PY3 + + +def dprint(msg): + # Debugging helper to trace thread-related tests. + if 0: + print(msg) + + +def is_clr_module(ob): + return type(ob).__name__ == 'ModuleObject' + + +def is_clr_root_module(ob): + if PY3: + # in Python 3 the clr module is a normal python module + return ob.__name__ == "clr" + elif PY2: + return type(ob).__name__ == 'CLRModule' + + +def is_clr_class(ob): + return type(ob).__name__ == 'CLR Metatype' # for now + + +class ClassicClass: + def kind(self): + return "classic" + + +class NewStyleClass(object): + def kind(self): + return "new-style" + + +class GenericHandler(object): + """A generic handler to test event callbacks.""" + + def __init__(self): + self.value = None + + def handler(self, sender, args): + self.value = args.value + + +class VariableArgsHandler(object): + """A variable args handler to test event callbacks.""" + + def __init__(self): + self.value = None + + def handler(self, *args): + ob, eventargs = args + self.value = eventargs.value + + +class CallableHandler(object): + """A callable handler to test event callbacks.""" + + def __init__(self): + self.value = None + + def __call__(self, sender, args): + self.value = args.value + + +class VarCallableHandler(object): + """A variable args callable handler to test event callbacks.""" + + def __init__(self): + self.value = None + + def __call__(self, *args): + ob, eventargs = args + self.value = eventargs.value + + +class StaticMethodHandler(object): + """A static method handler to test event callbacks.""" + + value = None + + def handler(sender, args): + StaticMethodHandler.value = args.value + + handler = staticmethod(handler) + + +class ClassMethodHandler(object): + """A class method handler to test event callbacks.""" + + value = None + + def handler(cls, sender, args): + cls.value = args.value + + handler = classmethod(handler) + + +class MultipleHandler(object): + """A generic handler to test multiple callbacks.""" + + def __init__(self): + self.value = 0 + + def handler(self, sender, args): + self.value += args.value + + def count(self): + self.value += 1 + return 'ok' + + +class HelloClass(object): + def hello(self): + return "hello" + + def __call__(self): + return "hello" + + @staticmethod + def s_hello(): + return "hello" + + @classmethod + def c_hello(cls): + return "hello" + + +def hello_func(): + return "hello" diff --git a/src/tests/warnfilter.py b/src/tests/warnfilter.py deleted file mode 100644 index 8e378b86c..000000000 --- a/src/tests/warnfilter.py +++ /dev/null @@ -1,11 +0,0 @@ -"""Warnfilter -""" - -from warnings import filterwarnings -from warnings import resetwarnings - - -def addClrWarnfilter(action="ignore", append=False): - msgs = ["^The CLR module is deprecated.*", "^Importing from the CLR\.\* namespace.*"] - for msg in msgs: - filterwarnings(action, msg, category=DeprecationWarning, append=append)