def testSimple(self): self.assertEquals(objc.splitSignature("@:@"), ('@',':','@')) self.assertEquals(objc.splitSignature("@:10{NSRect=ff}"), ('@',':','{NSRect=ff}')) self.assertEquals(objc.splitSignature("@:o^@"), ('@',':','o^@')) # struct definition in an struct objc_ivar self.assertEquals(objc.splitSignature('{_NSRect="origin"{_NSPoint="x"f"y"f}"size"{_NSSize="width"f"height"f}}'), ('{_NSRect="origin"{_NSPoint="x"f"y"f}"size"{_NSSize="width"f"height"f}}',))
def test_rectForPage(self): method = ObjCTestNSView_KnowPageRange.rectForPage_ self.assertResultHasType(method, AppKit.NSRect.__typestr__) self.assertEqual( objc.splitSignature(method.signature), objc.splitSignature(AppKit.NSRect.__typestr__ + b"@:" + objc._C_NSInteger), )
def testBlockSignatures(self): obj = OCTestBlock.alloc().init() block = obj.getFloatBlock() sig = objc.splitSignature(objc._block_signature(block)) self.assertEqual(sig, (objc._C_DBL, objc._C_ID + b'?', objc._C_DBL, objc._C_DBL)) block = obj.getStructBlock() sig = objc.splitSignature(objc._block_signature(block)) self.assertEqual(sig, (NSRect_tp, objc._C_ID + b'?', objc._C_DBL, objc._C_DBL, objc._C_DBL, objc._C_DBL))
def testSimple(self): self.assertEquals(objc.splitSignature("@:@"), ('@', ':', '@')) self.assertEquals(objc.splitSignature("@:10{NSRect=ff}"), ('@', ':', '{NSRect=ff}')) self.assertEquals(objc.splitSignature("@:o^@"), ('@', ':', 'o^@')) # struct definition in an struct objc_ivar self.assertEquals( objc.splitSignature( '{_NSRect="origin"{_NSPoint="x"f"y"f}"size"{_NSSize="width"f"height"f}}' ), ('{_NSRect="origin"{_NSPoint="x"f"y"f}"size"{_NSSize="width"f"height"f}}', ))
def testSplitSignature(self): # This is a very expensive test, with 1 goal: Verify that all method # signatures, and therefore all signatures changed by PyObjC, are # valid. for cls in objc.getClassList(): for selName in list(cls.__dict__.keys()): try: sel = getattr(cls, selName.decode("latin1")) except (AttributeError, TypeError): continue if not isinstance(sel, objc.selector): continue # Check is that the call is successfull objc.splitSignature(sel.signature)
def MakeProxyMethod(f): name = f.__name__.replace(':', '_') proxies = [ lambda self: (tracer(name), getattr(self.obj, name)())[1], lambda self, a1: (tracer(name), getattr(self.obj, name)(a1))[1], lambda self, a1, a2: (tracer(name), getattr(self.obj, name)(a1, a2))[1], lambda self, a1, a2, a3: (tracer(name), getattr(self.obj, name)(a1, a2, a3))[1], lambda self, a1, a2, a3, a4: (tracer(name), getattr(self.obj, name)(a1, a2, a3, a4))[1], lambda self, a1, a2, a3, a4, a5: (tracer(name), getattr(self.obj, name)(a1, a2, a3, a4, a5))[1], lambda self, a1, a2, a3, a4, a5, a6: (tracer(name), getattr(self.obj, name)(a1, a2, a3, a4, a5, a6))[1], lambda self, a1, a2, a3, a4, a5, a6, a7: (tracer(name), getattr(self.obj, name)(a1, a2, a3, a4, a5, a6, a7))[1], lambda self, a1, a2, a3, a4, a5, a6, a7, a8: (tracer(name), getattr(self.obj, name)(a1, a2, a3, a4, a5, a6, a7, a8))[1], ] # proxies = map(wraps(f, assigned=['__name__', '__doc__']), proxies) #count = name.count('_', 1) # count = f.__name__.count(':') if isinstance(f, objc.selector): count = len(objc.splitSignature(f.signature)) - 3 else: count = len(inspect.getargspec(f)[0]) # if name.startswith('p_'): # count -= 1 # if count and not name.endswith('_'): # count -= 1 # e.g. p_foo() # print "Proxying", name, "with", count, "arg version" # try: # print "signature", objc.splitSignature(f.signature) # except: # pass return proxies[count]
def testSimple(self): self.assertEqual(objc.splitSignature(b"@:@"), (b"@", b":", b"@")) self.assertEqual(objc.splitSignature(b"@:10{NSRect=ff}"), (b"@", b":", b"{NSRect=ff}")) self.assertEqual(objc.splitSignature(b"@:o^@"), (b"@", b":", b"o^@")) # Block pointer self.assertEqual(objc.splitSignature(b"@:@?"), (b"@", b":", b"@?")) # struct definition in an struct objc_ivar self.assertEqual( objc.splitSignature( b'{_NSRect="origin"{_NSPoint="x"f"y"f}"size"{_NSSize="width"f"height"f}}' ), (b'{_NSRect="origin"{_NSPoint="x"f"y"f}"size"{_NSSize="width"f"height"f}}', ), )
def validate_encoding_string(typestr): result = True try: parts = objc.splitSignature(typestr) except: return False for el in parts: result = result and validate_encoding(el) return result
def testOneWayMethods(self): # This one should be in test_methods*.py from PyObjCTest.initialize import OC_TestInitialize o = OC_TestInitialize.alloc().init() self.assertEqual(objc.splitSignature(o.onewayVoidMethod.signature), (objc._C_ONEWAY + objc._C_VOID, objc._C_ID, objc._C_SEL)) # Make sure we can call the method o.onewayVoidMethod() self.assertEqual(o.isInitialized(), -1)
def filter64(value): result = {} for k in value: if k.endswith('64'): continue result[k] = value[k] # Make sure all irrelavant bits of the signature string get ignored if 'type' in value: result['type'] = ''.join(objc.splitSignature(value['type'])) return result
def testPointer(self): # Check that the TestPointerStructPtr has a signature that is # different from the one in the method definition. The latter contains # more information. retval = objc.splitSignature( OC_TestStructPointer.returnPointerToStruct.signature)[0] self.assertNotEqual(TestStructPointerStructPtr.__typestr__, retval) # And then check that the correct pointer wrapper is created v = OC_TestStructPointer.returnPointerToStruct() self.assertIsInstance(v, TestStructPointerStructPtr)
def testSplitSignature(self): # This is a very expensive test, with 1 goal: Verify that all method # signatures, and therefore all signatures changed by PyObjC, are # valid. for cls in objc.getClassList(): for selName in cls.__dict__.keys(): try: sel = getattr(cls, selName) except AttributeError: continue if not isinstance(sel, objc.selector): continue elems = objc.splitSignature(sel.signature)
def testSplitSignature(self): # This is a very expensive test, with 1 goal: Verify that all method # signatures, and therefore all signatures changed by PyObjC, are # valid. for cls in objc.getClassList(): for selName in list(cls.__dict__.keys()): try: sel = getattr(cls, selName.decode('latin1')) except AttributeError: continue if not isinstance(sel, objc.selector): continue elems = objc.splitSignature(sel.signature)
def dont_testOpenPanelSignature(self): """ This test failed sometime after the 1.0b1 release (on Panther). """ o = AppKit.NSOpenPanel.openPanel() sig = ( o. beginSheetForDirectory_file_types_modalForWindow_modalDelegate_didEndSelector_contextInfo_ .signature # noqa: B950 ) sig = "".join(objc.splitSignature(sig)) self.assertEqual(sig, "v@:@@@@@:i")
def testSignatureCount(self): EXCEPTIONS = [ # For some reason this signature doesn't seem to be correct, even # though we don't touch it... "initWithDocument_URL_windowProperties_locationProperties_interpreterBuiltins_", # Some unittests... "setKey4", "get_key2", "read_bar", "setFoo_", "method_with_embedded_underscores", "methodWithArg_", "myMethod", "twoargs", "set_helper", "callback", # dictionary methods "get", "has_key", ] for cls in objc.getClassList(): if cls.__name__.startswith('OC'): continue for selName in cls.__dict__.keys(): self.assertIsInstance(selName, str) if selName in EXCEPTIONS: continue if selName.startswith('__') and selName.endswith('__'): continue try: sel = getattr(cls, selName) except (AttributeError, TypeError): continue if not isinstance(sel, objc.selector): continue elems = objc.splitSignature(sel.signature) argcount = len(elems) - 3 # retval, self, _sel coloncount = sel.selector.count(b':') self.assertEqual( argcount, coloncount, '%s [%d:%d] %r %r' % (sel.selector.decode('latin1'), argcount, coloncount, elems, cls))
def typestr2typestr(self, typestr): typestr = _as_bytes(typestr) # As of macOS 10.13 metadata files may contain # typestring that end with property specific data; # first remove that junk. if b"," in typestr: typestr = typestr.split(b",", 1)[0] result = [] for item in objc.splitSignature(typestr): if item == objc._C_BOOL: result.append(objc._C_NSBOOL) elif item == objc._C_NSBOOL: result.append(objc._C_BOOL) elif item.startswith(objc._C_STRUCT_B) or item.startswith( objc._C_UNION_B): # unions and structs have the same structure start, stop = item[:1], item[-1:] name, fields = objc.splitStructSignature( objc._C_STRUCT_B + _as_bytes(item[1:-1]) + objc._C_STRUCT_E) result.append(start) if name is not None: result.append(_as_bytes(name)) result.append(b"=") for nm, tp in fields: if nm is not None: result.append(b'"') result.append(_as_bytes(nm)) result.append(b'"') result.append(self.typestr2typestr(tp)) result.append(stop) elif item.startswith(objc._C_ARY_B): m = re.match(br"^.(\d*)(.*).$", item) result.append(objc._C_ARY_B) result.append(m.group(1)) result.append(self.typestr2typestr(m.group(2))) result.append(objc._C_ARY_E) else: result.append(item) return b"".join(result)
def testSignatureCount(self): EXCEPTIONS=[ # For some reason this signature doesn't seem to be correct, even # though we don't touch it... "initWithDocument_URL_windowProperties_locationProperties_interpreterBuiltins_", # Some unittests... "setKey4", "get_key2", "read_bar", "setFoo_", "method_with_embedded_underscores", "methodWithArg_", "myMethod", "twoargs", "set_helper", "callback", # dictionary methods "get", "has_key", ] for cls in objc.getClassList(): #if cls.__name__.startswith('OC_'): continue if cls.__name__.startswith('OC'): continue for selName in cls.__dict__.keys(): self.assertIsInstance(selName, str) if selName in EXCEPTIONS: continue if selName.startswith('__') and selName.endswith('__'): continue try: sel = getattr(cls, selName) except (AttributeError, TypeError): continue if not isinstance(sel, objc.selector): continue elems = objc.splitSignature(sel.signature) argcount = len(elems) - 3 # retval, self, _sel coloncount = sel.selector.count(b':') self.assertEqual(argcount, coloncount, '%s [%d:%d] %r %r'%(sel.selector.decode('latin1'), argcount, coloncount, elems, cls))
def typestr2typestr(self, typestr): typestr = _as_bytes(typestr) result = [] for item in objc.splitSignature(typestr): if item == objc._C_BOOL: result.append(objc._C_NSBOOL) elif item == objc._C_NSBOOL: result.append(objc._C_BOOL) elif item.startswith(objc._C_STRUCT_B) or item.startswith( objc._C_UNION_B): # unions and structs have the same structure start, stop = item[:1], item[-1:] name, fields = objc.splitStructSignature( objc._C_STRUCT_B + _as_bytes(item[1:-1]) + objc._C_STRUCT_E) result.append(start) result.append(_as_bytes(name)) result.append(b'=') for nm, tp in fields: if nm is not None: result.append(b'"') result.append(_as_bytes(nm)) result.append(b'"') result.append(self.typestr2typestr(tp)) result.append(stop) elif item.startswith(objc._C_ARY_B): m = re.match(b'^.(\d*)(.*).$', item) result.append(objc._C_ARY_B) result.append(m.group(1)) result.append(self.typestr2typestr(m.group(2))) result.append(objc._C_ARY_E) else: result.append(item) result = b''.join(result) return result
def typestr2typestr(self, typestr): typestr = _as_bytes(typestr) result = [] for item in objc.splitSignature(typestr): if item == objc._C_BOOL: result.append(objc._C_NSBOOL) elif item == objc._C_NSBOOL: result.append(objc._C_BOOL) elif item.startswith(objc._C_STRUCT_B) or item.startswith(objc._C_UNION_B): # unions and structs have the same structure start, stop = item[:1], item[-1:] name, fields = objc.splitStructSignature(objc._C_STRUCT_B + _as_bytes(item[1:-1]) + objc._C_STRUCT_E) result.append(start) result.append(_as_bytes(name)) result.append(b'=') for nm, tp in fields: if nm is not None: result.append(b'"') result.append(_as_bytes(nm)) result.append(b'"') result.append(self.typestr2typestr(tp)) result.append(stop) elif item.startswith(objc._C_ARY_B): m = re.match(b'^.(\d*)(.*).$', item) result.append(objc._C_ARY_B) result.append(m.group(1)) result.append(self.typestr2typestr(m.group(2))) result.append(objc._C_ARY_E) else: result.append(item) result = b''.join(result) return result
def testInStructDef(self): class OC_TestTypeCodeLeaks_StructDef(NSObject): def myBOOLArg_(self, arg): pass myBOOLArg_ = objc.selector( myBOOLArg_, signature=b"v@:" + objc._C_STRUCT_B + b"test=" + objc._C_NSBOOL + objc._C_STRUCT_E, ) def myInt8Arg_(self, arg): pass myInt8Arg_ = objc.selector( myInt8Arg_, signature=b"v@:" + objc._C_STRUCT_B + b"test=" + objc._C_CHAR_AS_INT + objc._C_STRUCT_E, ) def myByteArg_(self, arg): pass myByteArg_ = objc.selector( myByteArg_, signature=b"v@:" + objc._C_STRUCT_B + b"test=" + objc._C_CHAR_AS_TEXT + objc._C_STRUCT_E, ) def myUniCharArg_(self, arg): pass myUniCharArg_ = objc.selector( myUniCharArg_, signature=b"v@:" + objc._C_STRUCT_B + b"test=" + objc._C_UNICHAR + objc._C_STRUCT_E, ) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_StructDef.myBOOLArg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_StructDef.myBOOLArg_.native_signature) self.assertEqual( pysig[3], objc._C_STRUCT_B + b"test=" + objc._C_NSBOOL + objc._C_STRUCT_E) if objc.arch == "arm64": self.assertEqual( csig[3], objc._C_STRUCT_B + b"test=" + objc._C_BOOL + objc._C_STRUCT_E) else: self.assertEqual( csig[3], objc._C_STRUCT_B + b"test=" + objc._C_CHR + objc._C_STRUCT_E) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_StructDef.myInt8Arg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_StructDef.myInt8Arg_.native_signature) self.assertEqual( pysig[3], objc._C_STRUCT_B + b"test=" + objc._C_CHAR_AS_INT + objc._C_STRUCT_E, ) self.assertEqual( csig[3], objc._C_STRUCT_B + b"test=" + objc._C_CHR + objc._C_STRUCT_E) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_StructDef.myByteArg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_StructDef.myByteArg_.native_signature) self.assertEqual( pysig[3], objc._C_STRUCT_B + b"test=" + objc._C_CHAR_AS_TEXT + objc._C_STRUCT_E, ) self.assertEqual( csig[3], objc._C_STRUCT_B + b"test=" + objc._C_CHR + objc._C_STRUCT_E) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_StructDef.myUniCharArg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_StructDef.myUniCharArg_.native_signature) self.assertEqual( pysig[3], objc._C_STRUCT_B + b"test=" + objc._C_UNICHAR + objc._C_STRUCT_E) self.assertEqual( csig[3], objc._C_STRUCT_B + b"test=" + objc._C_SHT + objc._C_STRUCT_E)
def test_rectForPage(self): method = ObjCTestNSView_KnowPageRange.rectForPage_ self.assertEquals(objc.splitSignature(method.signature), objc.splitSignature("{_NSRect={_NSPoint=ff}{_NSSize=ff}}12@0:4i8"))
def test_rectForPage(self): method = ObjCTestNSView_KnowPageRange.rectForPage_ self.assertEquals( objc.splitSignature(method.signature), objc.splitSignature("{_NSRect={_NSPoint=ff}{_NSSize=ff}}12@0:4i8"))
def validate_encoding(typestr): """ Return True iff 'typestr' is a valid encoded type """ if not typestr: return False # Strip qualifiers while typestr and typestr[0] in (objc._C_IN, objc._C_OUT, objc._C_INOUT, objc._C_CONST, objc._C_ONEWAY): typestr = typestr[1:] if not typestr: return False if typestr[0] in (objc._C_BOOL, objc._C_CHARPTR, objc._C_CHR, objc._C_CLASS, objc._C_DBL, objc._C_FLT, objc._C_ID, objc._C_INT, objc._C_LNG, objc._C_LNG_LNG, objc._C_NSBOOL, objc._C_SEL, objc._C_SHT, objc._C_UCHR, objc._C_UINT, objc._C_ULNG, objc._C_ULNG_LNG, objc._C_UNDEF, objc._C_USHT): return len(typestr) == 1 elif typestr[0] == objc._C_ARY_B: if typestr[-1] != objc._C_ARY_E: return False typestr = typestr[1:-1] if len(typestr) == 0: return False while typestr and typestr[0].isdigit(): typestr = typestr[1:] if len(typestr) == 0: return False return validate_encoding(typestr) elif typestr[0] == objc._C_STRUCT_B: return True if typestr[-1] != objc._C_STRUCT_E: return False typestr = typestr[1:-1] if '=' in typestr: name = typestr[:typestr.find('=')] rest = typestr[typestr.find('=')+1:] if rest: if rest[0] != '"': fields = objc.splitSignature(rest) for fld in fields: if not validate_signature(fld): return False else: while rest: if rest.startswith('"'): end = rest.find('"', 1) fn = rest[1:end] for ch in fn: if fn != '_' and not fn.isalpha() and not fn.isdigit(): return False rest = rest[end+1:] end = rest.find('"') if end == -1: if not validate_encoding(rest): return False rest = '' else: if not validate_encoding(rest[:end]): return False rest = rest[end:] else: name = typestr if name != '?': for ch in name: if ch != '_' and not ch.isalpha() and not ch.isdigit(): return False return True elif typestr[0] == objc._C_BFLD: typestr = typestr[1:] if len(typestr) == 0: return False while typestr and typestr[0].isdigit(): typestr = typestr[1:] return typestr == '' return True
def validate_encoding(typestr): """ Return True iff 'typestr' is a valid encoded type """ if not typestr: return False # Strip qualifiers while typestr and typestr[0] in (objc._C_IN, objc._C_OUT, objc._C_INOUT, objc._C_CONST, objc._C_ONEWAY): typestr = typestr[1:] if not typestr: return False if typestr[0] in (objc._C_BOOL, objc._C_CHARPTR, objc._C_CHR, objc._C_CLASS, objc._C_DBL, objc._C_FLT, objc._C_ID, objc._C_INT, objc._C_LNG, objc._C_LNG_LNG, objc._C_NSBOOL, objc._C_SEL, objc._C_SHT, objc._C_UCHR, objc._C_UINT, objc._C_ULNG, objc._C_ULNG_LNG, objc._C_UNDEF, objc._C_USHT): return len(typestr) == 1 elif typestr[0] == objc._C_ARY_B: if typestr[-1] != objc._C_ARY_E: return False typestr = typestr[1:-1] if len(typestr) == 0: return False while typestr and typestr[0].isdigit(): typestr = typestr[1:] if len(typestr) == 0: return False return validate_encoding(typestr) elif typestr[0] == objc._C_STRUCT_B: return True if typestr[-1] != objc._C_STRUCT_E: return False typestr = typestr[1:-1] if '=' in typestr: name = typestr[:typestr.find('=')] rest = typestr[typestr.find('=') + 1:] if rest: if rest[0] != '"': fields = objc.splitSignature(rest) for fld in fields: if not validate_signature(fld): return False else: while rest: if rest.startswith('"'): end = rest.find('"', 1) fn = rest[1:end] for ch in fn: if fn != '_' and not fn.isalpha( ) and not fn.isdigit(): return False rest = rest[end + 1:] end = rest.find('"') if end == -1: if not validate_encoding(rest): return False rest = '' else: if not validate_encoding(rest[:end]): return False rest = rest[end:] else: name = typestr if name != '?': for ch in name: if ch != '_' and not ch.isalpha() and not ch.isdigit(): return False return True elif typestr[0] == objc._C_BFLD: typestr = typestr[1:] if len(typestr) == 0: return False while typestr and typestr[0].isdigit(): typestr = typestr[1:] return typestr == '' return True
def testSimpleTypes(self): class OC_TestTypeCodeLeaks_Result(NSObject): def myBOOLResult(self): return True myBOOLResult = objc.selector(myBOOLResult, signature=objc._C_NSBOOL + b"@:") def myInt8Result(self): return True myInt8Result = objc.selector(myInt8Result, signature=objc._C_CHAR_AS_INT + b"@:") def myByteResult(self): return True myByteResult = objc.selector(myByteResult, signature=objc._C_CHAR_AS_TEXT + b"@:") def myUniCharResult(self): return True myUniCharResult = objc.selector(myUniCharResult, signature=objc._C_UNICHAR + b"@:") def myUniStrResult(self): return True myUniStrResult = objc.selector(myUniStrResult, signature=objc._C_PTR + objc._C_UNICHAR + b"@:") pysig = objc.splitSignature( OC_TestTypeCodeLeaks_Result.myBOOLResult.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_Result.myBOOLResult.native_signature) self.assertEqual(pysig[0], objc._C_NSBOOL) if objc.arch == "arm64": self.assertEqual(csig[0], objc._C_BOOL) else: self.assertEqual(csig[0], objc._C_CHR) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_Result.myInt8Result.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_Result.myInt8Result.native_signature) self.assertEqual(pysig[0], objc._C_CHAR_AS_INT) self.assertEqual(csig[0], objc._C_CHR) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_Result.myByteResult.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_Result.myByteResult.native_signature) self.assertEqual(pysig[0], objc._C_CHAR_AS_TEXT) self.assertEqual(csig[0], objc._C_CHR) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_Result.myUniCharResult.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_Result.myUniCharResult.native_signature) self.assertEqual(pysig[0], objc._C_UNICHAR) self.assertEqual(csig[0], objc._C_SHT) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_Result.myUniStrResult.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_Result.myUniStrResult.native_signature) self.assertEqual(pysig[0], objc._C_PTR + objc._C_UNICHAR) self.assertEqual(csig[0], objc._C_PTR + objc._C_SHT)
def testInArrayDef(self): class OC_TestTypeCodeLeaks_ArrayDef(NSObject): def myBOOLArg_(self, arg): pass myBOOLArg_ = objc.selector( myBOOLArg_, signature=b"v@:" + objc._C_ARY_B + b"4" + objc._C_NSBOOL + objc._C_ARY_E, ) def myInt8Arg_(self, arg): pass myInt8Arg_ = objc.selector( myInt8Arg_, signature=b"v@:" + objc._C_ARY_B + b"4" + objc._C_CHAR_AS_INT + objc._C_ARY_E, ) def myByteArg_(self, arg): pass myByteArg_ = objc.selector( myByteArg_, signature=b"v@:" + objc._C_ARY_B + b"4" + objc._C_CHAR_AS_TEXT + objc._C_ARY_E, ) def myUniCharArg_(self, arg): pass myUniCharArg_ = objc.selector( myUniCharArg_, signature=b"v@:" + objc._C_ARY_B + b"4" + objc._C_UNICHAR + objc._C_ARY_E, ) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_ArrayDef.myBOOLArg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_ArrayDef.myBOOLArg_.native_signature) self.assertEqual(pysig[3], objc._C_ARY_B + b"4" + objc._C_NSBOOL + objc._C_ARY_E) self.assertEqual(csig[3], objc._C_ARY_B + b"4" + objc._C_CHR + objc._C_ARY_E) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_ArrayDef.myInt8Arg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_ArrayDef.myInt8Arg_.native_signature) self.assertEqual( pysig[3], objc._C_ARY_B + b"4" + objc._C_CHAR_AS_INT + objc._C_ARY_E) self.assertEqual(csig[3], objc._C_ARY_B + b"4" + objc._C_CHR + objc._C_ARY_E) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_ArrayDef.myByteArg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_ArrayDef.myByteArg_.native_signature) self.assertEqual( pysig[3], objc._C_ARY_B + b"4" + objc._C_CHAR_AS_TEXT + objc._C_ARY_E) self.assertEqual(csig[3], objc._C_ARY_B + b"4" + objc._C_CHR + objc._C_ARY_E) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_ArrayDef.myUniCharArg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_ArrayDef.myUniCharArg_.native_signature) self.assertEqual( pysig[3], objc._C_ARY_B + b"4" + objc._C_UNICHAR + objc._C_ARY_E) self.assertEqual(csig[3], objc._C_ARY_B + b"4" + objc._C_SHT + objc._C_ARY_E)
def testByRefIn(self): class OC_TestTypeCodeLeaks_RefIn(NSObject): def myBOOLArg_(self, arg): pass myBOOLArg_ = objc.selector(myBOOLArg_, signature=b"v@:" + objc._C_IN + objc._C_PTR + objc._C_NSBOOL) def myInt8Arg_(self, arg): pass myInt8Arg_ = objc.selector( myInt8Arg_, signature=b"v@:" + objc._C_IN + objc._C_PTR + objc._C_CHAR_AS_INT, ) def myByteArg_(self, arg): pass myByteArg_ = objc.selector( myByteArg_, signature=b"v@:" + objc._C_IN + objc._C_PTR + objc._C_CHAR_AS_TEXT, ) def myUniCharArg_(self, arg): pass myUniCharArg_ = objc.selector( myUniCharArg_, signature=b"v@:" + objc._C_IN + objc._C_PTR + objc._C_UNICHAR, ) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_RefIn.myBOOLArg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_RefIn.myBOOLArg_.native_signature) self.assertEqual(pysig[3], objc._C_IN + objc._C_PTR + objc._C_NSBOOL) if objc.arch == "arm64": self.assertEqual(csig[3], objc._C_IN + objc._C_PTR + objc._C_BOOL) else: self.assertEqual(csig[3], objc._C_IN + objc._C_PTR + objc._C_CHR) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_RefIn.myInt8Arg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_RefIn.myInt8Arg_.native_signature) self.assertEqual(pysig[3], objc._C_IN + objc._C_PTR + objc._C_CHAR_AS_INT) self.assertEqual(csig[3], objc._C_IN + objc._C_PTR + objc._C_CHR) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_RefIn.myByteArg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_RefIn.myByteArg_.native_signature) self.assertEqual(pysig[3], objc._C_IN + objc._C_PTR + objc._C_CHAR_AS_TEXT) self.assertEqual(csig[3], objc._C_IN + objc._C_PTR + objc._C_CHR) pysig = objc.splitSignature( OC_TestTypeCodeLeaks_RefIn.myUniCharArg_.signature) csig = objc.splitSignature( OC_TestTypeCodeLeaks_RefIn.myUniCharArg_.native_signature) self.assertEqual(pysig[3], objc._C_IN + objc._C_PTR + objc._C_UNICHAR) self.assertEqual(csig[3], objc._C_IN + objc._C_PTR + objc._C_SHT)