Commits

Ronald Oussoren committed 16fb386

Merged revisions 2582-2586 via svnmerge from
https://svn.red-bean.com/pyobjc/trunk/pyobjc

........
r2582 | ronaldoussoren | 2010-08-15 14:23:08 +0200 (Sun, 15 Aug 2010) | 4 lines

* Small updates to the metadata
* Add tests for more information, and explicit test failures for APIs that aren't
tested yet.
........
r2583 | ronaldoussoren | 2010-08-15 22:12:41 +0200 (Sun, 15 Aug 2010) | 4 lines

Fix lame bug in FSRef.from_pathname: the C implmentation was missing
the 'self' argument, which caused this class method to always raise
a TypeError.
........
r2584 | ronaldoussoren | 2010-08-15 22:52:50 +0200 (Sun, 15 Aug 2010) | 2 lines

Fix a python refcounting bug in PyObjCCF_NewSpecial
........
r2585 | ronaldoussoren | 2010-08-15 23:25:18 +0200 (Sun, 15 Aug 2010) | 6 lines

* Update api notes
* Expand test coverage
* Ensure that those tests pass
(except for a couple of APIs that aren't supported
right now and those are marked as such)
........
r2586 | ronaldoussoren | 2010-08-17 21:48:09 +0200 (Tue, 17 Aug 2010) | 4 lines

Improve test coverage and fix issues found by the added tests.

Quartz is now the only framework with some failing tests (all due to incomplete test cases)
........

  • Participants
  • Parent commits 7deae6a
  • Branches pyobjc-2.3.x

Comments (0)

Files changed (15)

File pyobjc-core/Modules/objc/corefoundation.m

 	CFTypeID typeid;
 
 	if (depythonify_c_value(@encode(CFTypeID), v, &typeid) < 0) {
-		Py_DECREF(v);
 		return NULL;
 	}
-	Py_DECREF(v);
 
 	if (gTypeid2class != NULL) {
 		PyObject* cfid;

File pyobjc-core/Modules/objc/fsref.m

 			strlen((char*)buffer), NULL);
 }
 
