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 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 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 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)
