""" XXX: Should verify if test_methods2.py implements all tests in this file. Test lowlevel message passing details (Python -> ObjC) NOTE: 'long long' return-value test for calls from Objective-C are disabled, they crash the interpreter. Done: - Return simple values, but need to add limit-cases (exactly INT_MAX et.al.) - Return structs, but need to add more complex cases - Pass in basic types - Pass in struct types, but need to add more complex cases - Pass by reference of basic types (in, out, inout) [Need to add python side of case 'id'] Todo: - Pass by reference of struct types (in, out, inout) - more than 1 argument - More argument conversions Also Todo: Passing from Objective-C to python - Using NSInvocation '[obj forwardInvocation:inv]' - Using normal calls - Done: Return simple values, return structs, pass in basic types (c part) NOTES: - Always use makeCFloat when testing the value of a C float against a precomputed (literal) value. Just comparing against a Python float won't work as that is a C double which has a different representation from C floats resulting in spurious test failures. - See also testbndl.m, the implementation there must be synchronized with this file. """ from PyObjCTools.TestSupport import * import objc import sys import struct # Can't set the right signatures in plain Objective-C. for method, argmeta in [ ( b"passInOutChar:", { 2: dict(type_modifier=b'N')}), ( b"passOutChar:", { 2: dict(type_modifier=b'o')}), ( b"passInChar:", { 2: dict(type_modifier=b'n')}), ( b"passInOutUChar:", { 2: dict(type_modifier=b'N', type='^C')}), ( b"passOutUChar:", { 2: dict(type_modifier=b'o', type='^C')}), ( b"passInUChar:", { 2: dict(type_modifier=b'n', type='^C')}), ( b"passInOutShort:", { 2: dict(type_modifier=b'N')}), ( b"passOutShort:", { 2: dict(type_modifier=b'o')}), ( b"passInShort:", { 2: dict(type_modifier=b'n')}), ( b"passInOutUShort:", { 2: dict(type_modifier=b'N')}), ( b"passOutUShort:", { 2: dict(type_modifier=b'o')}), ( b"passInUShort:", { 2: dict(type_modifier=b'n')}), ( b"passInOutInt:", { 2: dict(type_modifier=b'N')}), ( b"passOutInt:", { 2: dict(type_modifier=b'o')}), ( b"passInInt:", { 2: dict(type_modifier=b'n')}), ( b"passInOutUInt:", { 2: dict(type_modifier=b'N')}), ( b"passOutUInt:", { 2: dict(type_modifier=b'o')}), ( b"passInUInt:", { 2: dict(type_modifier=b'n')}), ( b"passInOutLong:", { 2: dict(type_modifier=b'N')}), ( b"passOutLong:", { 2: dict(type_modifier=b'o')}), ( b"passInLong:", { 2: dict(type_modifier=b'n')}), ( b"passInOutULong:", { 2: dict(type_modifier=b'N')}), ( b"passOutULong:", { 2: dict(type_modifier=b'o')}), ( b"passInULong:", { 2: dict(type_modifier=b'n')}), ( b"passInOutLongLong:", { 2: dict(type_modifier=b'N')}), ( b"passOutLongLong:", { 2: dict(type_modifier=b'o')}), ( b"passInLongLong:", { 2: dict(type_modifier=b'n')}), ( b"passInOutULongLong:", { 2: dict(type_modifier=b'N')}), ( b"passOutULongLong:", { 2: dict(type_modifier=b'o')}), ( b"passInULongLong:", { 2: dict(type_modifier=b'n')}), ( b"passInOutFloat:", { 2: dict(type_modifier=b'N')}), ( b"passOutFloat:", { 2: dict(type_modifier=b'o')}), ( b"passInFloat:", { 2: dict(type_modifier=b'n')}), ( b"passInOutDouble:", { 2: dict(type_modifier=b'N')}), ( b"passOutDouble:", { 2: dict(type_modifier=b'o')}), ( b"passInDouble:", { 2: dict(type_modifier=b'n')}), ( b"passInOutCharp:", { 2: dict(type_modifier=b'N')}), ( b"passOutCharp:", { 2: dict(type_modifier=b'o')}), ( b"passInCharp:", { 2: dict(type_modifier=b'n')}), ( b"passInOutID:", { 2: dict(type_modifier=b'N')}), ( b"passOutID:", { 2: dict(type_modifier=b'o')}), ( b"passInID:", { 2: dict(type_modifier=b'n')}), ]: objc.registerMetaDataForSelector(b"OC_TestClass1", method, dict(arguments=argmeta)) from PyObjCTest.testbndl import * def makeCFloat(value): """ C floats and doubles have a different representation, this function returns the result of converting a python float (== C double) to a C float and back. """ return struct.unpack('f',struct.pack('f', value))[0] class PyOCTestSimpleReturns(TestCase): # # Test returns of simple types from instance and classs methods # def testClsLongLong(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.longlongClsFunc(), -(1L << 60)) self.assertEquals(OC_TestClass1.longlongClsFunc(), -42) self.assertEquals(OC_TestClass1.longlongClsFunc(), 0) self.assertEquals(OC_TestClass1.longlongClsFunc(), 42) self.assertEquals(OC_TestClass1.longlongClsFunc(), (1L << 60)) def testClsULongLong(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.ulonglongClsFunc(), 0) self.assertEquals(OC_TestClass1.ulonglongClsFunc(), 42) self.assertEquals(OC_TestClass1.ulonglongClsFunc(), (1L << 63)) def testClsLong(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.longClsFunc(), -(1 << 30)) self.assertEquals(OC_TestClass1.longClsFunc(), -42) self.assertEquals(OC_TestClass1.longClsFunc(), 0) self.assertEquals(OC_TestClass1.longClsFunc(), 42) self.assertEquals(OC_TestClass1.longClsFunc(), (1 << 30)) def testClsULong(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.ulongClsFunc(), 0) self.assertEquals(OC_TestClass1.ulongClsFunc(), 42) self.assertEquals(OC_TestClass1.ulongClsFunc(), (1 << 30)) def testClsInt(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.intClsFunc(), -(1 << 30)) self.assertEquals(OC_TestClass1.intClsFunc(), -42) self.assertEquals(OC_TestClass1.intClsFunc(), 0) self.assertEquals(OC_TestClass1.intClsFunc(), 42) self.assertEquals(OC_TestClass1.intClsFunc(), (1 << 30)) def testClsUInt(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.uintClsFunc(), 0) self.assertEquals(OC_TestClass1.uintClsFunc(), 42) self.assertEquals(OC_TestClass1.uintClsFunc(), (1 << 30)) def testClsShort(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.shortClsFunc(), -(1 << 14)) self.assertEquals(OC_TestClass1.shortClsFunc(), -42) self.assertEquals(OC_TestClass1.shortClsFunc(), 0) self.assertEquals(OC_TestClass1.shortClsFunc(), 42) self.assertEquals(OC_TestClass1.shortClsFunc(), (1 << 14)) def testClsUShort(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.ushortClsFunc(), 0) self.assertEquals(OC_TestClass1.ushortClsFunc(), 42) self.assertEquals(OC_TestClass1.ushortClsFunc(), (1 << 14)) def testClsChar(self): # Fails with libffi due to the way we treat 'char' at the moment OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.charClsFunc(), -128) self.assertEquals(OC_TestClass1.charClsFunc(), 0) self.assertEquals(OC_TestClass1.charClsFunc(), 127) def testClsUChar(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.ucharClsFunc(), 0) self.assertEquals(OC_TestClass1.ucharClsFunc(), 128) self.assertEquals(OC_TestClass1.ucharClsFunc(), 255) def testClsFloat(self): # Fails, possibly rounding error OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.floatClsFunc(), makeCFloat(0.128)) self.assertEquals(OC_TestClass1.floatClsFunc(), makeCFloat(1.0)) self.assertEquals(OC_TestClass1.floatClsFunc(), makeCFloat(42.0)) self.assertEquals(OC_TestClass1.floatClsFunc(), makeCFloat(1e10)) def testClsDouble(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.doubleClsFunc(), 0.128) self.assertEquals(OC_TestClass1.doubleClsFunc(), 1.0) self.assertEquals(OC_TestClass1.doubleClsFunc(), 42.0) self.assertEquals(OC_TestClass1.doubleClsFunc(), 1e10) def testClsCharp(self): OC_TestClass1.clsReset() self.assertEquals(OC_TestClass1.charpClsFunc(), b'hello') self.assertEquals(OC_TestClass1.charpClsFunc(), b'world') self.assertEquals(OC_TestClass1.charpClsFunc(), b'foobar') def testClsID(self): OC_TestClass1.clsReset() self.assertEquals(len(OC_TestClass1.idClsFunc()), 0) self.assertEquals(type(OC_TestClass1.idClsFunc()).__name__, 'NSHost') self.assertIn(str(OC_TestClass1.idClsFunc()), ('{}', '{\n}')) self.assertEquals(OC_TestClass1.idClsFunc(), None) # testCls* ends here def testLongLong(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.longlongFunc(), -(1L << 60)) self.assertEquals(obj.longlongFunc(), -42) self.assertEquals(obj.longlongFunc(), 0) self.assertEquals(obj.longlongFunc(), 42) self.assertEquals(obj.longlongFunc(), (1L << 60)) def testULongLong(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.ulonglongFunc(), 0) self.assertEquals(obj.ulonglongFunc(), 42) self.assertEquals(obj.ulonglongFunc(), (1L << 63)) def testLong(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.longFunc(), -(1 << 30)) self.assertEquals(obj.longFunc(), -42) self.assertEquals(obj.longFunc(), 0) self.assertEquals(obj.longFunc(), 42) self.assertEquals(obj.longFunc(), (1 << 30)) def testULong(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.ulongFunc(), 0) self.assertEquals(obj.ulongFunc(), 42) self.assertEquals(obj.ulongFunc(), (1 << 30)) def testInt(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.intFunc(), -(1 << 30)) self.assertEquals(obj.intFunc(), -42) self.assertEquals(obj.intFunc(), 0) self.assertEquals(obj.intFunc(), 42) self.assertEquals(obj.intFunc(), (1 << 30)) def testUInt(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.uintFunc(), 0) self.assertEquals(obj.uintFunc(), 42) self.assertEquals(obj.uintFunc(), (1 << 30)) def testShort(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.shortFunc(), -(1 << 14)) self.assertEquals(obj.shortFunc(), -42) self.assertEquals(obj.shortFunc(), 0) self.assertEquals(obj.shortFunc(), 42) self.assertEquals(obj.shortFunc(), (1 << 14)) def testUShort(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.ushortFunc(), 0) self.assertEquals(obj.ushortFunc(), 42) self.assertEquals(obj.ushortFunc(), (1 << 14)) def testChar(self): obj = OC_TestClass1.new() # Fails with libffi due to the way we treat 'char' at the moment obj.reset() self.assertEquals(obj.charFunc(), -128) self.assertEquals(obj.charFunc(), 0) self.assertEquals(obj.charFunc(), 127) def testUChar(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.ucharFunc(), 0) self.assertEquals(obj.ucharFunc(), 128) self.assertEquals(obj.ucharFunc(), 255) def testFloat(self): # Fails, possibly rounding error obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.floatFunc(), makeCFloat(0.128)) self.assertEquals(obj.floatFunc(), makeCFloat(1.0)) self.assertEquals(obj.floatFunc(), makeCFloat(42.0)) self.assertEquals(obj.floatFunc(), makeCFloat(1e10)) def testDouble(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.doubleFunc(), 0.128) self.assertEquals(obj.doubleFunc(), 1.0) self.assertEquals(obj.doubleFunc(), 42.0) self.assertEquals(obj.doubleFunc(), 1e10) def testCharp(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(obj.charpFunc(), b'hello') self.assertEquals(obj.charpFunc(), b'world') self.assertEquals(obj.charpFunc(), b'foobar') def testID(self): obj = OC_TestClass1.new() obj.reset() self.assertEquals(len(obj.idFunc()), 0) self.assertEquals(type(obj.idFunc()).__name__, 'NSHost') self.assertIn(str(obj.idFunc()), ('{}', '{\n}')) self.assertEquals(obj.idFunc(), None) def testStruct1(self): obj = OC_TestClass1.new() self.assertEquals(obj.dummyFunc(), (-1, 1)) def testStruct2(self): obj = OC_TestClass1.new() self.assertEquals(obj.dummy2Func(), ((1,2,3,4),)) class PyOCTestSimpleArguments(TestCase): # # Test argument passing of single basic values. # def setUp(self): self.obj = OC_TestClass1.new() def testLongLong(self): self.assertEquals(self.obj.longlongArg_(0), 0) self.assertEquals(self.obj.longlongArg_(10), 5) self.assertEquals(self.obj.longlongArg_(10L), 5) self.assertEquals(self.obj.longlongArg_(1L << 60), (1L << 59)) self.assertEquals(self.obj.longlongArg_(-10), -5) self.assertEquals(self.obj.longlongArg_(-10L), -5) self.assertEquals(self.obj.longlongArg_(-1L << 60), -(1L << 59)) # TODO: Out of range values def testULongLong(self): self.assertEquals(self.obj.ulonglongArg_(0), 0) self.assertEquals(self.obj.ulonglongArg_(10), 5) self.assertEquals(self.obj.ulonglongArg_(10L), 5) self.assertEquals(self.obj.ulonglongArg_(1L << 60), (1L << 59)) # TODO: Out of range values def testLong(self): self.assertEquals(self.obj.longArg_(0), 0) self.assertEquals(self.obj.longArg_(10), 5) self.assertEquals(self.obj.longArg_(10L), 5) self.assertEquals(self.obj.longArg_(1 << 30), (1 << 29)) self.assertEquals(self.obj.longArg_(-10), -5) self.assertEquals(self.obj.longArg_(-10L), -5) self.assertEquals(self.obj.longArg_(-1 << 30), -(1 << 29)) # TODO: Out of range values def testULong(self): self.assertEquals(self.obj.ulongArg_(0), 0) self.assertEquals(self.obj.ulongArg_(10), 5) self.assertEquals(self.obj.ulongArg_(10L), 5) self.assertEquals(self.obj.ulongArg_(1 << 30), (1 << 29)) # TODO: Out of range values def testInt(self): self.assertEquals(self.obj.intArg_(0), 0) self.assertEquals(self.obj.intArg_(10), 5) self.assertEquals(self.obj.intArg_(10L), 5) self.assertEquals(self.obj.intArg_(1 << 30), (1 << 29)) self.assertEquals(self.obj.intArg_(-10), -5) self.assertEquals(self.obj.intArg_(-10L), -5) self.assertEquals(self.obj.intArg_(-1 << 30), -(1 << 29)) self.assertEquals(self.obj.intArg_(10.0), 5) self.assertRaises(ValueError, self.obj.intArg_, long(sys.maxint)+1) self.assertRaises(ValueError, self.obj.intArg_, -long(sys.maxint)-2) self.assertRaises(ValueError, self.obj.intArg_, -float(sys.maxint)-2) def testUInt(self): self.assertEquals(self.obj.uintArg_(0), 0) self.assertEquals(self.obj.uintArg_(10), 5) self.assertEquals(self.obj.uintArg_(10L), 5) self.assertEquals(self.obj.uintArg_(1 << 30), (1 << 29)) self.assertEquals(self.obj.uintArg_(10.0), 5) self.assertRaises(ValueError, self.obj.uintArg_, -5) self.assertRaises(ValueError, self.obj.uintArg_, -5L) self.assertRaises(ValueError, self.obj.uintArg_, 1+2*(long(sys.maxint)+1)) def testShort(self): self.assertEquals(self.obj.shortArg_(0), 0) self.assertEquals(self.obj.shortArg_(10), 5) self.assertEquals(self.obj.shortArg_(10L), 5) self.assertEquals(self.obj.shortArg_(1 << 14), (1 << 13)) self.assertEquals(self.obj.shortArg_(-10), -5) self.assertEquals(self.obj.shortArg_(-10L), -5) self.assertEquals(self.obj.shortArg_(-(1 << 14)), -(1 << 13)) self.assertEquals(self.obj.shortArg_(10.0), 5) # Out of range arguments, assumes a short is 16 bits self.assertRaises(ValueError, self.obj.shortArg_, -(1<<16)-1) self.assertRaises(ValueError, self.obj.shortArg_, 1<<16) self.assertRaises(ValueError, self.obj.shortArg_, -(1L<<16)-1) self.assertRaises(ValueError, self.obj.shortArg_, 1L<<16) def testUShort(self): self.assertEquals(self.obj.ushortArg_(0), 0) self.assertEquals(self.obj.ushortArg_(10), 5) self.assertEquals(self.obj.ushortArg_(10L), 5) self.assertEquals(self.obj.ushortArg_(1 << 14), (1 << 13)) self.assertEquals(self.obj.ushortArg_(10.0), 5) # Out of range arguments, assumes a short is 16 bits self.assertRaises(ValueError, self.obj.ushortArg_, -5) self.assertRaises(ValueError, self.obj.ushortArg_, -(1<<16)-1) self.assertRaises(ValueError, self.obj.ushortArg_, 1<<16) self.assertRaises(ValueError, self.obj.ushortArg_, -5L) self.assertRaises(ValueError, self.obj.ushortArg_, -(1L<<16)-1) self.assertRaises(ValueError, self.obj.ushortArg_, 1L<<16) def testChar(self): self.assertEquals(self.obj.charArg_(0), (0)) self.assertEquals(self.obj.charArg_(10), (5)) self.assertEquals(self.obj.charArg_(10L), (5)) self.assertEquals(self.obj.charArg_(1 << 6), (1 << 5)) self.assertEquals(self.obj.charArg_(b'\x00'), 0x00) self.assertEquals(self.obj.charArg_(b'\x10'), int(ord(b'\x10')/2)) # TODO: Out of range arguments def testUChar(self): self.assertEquals(self.obj.ucharArg_(0), 0) self.assertEquals(self.obj.ucharArg_(10), 5) self.assertEquals(self.obj.ucharArg_(10L), 5) self.assertEquals(self.obj.ucharArg_(1 << 7), (1 << 6)) self.assertEquals(self.obj.ucharArg_(b'\x00'), 0) self.assertEquals(self.obj.ucharArg_(b'\x10'), int(ord(b'\x10')/2)) self.assertEquals(self.obj.ucharArg_(10.0), 5) # Out of range arguments self.assertRaises(ValueError, self.obj.ucharArg_, -5) self.assertRaises(ValueError, self.obj.ucharArg_, -256) self.assertRaises(ValueError, self.obj.ucharArg_, 256) self.assertRaises(ValueError, self.obj.ucharArg_, -5L) self.assertRaises(ValueError, self.obj.ucharArg_, -256L) self.assertRaises(ValueError, self.obj.ucharArg_, 256L) def testCharp(self): self.assertEquals(self.obj.charpArg_(b"hello world"), b'dlrow olleh') self.assertRaises(ValueError, self.obj.charpArg_, 256L) self.assertRaises(ValueError, self.obj.charpArg_, u"hello world") def testIDPython(self): # Test a Python object as the argument s = self.obj.idArg_(u"hello") self.assertEquals(len(s), 1) self.assertEquals(s[0], u"hello") def testIDOC(self): # Test an Objective-C object as the argument # NSHost gives problems on GNUstep, better check those problems # seperately in the Foundation test suite. #c = objc.lookUpClass("NSHost") #o = c.hostWithAddress_('127.0.0.1') c = objc.lookUpClass("NSScanner") o = c.scannerWithString_(u"hello world") s = self.obj.idArg_(o) self.assertEquals(len(s), 1) self.assertIs(s[0], o) def testStruct1(self): self.assertEquals(self.obj.dummyArg_((-1, 1)), (-2, 2)) self.assertRaises(TypeError, self.obj.dummyArg_, 256L) self.assertRaises(ValueError, self.obj.dummyArg_, (-1,)) self.assertRaises(ValueError, self.obj.dummyArg_, (-1,1,2)) def testStruct2(self): self.assertEquals(self.obj.dummy2Arg_(((1,2,3,4),)), ((8,6,4,2),)) self.assertRaises(ValueError, self.obj.dummy2Arg_, ((8,6,4,2),1)) self.assertRaises(ValueError, self.obj.dummy2Arg_, ((8,6,4,),)) self.assertRaises(ValueError, self.obj.dummy2Arg_, ((8,6,4,2,1),)) class PyOCTestByReferenceArguments(TestCase): # # Test argument passing of single basic values by reference. # def setUp(self): self.obj = OC_TestClass1.new() def testCharIn(self): self.assertEquals(self.obj.passInChar_(b'\x10'), 0x19) def testCharOut(self): self.obj.reset() self.assertEquals(self.obj.passOutChar_(None), -128) self.assertEquals(self.obj.passOutChar_(None), 0) self.assertEquals(self.obj.passOutChar_(None), 127) def testCharInOut(self): self.assertEquals(self.obj.passInOutChar_(b'\x10'), 0x3a) def testUCharIn(self): self.assertEquals(self.obj.passInUChar_(10), 19) def testUCharOut(self): self.obj.reset() self.assertEquals(self.obj.passOutUChar_(None), 0) self.assertEquals(self.obj.passOutUChar_(None), 128) self.assertEquals(self.obj.passOutUChar_(None), 255) def testUCharInOut(self): self.assertEquals(self.obj.passInOutUChar_(10), 52) def testShortIn(self): self.assertEquals(self.obj.passInShort_(10), 19) self.assertEquals(self.obj.passInShort_(-100), -91) self.assertEquals(self.obj.passInShort_(-100.0), -91) def testShortOut(self): self.obj.reset() self.assertEquals(self.obj.passOutShort_(None), -(1 << 14)) self.assertEquals(self.obj.passOutShort_(None), -42) self.assertEquals(self.obj.passOutShort_(None), 0) self.assertEquals(self.obj.passOutShort_(None), 42) self.assertEquals(self.obj.passOutShort_(None), 1 << 14) def testShortInOut(self): self.assertEquals(self.obj.passInOutShort_(10), 52) self.assertEquals(self.obj.passInOutShort_(-100), -58) self.assertEquals(self.obj.passInOutShort_(-100.0), -58) def testUShortIn(self): self.assertEquals(self.obj.passInUShort_(10), 19) def testUShortOut(self): self.obj.reset() self.assertEquals(self.obj.passOutUShort_(None), 0) self.assertEquals(self.obj.passOutUShort_(None), 42) self.assertEquals(self.obj.passOutUShort_(None), (1 << 14)) def testUShortInOut(self): self.assertEquals(self.obj.passInOutUShort_(10), 52) def testIntIn(self): self.assertEquals(self.obj.passInInt_(10), 19) self.assertEquals(self.obj.passInInt_(-100), -91) def testIntOut(self): self.obj.reset() self.assertEquals(self.obj.passOutInt_(None), -(1 << 30)) self.assertEquals(self.obj.passOutInt_(None), -42) self.assertEquals(self.obj.passOutInt_(None), 0) self.assertEquals(self.obj.passOutInt_(None), 42) self.assertEquals(self.obj.passOutInt_(None), (1 << 30)) def testIntInOut(self): self.assertEquals(self.obj.passInOutInt_(10), 52) self.assertEquals(self.obj.passInOutInt_(-100), -58) self.assertEquals(self.obj.passInOutInt_(-100.0), -58) def testUIntIn(self): self.assertEquals(self.obj.passInUInt_(10), 19) def testUIntOut(self): self.obj.reset() self.assertEquals(self.obj.passOutUInt_(None), 0) self.assertEquals(self.obj.passOutUInt_(None), 42) self.assertEquals(self.obj.passOutUInt_(None), (1 << 30)) def testUIntInOut(self): self.assertEquals(self.obj.passInOutUInt_(10), 52) self.assertEquals(self.obj.passInOutUInt_(10.0), 52) def testLongIn(self): self.assertEquals(self.obj.passInLong_(10), 19) self.assertEquals(self.obj.passInLong_(-100), -91) def testLongOut(self): self.obj.reset() self.assertEquals(self.obj.passOutLong_(None), -(1 << 30)) self.assertEquals(self.obj.passOutLong_(None), -42) self.assertEquals(self.obj.passOutLong_(None), 0) self.assertEquals(self.obj.passOutLong_(None), 42) self.assertEquals(self.obj.passOutLong_(None), (1 << 30)) def testLongInOut(self): self.assertEquals(self.obj.passInOutLong_(10), 52) self.assertEquals(self.obj.passInOutLong_(-100), -58) self.assertEquals(self.obj.passInOutLong_(-100.0), -58) def testULongIn(self): self.assertEquals(self.obj.passInULong_(10), 19) def testULongOut(self): self.obj.reset() self.assertEquals(self.obj.passOutULong_(None), 0) self.assertEquals(self.obj.passOutULong_(None), 42) self.assertEquals(self.obj.passOutULong_(None), (1 << 30)) def testULongInOut(self): self.assertEquals(self.obj.passInOutULong_(10), 52) self.assertEquals(self.obj.passInOutULong_(10.0), 52) def testLongLongIn(self): self.assertEquals(self.obj.passInLongLong_(10), 19) self.assertEquals(self.obj.passInLongLong_(-100), -91) def testLongLongOut(self): self.obj.reset() self.assertEquals(self.obj.passOutLongLong_(None), -(1L << 60)) self.assertEquals(self.obj.passOutLongLong_(None), -42) self.assertEquals(self.obj.passOutLongLong_(None), 0) self.assertEquals(self.obj.passOutLongLong_(None), 42) self.assertEquals(self.obj.passOutLongLong_(None), (1L << 60)) def testLongLongInOut(self): self.assertEquals(self.obj.passInOutLongLong_(10), 52) self.assertEquals(self.obj.passInOutLongLong_(-100), -58) self.assertEquals(self.obj.passInOutLongLong_(-100.0), -58) def testULongLongIn(self): self.assertEquals(self.obj.passInULongLong_(10), 19) def testULongLongOut(self): self.obj.reset() self.assertEquals(self.obj.passOutULongLong_(None), 0) self.assertEquals(self.obj.passOutULongLong_(None), 42) self.assertEquals(self.obj.passOutULongLong_(None), (1L << 63)) def testULongLongInOut(self): self.assertEquals(self.obj.passInOutULongLong_(10), 52) self.assertEquals(self.obj.passInOutULongLong_(10.0), 52) def testFloatIn(self): self.assertEquals(self.obj.passInFloat_(10), makeCFloat(90.0)) self.assertEquals(self.obj.passInFloat_(0.11), makeCFloat(0.99)) def testFloatOut(self): self.obj.reset() self.assertEquals(self.obj.passOutFloat_(None), makeCFloat(0.128)) self.assertEquals(self.obj.passOutFloat_(None), makeCFloat(1.0)) self.assertEquals(self.obj.passOutFloat_(None), makeCFloat(42.0)) self.assertEquals(self.obj.passOutFloat_(None), makeCFloat(1e10)) def testFloatInOut(self): self.assertEquals(self.obj.passInOutFloat_(10), makeCFloat(420)) self.assertEquals(self.obj.passInOutFloat_(10.0), makeCFloat(420)) self.assertEquals(self.obj.passInOutFloat_(0.01), makeCFloat(0.42)) def testDoubleIn(self): self.assertEquals(self.obj.passInDouble_(10), 90.0) self.assertEquals(self.obj.passInDouble_(0.11), 0.99) def testDoubleOut(self): self.obj.reset() self.assertEquals(self.obj.passOutDouble_(None), 0.128) self.assertEquals(self.obj.passOutDouble_(None), 1.0) self.assertEquals(self.obj.passOutDouble_(None), 42.0) self.assertEquals(self.obj.passOutDouble_(None), 1e10) def testDoubleInOut(self): self.assertEquals(self.obj.passInOutDouble_(10), 420) self.assertEquals(self.obj.passInOutDouble_(10.0), 420) self.assertEquals(self.obj.passInOutDouble_(0.01), 0.42) def testCharpIn(self): self.assertEquals(self.obj.passInCharp_(b"hello"), b"hheelllloo") self.assertEquals(self.obj.passInCharp_(b"abcde"), b"aabbccddee") def testCharpOut(self): self.obj.reset() self.assertEquals(self.obj.passOutCharp_(None), b"hello") self.assertEquals(self.obj.passOutCharp_(None), b"world") self.assertEquals(self.obj.passOutCharp_(None), b"foobar") def testCharpInOut(self): self.assertEquals(self.obj.passInOutCharp_(b"hello"), b"hheelllloo") self.assertEquals(self.obj.passInOutCharp_(b"abcdef"), b"aabbccddeeff") # TODO: structs (including Objective-C part) # # Below this point only TestCases that test calling Python from Objective-C # # Notes: # - There is both a pure python and an Python-ObjC hybrid class # (MyPyClass and MyOCClass). The former is not used in the first few tests, # we need to decide what functionality we'll support for these (e.g. do # we support selector objects, or only normal methods?) # - Every test below should exists in two variants: # * 'invoke' - Calls back from ObjC to Python using an NSInvocation # and the forwardInvocation method # * 'call' - Calls back from ObjC to Python using a normal ObjC method call # Values for # - 8-bit char # - 16-bit short # - 32-bit int/long # - 64-bit long long # Values are: max-negative, -42, 0, 42, max-positive, out-of-range, bad-type, None # CHAR_NUMBERS=[ -128, -42, 0, 42, 127, b'a', 128, "hello", None ] UCHAR_NUMBERS=[ 0, 42, 255, b'a', 256, "hello", None ] SHORT_NUMBERS=[ -32768, -42, 0, 32767, 32768, "hello", None ] USHORT_NUMBERS=[ 0, 42, 65535, 65536, "hello", None ] INT_NUMBERS=[ -2147483648, -42, 0, 2147483647, 2147483648, "hello", None ] UINT_NUMBERS=[ 0, 42, 4294967295, 4294967296, "hello", None ] LONG_NUMBERS=[ -2147483648, -42, 0, 2147483647, sys.maxint+1, "hello", None ] ULONG_NUMBERS=[ 0, 42, 4294967295L, 2*(sys.maxint+1), "hello", None ] LONGLONG_NUMBERS=[ -9223372036854775808L, -42, 0, 42, 9223372036854775807L, 9223372036854775808L, "hello", None ] ULONGLONG_NUMBERS=[0, 42, 18446744073709551615L, 18446744073709551616L, "hello", None ] FLOAT_NUMBERS = [ makeCFloat(0.1), makeCFloat(100.0) ] DOUBLE_NUMBERS = [ 1.5, 3.5, 1e10, 1.99e10 ] OBJECTS = [ u"hello", 1.0, range(4), lambda x: 10 ] DUMMY_OBJECTS = [ (1, 1), (-10, -10), (-4, -5), (0, 0), (10, 20) ] DUMMY2_OBJECTS = [ ((1, 2, 3, 4),), ((-9, -8, -7, -6),)] POINTS=[ (1.0, 2.0), (1e10, 2e10), (-0.5, 0.5) ] class MyPyClass: def __init__(self): self.idx = 0 def reset(self): self.idx = 0 def idFunc(self): i = self.idx self.idx += 1 return OBJECTS[i] class MyOCClass (objc.lookUpClass('NSObject')): def __init__(self): self.idx = 0 def reset(self): self.idx = 0 def charFunc(self): i = self.idx self.idx += 1 return CHAR_NUMBERS[i] charFunc = objc.selector(charFunc, signature=OC_TestClass1.charFunc.signature) def ucharFunc(self): i = self.idx self.idx += 1 return UCHAR_NUMBERS[i] ucharFunc = objc.selector(ucharFunc, signature=OC_TestClass1.ucharFunc.signature) def shortFunc(self): i = self.idx self.idx += 1 return SHORT_NUMBERS[i] shortFunc = objc.selector(shortFunc, signature=OC_TestClass1.shortFunc.signature) def ushortFunc(self): i = self.idx self.idx += 1 return USHORT_NUMBERS[i] ushortFunc = objc.selector(ushortFunc, signature=OC_TestClass1.ushortFunc.signature) def intFunc(self): i = self.idx self.idx += 1 return INT_NUMBERS[i] intFunc = objc.selector(intFunc, signature=OC_TestClass1.intFunc.signature) def uintFunc(self): i = self.idx self.idx += 1 return UINT_NUMBERS[i] uintFunc = objc.selector(uintFunc, signature=OC_TestClass1.uintFunc.signature) def longFunc(self): i = self.idx self.idx += 1 return LONG_NUMBERS[i] longFunc = objc.selector(longFunc, signature=OC_TestClass1.longFunc.signature) def ulongFunc(self): i = self.idx self.idx += 1 return ULONG_NUMBERS[i] ulongFunc = objc.selector(ulongFunc, signature=OC_TestClass1.ulongFunc.signature) def longlongFunc(self): i = self.idx self.idx += 1 return LONGLONG_NUMBERS[i] longlongFunc = objc.selector(longlongFunc, signature=OC_TestClass1.longlongFunc.signature) def ulonglongFunc(self): i = self.idx self.idx += 1 return ULONGLONG_NUMBERS[i] ulonglongFunc = objc.selector(ulonglongFunc, signature=OC_TestClass1.ulonglongFunc.signature) def floatFunc(self): i = self.idx self.idx += 1 return FLOAT_NUMBERS[i] floatFunc = objc.selector(floatFunc, signature=OC_TestClass1.floatFunc.signature) def doubleFunc(self): i = self.idx self.idx += 1 return DOUBLE_NUMBERS[i] doubleFunc = objc.selector(doubleFunc, signature=OC_TestClass1.doubleFunc.signature) def idFunc(self): i = self.idx self.idx += 1 return OBJECTS[i] def dummyFunc(self): i = self.idx self.idx += 1 return DUMMY_OBJECTS[i] dummyFunc = objc.selector(dummyFunc, signature=OC_TestClass1.dummyFunc.signature) def dummy2Func(self): i = self.idx self.idx += 1 return DUMMY2_OBJECTS[i] dummy2Func = objc.selector(dummy2Func, signature=OC_TestClass1.dummy2Func.signature) def nspointFunc(self): i = self.idx self.idx += 1 return POINTS[i] nspointFunc = objc.selector(nspointFunc, signature=OC_TestClass1.nspointFunc.signature) def charArg_(self, arg): return arg * 2 charArg_ = objc.selector(charArg_, signature=OC_TestClass1.charArg_.signature) def ucharArg_(self, arg): return arg * 2 ucharArg_ = objc.selector(ucharArg_, signature=OC_TestClass1.ucharArg_.signature) def shortArg_(self, arg): return arg * 2 shortArg_ = objc.selector(shortArg_, signature=OC_TestClass1.shortArg_.signature) def ushortArg_(self, arg): return arg * 2 ushortArg_ = objc.selector(ushortArg_, signature=OC_TestClass1.ushortArg_.signature) def intArg_(self, arg): return arg * 2 intArg_ = objc.selector(intArg_, signature=OC_TestClass1.intArg_.signature) def uintArg_(self, arg): return arg * 2 uintArg_ = objc.selector(uintArg_, signature=OC_TestClass1.uintArg_.signature) def longArg_(self, arg): return arg * 2 longArg_ = objc.selector(longArg_, signature=OC_TestClass1.longArg_.signature) def ulongArg_(self, arg): return arg * 2 ulongArg_ = objc.selector(ulongArg_, signature=OC_TestClass1.ulongArg_.signature) def longlongArg_(self, arg): return arg * 2 longlongArg_ = objc.selector(longlongArg_, signature=OC_TestClass1.longlongArg_.signature) def ulonglongArg_(self, arg): return arg * 2 ulonglongArg_ = objc.selector(ulonglongArg_, signature=OC_TestClass1.ulonglongArg_.signature) def floatArg_(self, arg): return arg * 2 floatArg_ = objc.selector(floatArg_, signature=OC_TestClass1.floatArg_.signature) def doubleArg_(self, arg): return arg * 2 doubleArg_ = objc.selector(doubleArg_, signature=OC_TestClass1.doubleArg_.signature) class OCPyTestSimpleCalls(TestCase): # # Test argument passing of single basic values by reference. # def setUp(self): self.pyobj = MyPyClass() self.ocobj = MyOCClass.new() self.obj = OC_TestClass2.new() def testCChar(self): self.pyobj.reset() self.ocobj.reset() for o in CHAR_NUMBERS[:-3]: if isinstance(o, (bytes, str)): o = ord(o) self.assertEquals(self.obj.callInstanceCharFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.callInstanceCharFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceCharFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceCharFuncOf_, self.ocobj) def testIChar(self): self.pyobj.reset() self.ocobj.reset() for o in CHAR_NUMBERS[:-3]: if isinstance(o, (str, bytes)): o = ord(o) self.assertEquals(self.obj.invokeInstanceCharFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.invokeInstanceCharFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceCharFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceCharFuncOf_, self.ocobj) def testCUChar(self): self.pyobj.reset() self.ocobj.reset() for o in UCHAR_NUMBERS[:-3]: if isinstance(o, (str, bytes)): o = ord(o) self.assertEquals(self.obj.callInstanceUnsignedCharFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.callInstanceUnsignedCharFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceUnsignedCharFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceUnsignedCharFuncOf_, self.ocobj) def testIUChar(self): self.pyobj.reset() self.ocobj.reset() for o in UCHAR_NUMBERS[:-3]: if isinstance(o, (bytes, str)): o = ord(o) self.assertEquals(self.obj.invokeInstanceUnsignedCharFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedCharFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedCharFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedCharFuncOf_, self.ocobj) def testCShort(self): self.pyobj.reset() self.ocobj.reset() for o in SHORT_NUMBERS[:-3]: self.assertEquals(self.obj.callInstanceShortFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.callInstanceShortFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceShortFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceShortFuncOf_, self.ocobj) def testIShort(self): self.pyobj.reset() self.ocobj.reset() for o in SHORT_NUMBERS[:-3]: self.assertEquals(self.obj.invokeInstanceShortFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.invokeInstanceShortFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceShortFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceShortFuncOf_, self.ocobj) def testCUShort(self): self.pyobj.reset() self.ocobj.reset() for o in USHORT_NUMBERS[:-3]: self.assertEquals(self.obj.callInstanceUnsignedShortFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.callInstanceUnsignedShortFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceUnsignedShortFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceUnsignedShortFuncOf_, self.ocobj) def testIUShort(self): self.pyobj.reset() self.ocobj.reset() for o in USHORT_NUMBERS[:-3]: self.assertEquals(self.obj.invokeInstanceUnsignedShortFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedShortFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedShortFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedShortFuncOf_, self.ocobj) def testCInt(self): self.pyobj.reset() self.ocobj.reset() for o in INT_NUMBERS[:-3]: self.assertEquals(self.obj.callInstanceIntFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.callInstanceIntFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceIntFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceIntFuncOf_, self.ocobj) def testIInt(self): self.pyobj.reset() self.ocobj.reset() for o in INT_NUMBERS[:-3]: self.assertEquals(self.obj.invokeInstanceIntFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.invokeInstanceIntFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceIntFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceIntFuncOf_, self.ocobj) def testCUInt(self): self.pyobj.reset() self.ocobj.reset() for o in UINT_NUMBERS[:-3]: self.assertEquals(self.obj.callInstanceUnsignedIntFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.callInstanceUnsignedIntFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceUnsignedIntFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceUnsignedIntFuncOf_, self.ocobj) def testIUInt(self): self.pyobj.reset() self.ocobj.reset() for o in UINT_NUMBERS[:-3]: self.assertEquals(self.obj.invokeInstanceUnsignedIntFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedIntFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedIntFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedIntFuncOf_, self.ocobj) def testCLong(self): self.pyobj.reset() self.ocobj.reset() for o in LONG_NUMBERS[:-3]: self.assertEquals(self.obj.callInstanceLongFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.callInstanceLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceLongFuncOf_, self.ocobj) def testILong(self): self.pyobj.reset() self.ocobj.reset() for o in LONG_NUMBERS[:-3]: self.assertEquals(self.obj.invokeInstanceLongFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.invokeInstanceLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceLongFuncOf_, self.ocobj) def testCULong(self): self.pyobj.reset() self.ocobj.reset() for o in ULONG_NUMBERS[:-3]: self.assertEquals(self.obj.callInstanceUnsignedLongFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.callInstanceUnsignedLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceUnsignedLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceUnsignedLongFuncOf_, self.ocobj) def testIULong(self): self.pyobj.reset() self.ocobj.reset() for o in ULONG_NUMBERS[:-3]: self.assertEquals(self.obj.invokeInstanceUnsignedLongFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedLongFuncOf_, self.ocobj) def testCLongLong(self): self.pyobj.reset() self.ocobj.reset() for o in LONGLONG_NUMBERS[:-3]: self.assertEquals(self.obj.callInstanceLongLongFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.callInstanceLongLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceLongLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceLongLongFuncOf_, self.ocobj) def testILongLong(self): self.pyobj.reset() self.ocobj.reset() for o in LONGLONG_NUMBERS[:-3]: self.assertEquals(self.obj.invokeInstanceLongLongFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.invokeInstanceLongLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceLongLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceLongLongFuncOf_, self.ocobj) def testCULongLong(self): self.pyobj.reset() self.ocobj.reset() for o in ULONGLONG_NUMBERS[:-3]: self.assertEquals(self.obj.callInstanceUnsignedLongLongFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.callInstanceUnsignedLongLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceUnsignedLongLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.callInstanceUnsignedLongLongFuncOf_, self.ocobj) def testIULongLong(self): self.pyobj.reset() self.ocobj.reset() for o in ULONGLONG_NUMBERS[:-3]: self.assertEquals(self.obj.invokeInstanceUnsignedLongLongFuncOf_(self.ocobj), o) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedLongLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedLongLongFuncOf_, self.ocobj) self.assertRaises(ValueError, self.obj.invokeInstanceUnsignedLongLongFuncOf_, self.ocobj) def testCFloat(self): self.pyobj.reset() self.ocobj.reset() for o in FLOAT_NUMBERS: self.assertEquals(self.obj.callInstanceFloatFuncOf_(self.ocobj), o) def testIFloat(self): self.pyobj.reset() self.ocobj.reset() for o in FLOAT_NUMBERS: self.assertEquals(self.obj.invokeInstanceFloatFuncOf_(self.ocobj), o) def testCDouble(self): self.pyobj.reset() self.ocobj.reset() for o in DOUBLE_NUMBERS: self.assertEquals(self.obj.callInstanceDoubleFuncOf_(self.ocobj), o) def testIDouble(self): self.pyobj.reset() self.ocobj.reset() for o in DOUBLE_NUMBERS: self.assertEquals(self.obj.invokeInstanceDoubleFuncOf_(self.ocobj), o) def testCId(self): self.pyobj.reset() self.ocobj.reset() for o in OBJECTS: self.assertEquals(self.obj.callInstanceIdFuncOf_(self.ocobj), o) def testIId(self): self.pyobj.reset() self.ocobj.reset() for o in OBJECTS: self.assertEquals(self.obj.invokeInstanceIdFuncOf_(self.ocobj), o) def testCId2(self): self.pyobj.reset() self.ocobj.reset() for o in OBJECTS: self.assertEquals(self.obj.callInstanceIdFuncOf_(self.pyobj), o) def testIId2(self): self.pyobj.reset() self.ocobj.reset() for o in OBJECTS: self.assertEquals(self.obj.invokeInstanceIdFuncOf_(self.pyobj), o) def testCStruct1(self): self.pyobj.reset() self.ocobj.reset() for o in DUMMY_OBJECTS: self.assertEquals(self.obj.callInstanceDummyFuncOf_(self.ocobj), o) def testIStruct1(self): self.pyobj.reset() self.ocobj.reset() for o in DUMMY_OBJECTS: self.assertEquals(self.obj.invokeInstanceDummyFuncOf_(self.ocobj), o) def testCStruct2(self): self.pyobj.reset() self.ocobj.reset() for o in DUMMY2_OBJECTS: self.assertEquals(self.obj.callInstanceDummy2FuncOf_(self.ocobj), o) def testIStruct2(self): self.pyobj.reset() self.ocobj.reset() for o in DUMMY2_OBJECTS: self.assertEquals(self.obj.invokeInstanceDummy2FuncOf_(self.ocobj), o) def testCNSPoint(self): self.pyobj.reset() self.ocobj.reset() for o in POINTS: self.assertEquals(self.obj.callInstanceNSPointFuncOf_(self.ocobj), o) def testINSPoint(self): self.pyobj.reset() self.ocobj.reset() for o in POINTS: self.assertEquals(self.obj.invokeInstanceNSPointFuncOf_(self.ocobj), o) class OCPyTestSimpleArguments(TestCase): # # Test argument passing of single basic values. # # TODO: Copy and adapt rest of OCPyTestSimpleArguments # def setUp(self): self.ocobj = MyOCClass.new() self.obj = OC_TestClass2.new() def testCLongLong(self): self.assertEquals(self.obj.callInstanceLongLongArg_on_(0, self.ocobj), 0) self.assertEquals(self.obj.callInstanceLongLongArg_on_(10, self.ocobj), 20) self.assertEquals(self.obj.callInstanceLongLongArg_on_(1L << 60, self.ocobj), 1L << 61) self.assertEquals(self.obj.callInstanceLongLongArg_on_(-10, self.ocobj), -20) self.assertEquals(self.obj.callInstanceLongLongArg_on_(-(1L << 60), self.ocobj), -(1L << 61)) def testILongLong(self): self.assertEquals(self.obj.invokeInstanceLongLongArg_on_(0, self.ocobj), 0) self.assertEquals(self.obj.invokeInstanceLongLongArg_on_(10, self.ocobj), 20) self.assertEquals(self.obj.invokeInstanceLongLongArg_on_(1L << 60, self.ocobj), 1L << 61) self.assertEquals(self.obj.invokeInstanceLongLongArg_on_(-10, self.ocobj), -20) self.assertEquals(self.obj.invokeInstanceLongLongArg_on_(-(1L << 60), self.ocobj), -(1L << 61)) if __name__ == '__main__': main()