-static PyObject* fsref_from_path(PyObject* path)
+static PyObject* fsref_from_path(PyObject* self, PyObject* path)
 {
 	PyObject* value;
 	FSRef result;

File pyobjc-core/NEWS.txt

 - ``objc.allocateBuffer`` now returns a bytearray on python >= 2.6,
   it used to return a buffer object in Python 2.
 
+- ``objc.FSRef.from_pathname`` actually works instead of always raising
+   a TypeError.
+
 Version 2.3
 -----------
 

File pyobjc-framework-LaunchServices/Doc/api-notes-LaunchServices.txt

   Not supported at the moment because the Authorization framweork isn't properly 
   wrapped yet.
 
-* ``LSSharedFileListItemRef``
+* ``LSLaunchFSRefSpec``, ``LSLaunchURLSpec``
 
-  Not tested at the moment, uses ``LSSharedFileListInsertItemURL`` instead.
+  These types aren't supported in this version.
 
-* The tests for this framework are incomplete, although
-  most functions should work just fine.
+* ``LSOpenApplication``
 
+  This function is not yet supported. The bridge itself isn't smart
+  enough yet to process the first argument without a manual wrapper.
+
+* ``LSOpenItemsWithRole``, ``LSOpenURLsWithRole``
+
+  The ``inAEParam`` and ``inAppParams`` must be None.
+
+* ``LSOpenFromRefSpec``, ``LSOpenFromURLSpec``
+
+  This functions are not yet supported and need manual wrappers.
+

File pyobjc-framework-LaunchServices/Lib/LaunchServices/PyObjC.bridgesupport

   <depends_on path='/System/Library/Frameworks/Security.framework/Security' />
   <depends_on path='/System/Library/Frameworks/CoreServices.framework/Frameworks/AE.framework/AE' />
   <depends_on path='/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation' />
+  <struct name='LSItemInfoRecord' type='{LSItemInfoRecord="flags"I"filetype"I"creator"I"extension"^{__CFString}"iconFileName"^{__CFString}"kindID"I}' type64='{LSItemInfoRecord="flags"I"filetype"I"creator"I"extension"^{__CFString}}' />
   <struct name='LSApplicationParameters' type='{LSApplicationParameters="version"i"flags"I"application"^{FSRef}"asyncLaunchRefCon"^v"environment"^{__CFDictionary}"argv"^{__CFArray}"initialEvent"^{AEDesc}}' type64='{LSApplicationParameters="version"q"flags"I"application"^{FSRef}"asyncLaunchRefCon"^v"environment"^{__CFDictionary}"argv"^{__CFArray}"initialEvent"^{AEDesc}}' />
   <struct name='LSLaunchFSRefSpec' type='{LSLaunchFSRefSpec="appRef"^{FSRef}"numDocs"I"itemRefs"^{FSRef}"passThruParams"^{AEDesc}"launchFlags"I"asyncRefCon"^v}' type64='{LSLaunchFSRefSpec="appRef"^{FSRef}"numDocs"Q"itemRefs"^{FSRef}"passThruParams"^{AEDesc}"launchFlags"I"asyncRefCon"^v}' />
   <struct name='LSLaunchURLSpec' type='{LSLaunchURLSpec="appURL"^{__CFURL}"itemURLs"^{__CFArray}"passThruParams"^{AEDesc}"launchFlags"I"asyncRefCon"^v}' type64='{LSLaunchURLSpec="appURL"^{__CFURL}"itemURLs"^{__CFArray}"passThruParams"^{AEDesc}"launchFlags"I"asyncRefCon"^v}' />
   <constant name='kLSSharedFileListFavoriteItems' type='^{__CFString=}' />
   <constant name='kLSSharedFileListFavoriteVolumes' type='^{__CFString=}' />
   <constant name='kLSSharedFileListGlobalLoginItems' type='^{__CFString=}' />
-  <!--
   <constant name='kLSSharedFileListItemBeforeFirst' type='^{OpaqueLSSharedFileListItemRef=}' magic_cookie='true' />
+  <constant name='kLSSharedFileListItemLast' type='^{OpaqueLSSharedFileListItemRef=}' magic_cookie='true' />
   <constant name='kLSSharedFileListItemHidden' type='^{__CFString=}' />
-  <constant name='kLSSharedFileListItemLast' type='^{OpaqueLSSharedFileListItemRef=}' magic_cookie='true' />
-  -->
   <constant name='kLSSharedFileListRecentApplicationItems' type='^{__CFString=}' />
   <constant name='kLSSharedFileListRecentDocumentItems' type='^{__CFString=}' />
   <constant name='kLSSharedFileListRecentItemsMaxAmount' type='^{__CFString=}' />
   <enum name='kLSRequestExtensionFlagsOnly' value='64' />
   <enum name='kLSRequestIconAndKind' value='32' />
   <enum name='kLSRequestTypeCreator' value='2' />
-  <enum name='kLSRolesAll' value='-1' />
+  <enum name='kLSRolesAll' value='4294967295' value64='18446744073709551615'/>
   <enum name='kLSRolesEditor' value='4' />
   <enum name='kLSRolesNone' value='1' />
   <enum name='kLSRolesShell' value='8' />
     <retval type='l' type64='i' />
     <arg type='^{__CFString=}' />
     <arg type='L' type64='L' />
-    <arg already_retained='true' type='^^{__CFURL}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFURL}' type_modifier='o' />
   </function>
   <function name='LSCopyApplicationURLsForURL'>
     <retval already_cfretained='true' type='^{__CFArray=}' />
   <function name='LSCopyDisplayNameForRef'>
     <retval type='l' type64='i' />
     <arg type='^{FSRef=[80C]}' type_modifier='n' />
-    <arg already_retained='true' type='^^{__CFString}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFString}' type_modifier='o' />
   </function>
   <function name='LSCopyDisplayNameForURL'>
     <retval type='l' type64='i' />
     <arg type='^{__CFURL=}' />
-    <arg already_retained='true' type='^^{__CFString}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFString}' type_modifier='o' />
   </function>
   <function name='LSCopyItemAttribute'>
     <retval type='l' type64='i' />
     <arg type='^{FSRef=[80C]}' type_modifier='n' />
     <arg type='L' type64='L' />
     <arg type='^{__CFString=}' />
-    <arg already_retained='true' type='^@' type_modifier='o' />
+    <arg already_cfretained='true' type='^@' type_modifier='o' />
   </function>
   <function name='LSCopyItemAttributes'>
     <retval type='l' type64='i' />
     <retval type='l' type64='i' />
     <arg type='^{FSRef=[80C]}' type_modifier='n' />
     <arg type='L' type64='L' />
-    <arg type='^{LSItemInfoRecord=III^{__CFString}^{__CFString}I}' type64='^{LSItemInfoRecord=III^{__CFString}^{__CFString}I}' type_modifier='o' />
+    <arg type='^{LSItemInfoRecord=III^{__CFString}^{__CFString}I}' type64='^{LSItemInfoRecord=III^{__CFString}}' type_modifier='o' />
   </function>
   <function name='LSCopyItemInfoForURL'>
     <retval type='l' type64='i' />
     <arg type='^{__CFURL=}' />
     <arg type='L' type64='L' />
-    <arg type='^{LSItemInfoRecord=III^{__CFString}^{__CFString}I}' type64='^{LSItemInfoRecord=III^{__CFString}^{__CFString}I}' type_modifier='o' />
+    <arg type='^{LSItemInfoRecord=III^{__CFString}^{__CFString}I}' type64='^{LSItemInfoRecord=III^{__CFString}}' type_modifier='o' />
   </function>
   <function name='LSCopyKindStringForMIMEType'>
     <retval type='l' type64='i' />
     <arg type='^{__CFString=}' />
-    <arg already_retained='true' type='^^{__CFString}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFString}' type_modifier='o' />
   </function>
   <function name='LSCopyKindStringForRef'>
     <retval type='l' type64='i' />
     <arg type='^{FSRef=[80C]}' type_modifier='n' />
-    <arg already_retained='true' type='^^{__CFString}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFString}' type_modifier='o' />
   </function>
   <function name='LSCopyKindStringForTypeInfo'>
     <retval type='l' type64='i' />
     <arg type='L' type64='L' />
     <arg type='L' type64='L' />
     <arg type='^{__CFString=}' />
-    <arg already_retained='true' type='^^{__CFString}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFString}' type_modifier='o' />
   </function>
   <function name='LSCopyKindStringForURL'>
     <retval type='l' type64='i' />
     <arg type='^{__CFURL=}' />
-    <arg already_retained='true' type='^^{__CFString}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFString}' type_modifier='o' />
   </function>
   <function name='LSFindApplicationForInfo'>
     <retval type='l' type64='i' />
     <arg type='^{__CFString=}' />
     <arg type='^{__CFString=}' />
     <arg type='^{FSRef=[80C]}' type_modifier='o' />
-    <arg already_retained='true' type='^^{__CFURL}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFURL}' type_modifier='o' />
   </function>
   <function name='LSGetApplicationForInfo'>
     <retval type='l' type64='i' />
     <arg type='^{__CFString=}' />
     <arg type='L' type64='L' />
     <arg type='^{FSRef=[80C]}' type_modifier='o' />
-    <arg already_retained='true' type='^^{__CFURL}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFURL}' type_modifier='o' />
   </function>
   <function name='LSGetApplicationForItem'>
     <retval type='l' type64='i' />
     <arg type='^{FSRef=[80C]}' type_modifier='n' />
     <arg type='L' type64='L' />
     <arg type='^{FSRef=[80C]}' type_modifier='o' />
-    <arg already_retained='true' type='^^{__CFURL}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFURL}' type_modifier='o' />
   </function>
   <function name='LSGetApplicationForURL'>
     <retval type='l' type64='i' />
     <arg type='^{__CFURL=}' />
     <arg type='L' type64='L' />
     <arg type='^{FSRef=[80C]}' type_modifier='o' />
-    <arg already_retained='true' type='^^{__CFURL}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFURL}' type_modifier='o' />
   </function>
   <function name='LSGetExtensionInfo'>
     <retval type='l' type64='i' />
   <function name='LSOpenCFURLRef'>
     <retval type='l' type64='i' />
     <arg type='^{__CFURL=}' />
-    <arg already_retained='true' type='^^{__CFURL}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFURL}' type_modifier='o' />
   </function>
   <function name='LSOpenFSRef'>
     <retval type='l' type64='i' />
   <function name='LSOpenFromURLSpec'>
     <retval type='l' type64='i' />
     <arg type='^{LSLaunchURLSpec=^{__CFURL}^{__CFArray}^{AEDesc}I^v}' type_modifier='n' />
-    <arg already_retained='true' type='^^{__CFURL}' type_modifier='o' />
+    <arg already_cfretained='true' type='^^{__CFURL}' type_modifier='o' />
   </function>
   <function name='LSOpenItemsWithRole'>
     <retval type='l' type64='i' />
     <arg type='L' type64='L' />
     <arg type='^{AEKeyDesc=I{AEDesc=I^^{OpaqueAEDataStorageType}}}' type_modifier='n' />
     <arg type='^{LSApplicationParameters=iI^{FSRef}^v^{__CFDictionary}^{__CFArray}^{AEDesc}}' type64='^{LSApplicationParameters=iI^{FSRef}^v^{__CFDictionary}^{__CFArray}^{AEDesc}}' type_modifier='n' />
-    <arg type='^{ProcessSerialNumber=II}' type_modifier='o' />
+    <arg type='^{ProcessSerialNumber=II}' type_modifier='o' c_array_length_in_arg='6' />
     <arg type='l' type64='l' />
   </function>
   <function name='LSOpenURLsWithRole'>
     <arg type='L' type64='L' />
     <arg type='^{AEKeyDesc=I{AEDesc=I^^{OpaqueAEDataStorageType}}}' type_modifier='n' />
     <arg type='^{LSApplicationParameters=iI^{FSRef}^v^{__CFDictionary}^{__CFArray}^{AEDesc}}' type64='^{LSApplicationParameters=iI^{FSRef}^v^{__CFDictionary}^{__CFArray}^{AEDesc}}' type_modifier='n' />
-    <arg type='^{ProcessSerialNumber=II}' type_modifier='o' />
+    <arg type='^{ProcessSerialNumber=II}' type_modifier='o' c_array_length_in_arg='5' />
     <arg type='l' type64='l' />
   </function>
   <function name='LSRegisterFSRef'>
   </function>
   <function name='LSSetItemAttribute'>
     <retval type='l' type64='i' />
-    <arg type='^{FSRef=[80C]}' type64='^{FSRef=[80C]}' />
+    <arg type='^{FSRef=[80C]}' type64='^{FSRef=[80C]}' type_modifier='n'/>
     <arg type='L' type64='L' />
     <arg type='^{__CFString=}' />
     <arg type='@' />
   <function name='LSSharedFileListCopySnapshot'>
     <retval already_cfretained='true' type='^{__CFArray=}' />
     <arg type='^{OpaqueLSSharedFileListRef=}' />
-    <arg type='^I' type64='^I' />
+    <arg type='^I' type64='^I' type_modifier='o' />
   </function>
   <function name='LSSharedFileListCreate'>
     <retval type='^{OpaqueLSSharedFileListRef=}' already_cfretained='true' />
     <arg type='^{__CFArray=}' />
   </function>
   <function name='LSSharedFileListInsertItemURL'>
-    <retval type='^{OpaqueLSSharedFileListItemRef=}' />
+    <retval type='^{OpaqueLSSharedFileListItemRef=}' already_cfretained='true' />
     <arg type='^{OpaqueLSSharedFileListRef=}' />
     <arg type='^{OpaqueLSSharedFileListItemRef=}' />
     <arg type='^{__CFString=}' />
     <retval type='l' type64='i' />
     <arg type='^{OpaqueLSSharedFileListItemRef=}' />
     <arg type='L' type64='L' />
-    <arg type='^^{__CFURL}' type64='^^{__CFURL}' />
-    <arg type='^{FSRef=[80C]}' type64='^{FSRef=[80C]}' />
+    <arg type='^^{__CFURL}' type64='^^{__CFURL}' type_modifier='o' already_cfretained='true' />
+    <arg type='^{FSRef=[80C]}' type64='^{FSRef=[80C]}' type_modifier='o' />
   </function>
   <function name='LSSharedFileListItemSetProperty'>
     <retval type='l' type64='i' />

File pyobjc-framework-LaunchServices/PyObjCTest/test_lsinfo.py

 
 from PyObjCTools.TestSupport import *
 from LaunchServices import *
+import sys
+import os
 
 class TestLSInfo (TestCase):
+    def setUp(self):
+        self.path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'dummy.txt')
+        fp = open(self.path, 'w')
+        fp.write('test contents')
+        fp.close()
+
+    def tearDown(self):
+        if os.path.exists(self.path):
+            os.unlink(self.path)
+
     def testConstants(self):
         self.assertEqual(kLSAppInTrashErr, -10660)
         self.assertEqual(kLSExecutableIncorrectFormat, -10661)
         self.assertEqual(kLSRolesViewer, 0x00000002)
         self.assertEqual(kLSRolesEditor, 0x00000004)
         self.assertEqual(kLSRolesShell, 0x00000008)
-        self.assertEqual(kLSRolesAll, cast_int(0xFFFFFFFF))
+        self.assertEqual(kLSRolesAll, 0xFFFFFFFF, 0xFFFFFFFFFFFFFFFF)
         self.assertEqual(kLSUnknownKindID, 0)
         self.assertEqual(kLSUnknownType, 0)
         self.assertEqual(kLSUnknownCreator, 0)
         self.assertEqual(kLSAcceptDefault, 0x00000001)
         self.assertEqual(kLSAcceptAllowLoginUI, 0x00000002)
 
+        self.assertIsInstance(kLSItemContentType, unicode)
+        self.assertIsInstance(kLSItemFileType, unicode)
+        self.assertIsInstance(kLSItemFileCreator, unicode)
+        self.assertIsInstance(kLSItemExtension, unicode)
+        self.assertIsInstance(kLSItemDisplayName, unicode)
+        self.assertIsInstance(kLSItemDisplayKind, unicode)
+        self.assertIsInstance(kLSItemRoleHandlerDisplayName, unicode)
+        self.assertIsInstance(kLSItemIsInvisible, unicode)
+        self.assertIsInstance(kLSItemExtensionIsHidden, unicode)
+        self.assertIsInstance(kLSItemQuarantineProperties, unicode)
+
+
+        self.assertEqual(kLSHandlerOptionsDefault, 0)
+        self.assertEqual(kLSHandlerOptionsIgnoreCreator, 1)
+
+
+    def testStructs(self):
+        v = LSItemInfoRecord()
+        self.assertHasAttr(v, 'flags')
+        self.assertHasAttr(v, 'filetype')
+        self.assertHasAttr(v, 'creator')
+        self.assertHasAttr(v, 'extension')
+        if sys.maxint < 2 ** 32:
+            self.assertHasAttr(v, 'iconFileName')
+            self.assertHasAttr(v, 'kindID')
+        else:
+            self.assertNotHasAttr(v, 'iconFileName')
+            self.assertNotHasAttr(v, 'kindID')
+
     def testFunctions(self):
         LSInit(kLSInitializeDefaults)
         LSTerm()
 
-        path = "/Library/Documents/Acknowledgements.rtf"
-        url = CFURLCreateFromFileSystemRepresentation(None, path, len(path), True)
+        url = CFURLCreateFromFileSystemRepresentation(None, self.path, len(self.path), True)
         self.assertIsInstance(url, CFURLRef)
 
         ok, info = LSCopyItemInfoForURL(url, kLSRequestExtension|kLSRequestTypeCreator, None)
         self.assertEqual(ok, 0)
         self.assertIsInstance(info, LSItemInfoRecord)
 
-        self.fail("Start at LSGetExtensionInfo")
+        self.assertArgIsOut(LSGetExtensionInfo, 2)
+        ok, info = LSGetExtensionInfo(len(self.path), self.path, None)
+        self.failUnlessEqual(ok, 0)
+        self.failUnlessEqual(info, self.path.index('.')+1)
+
+        self.assertArgIsOut(LSCopyDisplayNameForURL, 1)
+        self.assertArgIsCFRetained(LSCopyDisplayNameForURL, 1)
+        ok, info = LSCopyDisplayNameForURL(url, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(info, unicode)
+
+        self.assertArgIsBOOL(LSSetExtensionHiddenForURL, 1)
+        ok = LSSetExtensionHiddenForURL(url, True)
+        self.assertEquals(ok, 0)
+
+        self.assertArgIsOut(LSCopyKindStringForURL, 1)
+        self.assertArgIsCFRetained(LSCopyKindStringForURL, 1)
+        ok, info = LSCopyKindStringForURL(url, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(info, unicode)
+
+        self.assertArgIsOut(LSCopyKindStringForTypeInfo, 3)
+        self.assertArgIsCFRetained(LSCopyKindStringForTypeInfo, 3)
+        ok, info = LSCopyKindStringForTypeInfo(kLSUnknownType, kLSUnknownCreator, "jpg", None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(info, unicode)
+
+        self.assertArgIsOut(LSCopyKindStringForMIMEType, 1)
+        self.assertArgIsCFRetained(LSCopyKindStringForMIMEType, 1)
+        ok, info = LSCopyKindStringForMIMEType("image/jpeg", None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(info, unicode)
+
+        self.assertArgIsOut(LSGetApplicationForInfo, 4)
+        self.assertArgIsOut(LSGetApplicationForInfo, 5)
+        self.assertArgIsCFRetained(LSGetApplicationForInfo, 5)
+
+        ok, ref, info_url = LSGetApplicationForInfo(kLSUnknownType, kLSUnknownCreator, "txt", kLSRolesAll, None, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(ref, objc.FSRef)
+        self.assertIsInstance(info_url, CFURLRef)
+        
+        self.assertArgIsOut(LSCopyApplicationForMIMEType, 2)
+        self.assertArgIsCFRetained(LSCopyApplicationForMIMEType, 2)
+        ok, info_url = LSCopyApplicationForMIMEType("text/plain", kLSRolesAll, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(info_url, CFURLRef)
+
+        self.assertArgIsOut(LSGetApplicationForURL, 2)
+        self.assertArgIsOut(LSGetApplicationForURL, 3)
+        self.assertArgIsCFRetained(LSGetApplicationForURL, 3)
+        ok, ref, info_url = LSGetApplicationForURL(url, kLSRolesAll, None, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(ref, objc.FSRef)
+        self.assertIsInstance(info_url, CFURLRef)
+
+        self.assertArgIsOut(LSFindApplicationForInfo, 3)
+        self.assertArgIsOut(LSFindApplicationForInfo, 4)
+        self.assertArgIsCFRetained(LSFindApplicationForInfo, 4)
+        ok, ref, info_url = LSFindApplicationForInfo(kLSUnknownCreator, None, "foo.app", None, None)
+        # XXX: The code looks correct but fails, however the corresponding C code also fails.
+        #self.assertEquals(ok, 0)
+        self.assertIsInstance(ok, (int, long))
+        if ref is not None:
+            self.assertIsInstance(ref, objc.FSRef)
+        if info_url is not None:
+            self.assertIsInstance(info_url, CFURLRef)
+
+        self.assertArgIsOut(LSCanURLAcceptURL, 4)
+        ok, status = LSCanURLAcceptURL(url, url, kLSRolesAll, kLSAcceptDefault, None)
+        self.assertIsInstance(ok, (int, long))
+        self.assertIsInstance(status, bool)
+
+        ok = LSRegisterURL(url, False)
+        self.assertIsInstance(ok, (int, long))
+
+
+        v = LSCopyApplicationURLsForURL(url, kLSRolesAll)
+        self.assertIsInstance(v, CFArrayRef)
+        for a in v:
+            self.assertIsInstance(a, CFURLRef)
+
+        
+        default_role = LSCopyDefaultRoleHandlerForContentType("public.plain-text", kLSRolesAll)
+        self.assertIsInstance(default_role, unicode)
+
+        v = LSCopyAllRoleHandlersForContentType("public.plain-text", kLSRolesAll)
+        self.assertIsInstance(v, CFArrayRef)
+        for a in v:
+            self.assertIsInstance(a, unicode)
+
+
+        ok = LSSetDefaultRoleHandlerForContentType("public.plain-text", kLSRolesAll, default_role)
+        self.assertIsInstance(ok, (int, long))
+
+        v = LSGetHandlerOptionsForContentType("public.plain-text")
+        self.assertIsInstance(v, (int, long))
+
+        ok = LSSetHandlerOptionsForContentType("public.plain-text", v)
+        self.assertIsInstance(ok, (int, long))
+
+        self.assertResultIsCFRetained(LSCopyDefaultHandlerForURLScheme)
+        default_handler = LSCopyDefaultHandlerForURLScheme("http")
+        self.assertIsInstance(default_handler, unicode)
+
+        self.assertResultIsCFRetained(LSCopyAllHandlersForURLScheme)
+        v = LSCopyAllHandlersForURLScheme("http")
+        self.assertIsInstance(v, CFArrayRef)
+        for a in v:
+            self.assertIsInstance(a, unicode)
+
+        ok = LSSetDefaultHandlerForURLScheme("http", default_handler)
+        self.assertIsInstance(ok, (int, long))
+
+
+
+
+
+
 
 
 
     def testFSRef(self):
-        self.fail('LSCopyItemInfoForRef')
-        
+        ref = objc.FSRef.from_pathname(self.path)
+        self.assertIsInstance(ref, objc.FSRef)
+
+        ok, info = LSCopyItemInfoForRef(ref, kLSRequestExtension|kLSRequestTypeCreator, None)
+        self.assertEqual(ok, 0)
+        self.assertIsInstance(info, LSItemInfoRecord)
+
+        self.assertArgIsOut(LSCopyDisplayNameForRef, 1)
+        self.assertArgIsCFRetained(LSCopyDisplayNameForRef, 1)
+        ok, info = LSCopyDisplayNameForRef(ref, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(info, unicode)
+
+        self.assertArgIsBOOL(LSSetExtensionHiddenForRef, 1)
+        ok = LSSetExtensionHiddenForRef(ref, True)
+        self.assertEquals(ok, 0)
+
+        self.assertArgIsOut(LSCopyKindStringForRef, 1)
+        self.assertArgIsCFRetained(LSCopyKindStringForRef, 1)
+        ok, info = LSCopyKindStringForRef(ref, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(info, unicode)
+
+        self.assertArgIsOut(LSGetApplicationForItem, 2)
+        self.assertArgIsOut(LSGetApplicationForItem, 3)
+        self.assertArgIsCFRetained(LSGetApplicationForItem, 3)
+        ok, info_ref, info_url = LSGetApplicationForItem(ref, kLSRolesAll, None, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(info_ref, objc.FSRef)
+        self.assertIsInstance(info_url, CFURLRef)
+
+
+        app_ref = objc.FSRef.from_pathname('/Applications/TextEdit.app')
+        self.assertArgIsOut(LSCanRefAcceptItem, 4)
+        ok, accepts = LSCanRefAcceptItem(ref, app_ref, kLSRolesAll, kLSAcceptDefault, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(accepts, bool)
+
+        ok = LSRegisterFSRef(ref, False)
+        self.assertIsInstance(ok, (int, long))
+
+        self.assertArgHasType(LSCopyItemAttribute, 3, 'o^@')
+        ok, value = LSCopyItemAttribute(ref, kLSRolesAll, kLSItemExtensionIsHidden, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(value, bool)
+
+
+        ok = LSSetItemAttribute(ref, kLSRolesAll, kLSItemRoleHandlerDisplayName, u"foo")
+        self.assertIsInstance(ok, (int, long))
+
 
 
 if __name__ == "__main__":

File pyobjc-framework-LaunchServices/PyObjCTest/test_lsopen.py

 
 from PyObjCTools.TestSupport import *
 from LaunchServices import *
+import sys
+import os
 
 class TestLSOpen (TestCase):
+    def setUp(self):
+        self.path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'dummy.txt')
+        fp = open(self.path, 'w')
+        fp.write('test contents')
+        fp.close()
+
+    def tearDown(self):
+        if os.path.exists(self.path):
+            os.unlink(self.path)
+
     def testConstants(self):
         self.assertEqual(kLSLaunchDefaults, 0x00000001)
         self.assertEqual(kLSLaunchAndPrint, 0x00000002)
         self.assertEqual(kLSLaunchHasUntrustedContents, 0x00400000)
 
     def testStructs(self):
-        pass
+        v = LSApplicationParameters()
+        self.assertHasAttr(v, "version")
+        self.assertHasAttr(v, "flags")
+        self.assertHasAttr(v, "application")
+        self.assertHasAttr(v, "asyncLaunchRefCon")
+        self.assertHasAttr(v, "environment")
+        self.assertHasAttr(v, "argv")
+        self.assertHasAttr(v, "initialEvent")
 
+    @expectedFailure
+    def testUnsupportedStructs(self):
+        self.fail("LSLaunchFSRefSpec")
 
+
+    def testFunctions(self):
+        url = CFURLCreateFromFileSystemRepresentation(None, self.path, len(self.path), True)
+
+        self.assertArgIsOut(LSOpenCFURLRef, 1)
+        ok, u = LSOpenCFURLRef(url, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(u, CFURLRef)
+
+        self.assertArgIsIn(LSOpenItemsWithRole, 0)
+        self.assertArgSizeInArg(LSOpenItemsWithRole, 0, 1)
+        self.assertArgIsIn(LSOpenItemsWithRole, 3)
+        self.assertArgIsIn(LSOpenItemsWithRole, 4)
+        self.assertArgIsOut(LSOpenItemsWithRole, 5)
+        self.assertArgSizeInArg(LSOpenItemsWithRole, 5, 6)
+        ref = objc.FSRef.from_pathname(self.path)
+        ok, psns = LSOpenItemsWithRole([ref], 1, kLSRolesAll, None, None, None, 1)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(psns, (list, tuple))
+        for x in psns:
+            # Actually a ProcessSerialNumber, but those aren't wrapped yet
+            self.assertIsInstance(x, tuple)
+            self.assertEquals(len(x), 2)
+            self.assertIsInstance(x[0], (int, long))
+            self.assertIsInstance(x[1], (int, long))
+
+        self.assertArgIsIn(LSOpenURLsWithRole, 2)
+        self.assertArgIsIn(LSOpenURLsWithRole, 3)
+        self.assertArgIsOut(LSOpenURLsWithRole, 4)
+        self.assertArgSizeInArg(LSOpenURLsWithRole, 4, 5)
+        ok, psns = LSOpenURLsWithRole([url], kLSRolesAll, None, None, None, 1)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(psns, (list, tuple))
+        for x in psns:
+            # Actually a ProcessSerialNumber, but those aren't wrapped yet
+            self.assertIsInstance(x, tuple)
+            self.assertEquals(len(x), 2)
+            self.assertIsInstance(x[0], (int, long))
+            self.assertIsInstance(x[1], (int, long))
+
+
+
+    @expectedFailure
+    def testUnsupportedFunctions(self):
+        self.assertArgIsIn(LSOpenApplication, 0)
+        self.assertArgIsOut(LSOpenApplication, 1)
+        params = LSApplicationParameters(
+                version=0,
+                flags = kLSLaunchDefaults,
+                application = objc.FSRef.from_pathname('/Applications/Utilities/Terminal.app'),
+                asyncLaunchRefCon = None,
+                environment = None,
+                argv = [u"Terminal"],
+                initialEvent = None,
+            )
         
-    def testIncomplete(self):
-        self.fail("Add header tests for <LaunchServices/LSOpen.h>")
+        # Call will fail for now, 'application' is an FSRef pointers and
+        # pyobjc-core isn't smart enough to deal with that.
+        ok, psn = LSOpenApplication(params, None)
+        self.assertEquals(ok, 0)
+        self.assertIsInstance(psn, (int, long))
 
+
+    @expectedFailure
+    def testFSRef(self):
+        # Functions using structs we don't support, probably need
+        # manual wrappers
+        self.fail("LSOpenFromRefSpec")
+        self.fail("LSOpenFromURLSpec")
+        
 if __name__ == "__main__":
     main()

File pyobjc-framework-LaunchServices/PyObjCTest/test_lssharedfilelist.py

 from LaunchServices import *
 
 class TestLSSharedFileList (TestCase):
-    def testIncomplete(self):
-        self.fail("Add header tests for <LaunchServices/LSSharedFileList.h>")
-
     def testTypes(self):
         self.assertIsCFType(LSSharedFileListRef)
         self.assertIsCFType(LSSharedFileListItemRef)
         self.assertIsInstance(kLSSharedFileListVolumesComputerVisible, unicode)
         self.assertIsInstance(kLSSharedFileListVolumesIDiskVisible, unicode)
         self.assertIsInstance(kLSSharedFileListVolumesNetworkVisible, unicode)
+        self.assertIsInstance(kLSSharedFileListItemHidden, unicode)
+
+    @min_os_level('10.5')
+    def testMagicConstants10_5(self):
         self.assertIsInstance(kLSSharedFileListItemBeforeFirst, LSSharedFileListItemRef)
         self.assertIsInstance(kLSSharedFileListItemLast, LSSharedFileListItemRef)
-        self.assertIsInstance(kLSSharedFileListItemHidden, unicode)
 
     def testConstants(self):
         self.assertEqual(kLSSharedFileListNoUserInteraction, 1)
 
         self.assertResultIsCFRetained(LSSharedFileListCopyProperty)
         self.assertResultHasType(LSSharedFileListCopyProperty, b'@')
-        v = LSSharedFileListCopyProperty(lst, u"name")
+        v = LSSharedFileListCopyProperty(lst, u"pyobjc.name")
 
         v = LSSharedFileListSetProperty(lst, u"pyobjc.name", u"value")
         self.assertIsInstance(v, (int, long))
-        v = LSSharedFileListCopyProperty(lst, u"name")
+        v = LSSharedFileListCopyProperty(lst, u"pyobjc.name")
         self.assertEqual(v, u"value")
 
         self.assertArgIsOut(LSSharedFileListCopySnapshot, 1)
         self.assertIsInstance(seed, (int,long))
 
         self.assertResultIsCFRetained(LSSharedFileListInsertItemURL)
-        item = LSSharedFileListInsertItemURL(lst, kLSSharedFileListItemLast, "PyObjC.Test", None, 
+        item = LSSharedFileListInsertItemURL(lst, kLSSharedFileListItemLast, u"PyObjC.Test", None, 
                 CFURLCreateWithString(None, "file:///etc/hosts", None), {}, [])
         self.assertIsInstance(item, LSSharedFileListItemRef)
 
         self.assertIsInstance(v, (int, long))
 
         v = LSSharedFileListItemCopyIconRef(item)
-        self.assertIsObject(v, None)
+        if v is not None:
+            self.assertIsInstance(v, IconRef)
 
         self.assertResultIsCFRetained(LSSharedFileListItemCopyDisplayName)
         v = LSSharedFileListItemCopyDisplayName(item)
         self.assertArgIsCFRetained(LSSharedFileListItemResolve, 2)
         v, url, ref = LSSharedFileListItemResolve(item, 0, None, objc.NULL)
         self.assertIsInstance(v, (int, long))
-        self.assertIsInstance(url, CFURLRef)
+        if url is not None:
+            self.assertIsInstance(url, CFURLRef)
 
-        v = LSSharedFileListItemSetProperty(item, u"name", u"pyobjc.test")
+        v = LSSharedFileListItemSetProperty(item, u"pyobjc.name", u"pyobjc.test")
         self.assertIsInstance(v, (int, long))
 
         self.assertResultIsCFRetained(LSSharedFileListItemCopyProperty)
-        v = LSSharedFileListItemCopyProperty(item, u"name")
-        self.assertEqual(v, "pyobjc.test")
+        v = LSSharedFileListItemCopyProperty(item, u"pyobjc.name")
+        if v is not None:
+            self.assertEqual(v, "pyobjc.test")
 
         v = LSSharedFileListItemMove(lst, item, kLSSharedFileListItemBeforeFirst)
         self.assertIsInstance(v, (int, long))
 
 
 
-
-
-
-
-
-
-
-
+    @expectedFailure
     def testMissing(self):
         # Needs more infrastructure
         self.fail('LSSharedFileListSetAuthorization')

File pyobjc-framework-Quartz/Lib/Quartz/CoreGraphics/PyObjC.bridgesupport

   </function>
   <function name='CGContextShowGlyphs'>
     <arg type='^{CGContext=}' />
-    <arg c_array_length_in_arg='1' type='^S' type_modifier='n' />
+    <arg c_array_length_in_arg='2' type='^S' type_modifier='n' />
     <arg type='L' type64='L' />
   </function>
   <function name='CGContextShowGlyphsAtPoint'>
   </function>
   <function name='CGContextShowGlyphsAtPositions'>
     <arg type='^{CGContext=}' />
-    <arg c_array_length_in_arg='3' type='^S' />
-    <arg c_array_length_in_arg='3' type='^{CGPoint=ff}' type64='^{CGPoint=dd}' />
+    <arg c_array_length_in_arg='3' type='^S' type_modifier='n' />
+    <arg c_array_length_in_arg='3' type='^{CGPoint=ff}' type64='^{CGPoint=dd}' type_modifier='n' />
     <arg type='L' type64='L' />
   </function>
   <function name='CGContextShowGlyphsWithAdvances'>

File pyobjc-framework-Quartz/Modules/_coregraphics.m

 	return rv;
 }
 
+#if PyObjC_BUILD_RELEASE >= 1006
+static void
+m_releasecallback(void* releaseInfo, void* data)
+{
+	PyObject* py_data = (PyObject*)releaseInfo;
+
+	PyGILState_STATE   state = PyGILState_Ensure();
+
+	if (PyTuple_GET_ITEM(releaseInfo, 0) != Py_None) {
+		PyObject* r = PyObject_CallFunction(
+			PyTuple_GET_ITEM(py_data, 0), "OO",
+			PyTuple_GET_ITEM(py_data, 1),
+			PyTuple_GET_ITEM(py_data, 2));
+		Py_XDECREF(r);
+	}
+
+	Py_DECREF(py_data);
+
+	if (PyErr_Occurred()) {
+		PyObjCErr_ToObjCWithGILState(&state);
+	}
+	PyGILState_Release(state);
+
+}
+
+static PyObject*
+m_CGBitmapContextCreateWithData(PyObject* self __attribute__((__unused__)), 
+		PyObject* args)
+{
+	PyObject* py_data;
+	PyObject* py_width;
+	PyObject* py_height;
+	PyObject* py_bitsPerComponent;
+	PyObject* py_bytesPerRow;
+	PyObject* py_colorSpace;
+	PyObject* py_bitmapInfo;
+	PyObject* py_releaseCallback;
+	PyObject* py_releaseInfo;
+
+	void*	data;
+	size_t  width;
+	size_t  height;
+	size_t  bitsPerComponent;
+	size_t  bytesPerRow;
+	CGColorSpaceRef colorSpace;
+	CGBitmapInfo bitmapInfo;
+
+	if (!PyArg_ParseTuple(args, "OOOOOOOOO", 
+		&py_data, &py_width, &py_height, &py_bitsPerComponent, 
+		&py_bytesPerRow, &py_colorSpace, &py_bitmapInfo,
+		&py_releaseCallback, &py_releaseInfo
+		)) {
+		return NULL;
+	}
+
+	if (PyObjC_PythonToObjC(@encode(size_t), py_width, &width) == -1) {
+		return NULL;
+	}
+	if (PyObjC_PythonToObjC(@encode(size_t), py_height, &height) == -1) {
+		return NULL;
+	}
+	if (PyObjC_PythonToObjC(@encode(size_t), py_bitsPerComponent, &bitsPerComponent) == -1) {
+		return NULL;
+	}
+	if (PyObjC_PythonToObjC(@encode(size_t), py_bytesPerRow, &bytesPerRow) == -1) {
+		return NULL;
+	}
+	if (PyObjC_PythonToObjC(@encode(CGColorSpaceRef), py_colorSpace, &colorSpace) == -1) {
+		return NULL;
+	}
+	if (PyObjC_PythonToObjC(@encode(CGBitmapInfo), py_bitmapInfo, &bitmapInfo) == -1) {
+		return NULL;
+	}
+
+	if (py_data == Py_None) {
+		data = NULL;
+
+	} else if (PyUnicode_Check(py_data)) {
+		PyErr_SetString(PyExc_TypeError, "Cannot use Unicode as backing store");
+		return NULL;
+
+	} else {
+		Py_ssize_t size;
+
+		if (PyObject_AsWriteBuffer(py_data, &data, &size) == -1) {
+			return NULL;
+		}
+	}
+
+	PyObject* releaseInfo = PyTuple_New(3);
+	if (releaseInfo == NULL) {
+		return NULL;
+	}
+	PyTuple_SET_ITEM(releaseInfo, 0, py_releaseCallback);
+	Py_INCREF(py_releaseCallback);
+	PyTuple_SET_ITEM(releaseInfo, 1, py_releaseInfo);
+	Py_INCREF(py_releaseInfo);
+	PyTuple_SET_ITEM(releaseInfo, 2, py_data);
+	Py_INCREF(py_data);
+
+
+	CGContextRef ctx = NULL;
+	PyObjC_DURING
+		ctx = CGBitmapContextCreateWithData(data, width, height, bitsPerComponent, bytesPerRow, colorSpace, bitmapInfo, m_releasecallback, releaseInfo);
+
+	PyObjC_HANDLER
+		ctx = NULL;
+		PyObjCErr_FromObjC(localException);
+	PyObjC_ENDHANDLER
+
+	if (ctx == NULL && PyErr_Occurred()) {
+		Py_DECREF(releaseInfo);
+		return NULL;
+	}
+
+	if (ctx == NULL)  {
+		Py_DECREF(releaseInfo);
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
+
+	PyObject* rv = PyObjC_ObjCToPython(@encode(CGContextRef), &ctx);
+	CFRelease(ctx);
+	return rv;
+}
+#endif
+
 
 static PyMethodDef mod_methods[] = {
 #if PyObjC_BUILD_RELEASE >= 1005
 		METH_VARARGS,
 		NULL
 	},
+#if PyObjC_BUILD_RELEASE >= 1006
+	{
+		"CGBitmapContextCreateWithData",
+		(PyCFunction)m_CGBitmapContextCreateWithData,
+		METH_VARARGS,
+		NULL
+	},
+#endif
 
 
 	{ 0, 0, 0, }

File pyobjc-framework-Quartz/PyObjCTest/test_cgbitmapcontext.py

 
 
     def testFunctions106_(self):
-        self.fail("CGBitmapContextCreateWithData: manual wrapper")
+        bytes_val = array.array('B', (0 for i in xrange(100*80*4)))
+        ctx = CGBitmapContextCreateWithData(bytes_val, 100, 80, 8, 400, CGColorSpaceCreateDeviceRGB(), kCGImageAlphaPremultipliedLast, None, None)
+        self.assertIsInstance(ctx, CGContextRef)
+        del ctx
+
+        list = []
+        release_info = object()
+        def callback(info, data):
+            list.append((info, data))
+
+        ctx = CGBitmapContextCreateWithData(bytes_val, 100, 80, 8, 400, CGColorSpaceCreateDeviceRGB(), kCGImageAlphaPremultipliedLast, callback, release_info)
+        self.assertIsInstance(ctx, CGContextRef)
+        del ctx
+
+        self.assertEquals(len(list), 1)
+        self.assertIs(list[0][0], release_info)
+        self.assertIs(list[0][1], bytes_val)
 
 
 if __name__ == "__main__":

File pyobjc-framework-Quartz/PyObjCTest/test_cgcontext.py

             if os.path.exists("/tmp/pyobjc.test.pdf"):
                 os.unlink("/tmp/pyobjc.test.pdf")
 
-    def testMissing(self):
-        self.fail("CGContextShowGlyphsAtPositions")
-        self.fail("CGContextShowGlyphs")
-        self.fail("CGContextShowGlyphsAtPoint")
-        self.fail("CGContextShowGlyphsWithAdvances")
-        self.fail("CGContextDrawPDFPage")
-        self.fail("CGContextDrawPDFDocument")
+    def testGlyphFunctions(self):
+        self.assertArgHasType(CGContextShowGlyphsAtPositions, 1, 'n^S')
+        self.assertArgSizeInArg(CGContextShowGlyphsAtPositions, 1, 3)
+        self.assertArgHasType(CGContextShowGlyphsAtPositions, 2, 'n^' + CGPoint.__typestr__)
+        self.assertArgSizeInArg(CGContextShowGlyphsAtPositions, 2, 3)
+
+        self.assertArgHasType(CGContextShowGlyphs, 1, 'n^S')
+        self.assertArgSizeInArg(CGContextShowGlyphs, 1, 2)
+
+        self.assertArgHasType(CGContextShowGlyphsAtPoint, 1, objc._C_CGFloat)
+        self.assertArgHasType(CGContextShowGlyphsAtPoint, 2, objc._C_CGFloat)
+        self.assertArgHasType(CGContextShowGlyphsAtPoint, 3, 'n^S')
+        self.assertArgSizeInArg(CGContextShowGlyphsAtPoint, 3, 4)
+
+        self.assertArgHasType(CGContextShowGlyphsWithAdvances, 1, 'n^S')
+        self.assertArgSizeInArg(CGContextShowGlyphsWithAdvances, 1, 3)
+        self.assertArgHasType(CGContextShowGlyphsWithAdvances, 2, 'n^' + CGSize.__typestr__)
+        self.assertArgSizeInArg(CGContextShowGlyphsWithAdvances, 2, 3)
+
+        self.assertArgHasType(CGContextDrawPDFPage, 0, '^{CGContext=}')
+        self.assertArgHasType(CGContextDrawPDFPage, 1, '^{CGPDFPage=}')
+
+        self.assertArgHasType(CGContextDrawPDFDocument, 0, '^{CGContext=}')
+        self.assertArgHasType(CGContextDrawPDFDocument, 1, CGRect.__typestr__)
+        self.assertArgHasType(CGContextDrawPDFDocument, 2, '^{CGPDFDocument=}')
+        self.assertArgHasType(CGContextDrawPDFDocument, 3, objc._C_INT)
 
 
     @min_os_level('10.5')

File pyobjc-framework-Quartz/PyObjCTest/test_cgevent.py

         self.assertIsCFType(CGEventRef)
         self.assertIsCFType(CGEventSourceRef)
 
-    def testMissing(self):
+    def testEventFunctions(self):
         evt = CGEventCreateMouseEvent(None, kCGEventLeftMouseDown, (80, 90), kCGMouseButtonLeft)
         self.assertIsInstance(evt, CGEventRef)
 
 
         CGEventSetDoubleValueField(evt, kCGMouseEventPressure, 42.5)
 
+        self.assertArgHasType(CGEventTapEnable, 0, '^{__CFMachPort=}')
+        self.assertArgHasType(CGEventTapEnable, 1, objc._C_BOOL)
+
+        self.assertResultHasType(CGEventTapIsEnabled, objc._C_BOOL)
+        self.assertArgHasType(CGEventTapIsEnabled, 0, '^{__CFMachPort=}')
+
+        self.assertArgHasType(CGEventTapPostEvent, 0, '^{__CGEventTapProxy=}')
+        self.assertArgHasType(CGEventTapPostEvent, 1, '^{__CGEvent=}')
+
+        self.assertResultHasType(CGGetEventTapList, objc._C_INT)
+        self.assertArgHasType(CGGetEventTapList, 0, objc._C_UINT)
+        self.assertArgHasType(CGGetEventTapList, 1, 'o^' + CGEventTapInformation.__typestr__)
+        self.assertArgSizeInArg(CGGetEventTapList, 1, (0, 2))
+        self.assertArgHasType(CGGetEventTapList, 2, 'o^' + objc._C_UINT)
+
+        self.assertResultHasType(CGEventPost, objc._C_VOID)
+        self.assertArgHasType(CGEventPost, 0, objc._C_UINT)
+        self.assertArgHasType(CGEventPost, 1, '^{__CGEvent=}')
+
+        self.assertResultHasType(CGEventPostToPSN, objc._C_VOID)
+        self.assertArgHasType(CGEventPostToPSN, 0, 'n^{ProcessSerialNumber=II}')
+        self.assertArgHasType(CGEventPostToPSN, 1, '^{__CGEvent=}')
+
+
+    @expectedFailure
+    def testMissing(self):
         self.fail("CGEventTapCreateForPSN")
-        self.fail("CGEventTapEnable")
-        self.fail("CGEventTapIsEnabled")
-        self.fail("CGEventTapPostEvent")
-        self.fail("CGGetEventTapList")
-        self.fail("CGEventPost")
-        self.fail("CGEventPostToPSN")
 
 
     def testFunctions(self):

File pyobjc-framework-Quartz/PyObjCTest/test_qcplugin.py

 from PyObjCTools.TestSupport import *
 from Quartz.QuartzComposer import *
 
-
 class TestQCPlugIn (TestCase):
     @min_os_level('10.5')
     def testConstants10_5(self):
         self.assertResultIsBOOL(QCPlugIn.setValue_forOutputKey_)
         self.assertResultIsBOOL(QCPlugIn.loadPlugInAtPath_)
 
+    @expectedFailure
     def testProtocols(self):
         self.fail("Test interface for QCPlugInContext")
 

File pyobjc-framework-Quartz/setup.py

 
 WARNING: Running the unittests will change your display settings during the
 testrun, which will probably mess up your window layout.
+
+NEWS
+====
+
+2.4
+---
+
+* Add wrapper for ``CGBitmapContextCreateWithData``
+
 '''
 
 from pyobjc_setup import setup, Extension