pyobjc-core 12.0__tar.gz → 12.2__tar.gz

{pyobjc_core-12.0 → pyobjc_core-12.2}/Lib/PyObjCTools/TestSupport.py

@@ -29,9 +29,7 @@ _usepool = not _os.environ.get("PYOBJC_NO_AUTORELEASE")
 
 
 def _typemap(tp):
-    if isinstance(tp, tuple):
-        return tuple(_typemap(x) for x in tp)
-    elif tp is None:
+    if tp is None:
         return None
     return (
         tp.replace(b"_NSRect", b"CGRect")
@@ -499,6 +497,21 @@ class TestCase(_unittest.TestCase):
                 or "argument %d of %r is not a null-terminated array" % (argno, method)
             )
 
+    def assertArgIsNotNullTerminated(self, method, argno, message=None):
+        if isinstance(method, objc.selector):
+            offset = 2
+        else:
+            offset = 0
+        info = method.__metadata__()
+        try:
+            if info["arguments"][argno + offset].get("c_array_delimited_by_null"):
+                self.fail(
+                    message
+                    or "argument %d of %r is a null-terminated array" % (argno, method)
+                )
+        except (KeyError, IndexError):
+            pass
+
     def assertArgIsVariableSize(self, method, argno, message=None):
         if isinstance(method, objc.selector):
             offset = 2
@@ -542,6 +555,21 @@ class TestCase(_unittest.TestCase):
                 or "argument %d of %r does not have size in result" % (argno, method)
             )
 
+    def assertArgSizeNotInResult(self, method, argno, message=None):
+        if isinstance(method, objc.selector):
+            offset = 2
+        else:
+            offset = 0
+        info = method.__metadata__()
+        try:
+            if info["arguments"][argno + offset].get("c_array_length_in_result"):
+                self.fail(
+                    message
+                    or "argument %d of %r does have size in result" % (argno, method)
+                )
+        except (KeyError, IndexError):
+            pass
+
     def assertArgIsPrintf(self, method, argno, message=None):
         if isinstance(method, objc.selector):
             offset = 2
@@ -563,6 +591,24 @@ class TestCase(_unittest.TestCase):
                 or "%r argument %d is not a printf format string" % (method, argno)
             )
 
+    def assertArgIsNotPrintf(self, method, argno, message=None):
+        if isinstance(method, objc.selector):
+            offset = 2
+        else:
+            offset = 0
+        info = method.__metadata__()
+        if not info.get("variadic"):
+            self.fail(message or f"{method!r} is not a variadic function")
+
+        try:
+            if info["arguments"][argno + offset].get("printf_format"):
+                self.fail(
+                    message
+                    or "%r argument %d is a printf format string" % (method, argno)
+                )
+        except (KeyError, IndexError):
+            pass
+
     def assertArgIsCFRetained(self, method, argno, message=None):
         if isinstance(method, objc.selector):
             offset = 2
@@ -675,8 +721,8 @@ class TestCase(_unittest.TestCase):
             for item in tp:
                 if (
                     typestr == item
-                    or _typemap(typestr) == _typemap(tp)
-                    or _typealias.get(typestr, typestr) == _typealias.get(tp, tp)
+                    or _typemap(typestr) == _typemap(item)
+                    or _typealias.get(typestr, typestr) == _typealias.get(item, item)
                 ):
                     break
             else:
@@ -717,8 +763,8 @@ class TestCase(_unittest.TestCase):
             for item in tp:
                 if (
                     typestr == item
-                    or _typemap(typestr) == _typemap(tp)
-                    or _typealias.get(typestr, typestr) == _typealias.get(tp, tp)
+                    or _typemap(typestr) == _typemap(item)
+                    or _typealias.get(typestr, typestr) == _typealias.get(item, item)
                 ):
                     break
             else:
@@ -1302,9 +1348,14 @@ class TestCase(_unittest.TestCase):
 
         if exclude_cocoa:
             try:
-                import Cocoa
+                if "AppKit" in _sys.modules:
+                    import AppKit
 
-                exclude_names = set(dir(Cocoa))
+                    exclude_names = set(dir(AppKit))
+                else:
+                    import Foundation
+
+                    exclude_names = set(dir(Foundation))
 
                 # Don't exclude NSObject' because a number
                 # of frameworks define categories on this class.
@@ -1383,65 +1434,339 @@ class TestCase(_unittest.TestCase):
         exclude_attrs.add("AudioObjectPropertiesChanged")
         exclude_attrs.add("AudioObjectsPublishedAndDied")
 
+        # Private classes in various frameworks
+        exclude_attrs.add("ACTrackedXPCConnection")
+        exclude_attrs.add("ACZeroingString")
+        exclude_attrs.add("AFBArray")
+        exclude_attrs.add("AFBBufferBuilder")
+        exclude_attrs.add("AFBDictionary")
+        exclude_attrs.add("AFConversationError")
+        exclude_attrs.add("AFInstanceContext")
+        exclude_attrs.add("AFInstanceContextHost")
+        exclude_attrs.add("AFKBufferMemoryDescriptor")
+        exclude_attrs.add("AFKEndpointInterface")
+        exclude_attrs.add("AFKMemoryDescriptor")
+        exclude_attrs.add("AFMyriadAccessoryMetricMessage")
+        exclude_attrs.add("AFPreferences")
+        exclude_attrs.add("AFSUPFunctionProvider")
+        exclude_attrs.add("AFSpeakableUtteranceParser")
+        exclude_attrs.add("AKAppleIDSession")
+        exclude_attrs.add("AWDLTrafficRegistrationConfiguration")
+        exclude_attrs.add("AXLogColorizer")
+        exclude_attrs.add("AXValidationManager")
+        exclude_attrs.add("BroadcomHostController")
+        exclude_attrs.add("CBDevice")
+        exclude_attrs.add("CKAssetDownloadStagingManager")
+        exclude_attrs.add("CKBehaviorOptions")
+        exclude_attrs.add("CKInternalError")
+        exclude_attrs.add("CKObjCType")
+        exclude_attrs.add("CKPrettyError")
+        exclude_attrs.add("CKSQLiteCompiledStatementDecoder")
+        exclude_attrs.add("CKSQLiteDatabaseKeyedArchiver")
+        exclude_attrs.add("CKSQLiteDatabaseKeyedUnarchiver")
+        exclude_attrs.add("CKSQLiteTOCImageInfoEntry")
+        exclude_attrs.add("CKSyncEngineState")
+        exclude_attrs.add("CKUserDefaults")
+        exclude_attrs.add("CLAssertion")
+        exclude_attrs.add("CLBBTimeFreqTransferCallbackAssertion")
+        exclude_attrs.add("CLEEDMitigation")
+        exclude_attrs.add("CLEmergencyClientEnablementAssertion")
+        exclude_attrs.add("CLEmergencyEnablementAssertion")
+        exclude_attrs.add("CLFindMyAccessoryManager")
+        exclude_attrs.add("CLGNSSStateQueryAssertionResponse")
+        exclude_attrs.add("CLGnssDisablementAssertion")
+        exclude_attrs.add("CLGnssExtensionsClient")
+        exclude_attrs.add("CLIntersiloProxy")
+        exclude_attrs.add("CLIntersiloProxyToInitiator")
+        exclude_attrs.add("CLIntersiloProxyToRecipient")
+        exclude_attrs.add("CLLocationInternalClient")
+        exclude_attrs.add("CLLocationManagerStateTracker")
+        exclude_attrs.add("CLLocationUpdater")
+        exclude_attrs.add("CLOSTransaction")
+        exclude_attrs.add("CLStateTracker")
+        exclude_attrs.add("CRBiDiTransform")
+        exclude_attrs.add("CRImage")
+        exclude_attrs.add("CRImage_PixelBuffer")
+        exclude_attrs.add("CSUError")
+        exclude_attrs.add("CUDashboardClient")
+        exclude_attrs.add("CUICommonAssetStorage")
+        exclude_attrs.add("CUIMaskedFacetLayer")
+        exclude_attrs.add("CUIMutableCommonAssetStorage")
+        exclude_attrs.add("CUIMutablePSDImageRef")
+        exclude_attrs.add("CUIMutableStructuredThemeStore")
+        exclude_attrs.add("CUIPSDImageRef")
+        exclude_attrs.add("CUIPSDLayerRef")
+        exclude_attrs.add("CUIPlaceholderCUICommonAssetStorage")
+        exclude_attrs.add("CUIPlaceholderCUIMutableCommonAssetStorage")
+        exclude_attrs.add("CUISingleNamedAssetMutableStorage")
+        exclude_attrs.add("CUIStructuredThemeStore")
+        exclude_attrs.add("CUISystemStore")
+        exclude_attrs.add("CUNANEndpoint")
+        exclude_attrs.add("CUReadRequest")
+        exclude_attrs.add("CUSPAKECommon")
+        exclude_attrs.add("CUSPAKEProver")
+        exclude_attrs.add("CUSPAKEVerifier")
+        exclude_attrs.add("CUWriteRequest")
+        exclude_attrs.add("CWFNetworkProfile")
+        exclude_attrs.add("CoreUtilsNSSubrangeData")
+        exclude_attrs.add("DDScannerResult")
+        exclude_attrs.add("DMAPFS")
+        exclude_attrs.add("DMCoreStorage")
+        exclude_attrs.add("DMFilesystem")
+        exclude_attrs.add("DMManager")
+        exclude_attrs.add("EFILWLogging")
+        exclude_attrs.add("FLSQLitePersistence")
+        exclude_attrs.add("FPAppLibraryCollection")
+        exclude_attrs.add("FPCTLTermDumper")
+        exclude_attrs.add("FPError")
+        exclude_attrs.add("FPExtensionCollection")
+        exclude_attrs.add("FPFlattenedPackageSandboxingURLWrapper")
+        exclude_attrs.add("FPItemCollection")
+        exclude_attrs.add("FPQueryCollection")
+        exclude_attrs.add("FPSandboxingURLWrapper")
+        exclude_attrs.add("FPSearchCollection")
+        exclude_attrs.add("FPSearchTrashCollection")
+        exclude_attrs.add("FPTask")
+        exclude_attrs.add("FPTrashUnionCollection")
+        exclude_attrs.add("FPUnarchiveOperation")
+        exclude_attrs.add("FPUnionCollection")
+        exclude_attrs.add("FaceCoreImage")
+        exclude_attrs.add("GEOActiveTileGroup")
+        exclude_attrs.add("GEOBrandInfoMapping")
+        exclude_attrs.add("GEODaemon")
+        exclude_attrs.add("GEOFeature")
+        exclude_attrs.add("GEOMapItemURLExtras")
+        exclude_attrs.add("GEOPDTransitIncident")
+        exclude_attrs.add("GEOPerformanceEventLogger")
+        exclude_attrs.add("GEOPurgableFile")
+        exclude_attrs.add("GEORegionalResourceTileDecoder")
+        exclude_attrs.add("GEOSQLiteDB")
+        exclude_attrs.add("GEOTileEditionUpdate")
+        exclude_attrs.add("GEOVectorTile")
+        exclude_attrs.add("GEOVectorTileDecoder")
+        exclude_attrs.add("HardcopyCableReplacement")
+        exclude_attrs.add("ICREnvironment")
+        exclude_attrs.add("IDSDatagramChannel")
+        exclude_attrs.add("IDSDependencyProvider")
+        exclude_attrs.add("IDSDirectMessageConnection")
+        exclude_attrs.add("IDSGlobalLinkMessage")
+        exclude_attrs.add("IDSInterfaceAddress")
+        exclude_attrs.add("IDSInternalQueueController")
+        exclude_attrs.add("IDSNWPathUtils")
+        exclude_attrs.add("IDSRateLimiter")
+        exclude_attrs.add("IDSStunMessage")
+        exclude_attrs.add("IDSStunRelayInterfaceInfoController")
+        exclude_attrs.add("IDSTCPLink")
+        exclude_attrs.add("IMFileManager")
+        exclude_attrs.add("INDeferredLocalizedString")
+        exclude_attrs.add("IOBluetoothHardcopyCableReplacement")
+        exclude_attrs.add("IOBluetoothHeadsetAudioGateway")
+        exclude_attrs.add("IOBluetoothLocalSDPServiceRecord")
+        exclude_attrs.add("IOBluetoothOBEXSession")
+        exclude_attrs.add("IOBluetoothSDPDataElement")
+        exclude_attrs.add("IOBluetoothSDPServiceRecord")
+        exclude_attrs.add("IOBluetoothSDPUUID")
+        exclude_attrs.add("IOBluetoothSerialPortManager")
+        exclude_attrs.add("ISCompositor")
+        exclude_attrs.add("ISIcns")
+        exclude_attrs.add("ISMutableIcns")
+        exclude_attrs.add("KCAESGCMDuplexSession")
+        exclude_attrs.add("KCPairingChannel")
+        exclude_attrs.add("KCSRPClientContext")
+        exclude_attrs.add("KCSRPContext")
+        exclude_attrs.add("KCSRPServerContext")
+        exclude_attrs.add("LACACMHelper")
+        exclude_attrs.add("LACBiometryHelper")
+        exclude_attrs.add("LACDeviceTreeReader")
+        exclude_attrs.add("LACLocalizationUtils")
+        exclude_attrs.add("LAErrorHelper")
+        exclude_attrs.add("MLE5InputPort")
+        exclude_attrs.add("MLE5InputPortBinder")
+        exclude_attrs.add("MLE5OutputPort")
+        exclude_attrs.add("MLE5OutputPortBinder")
+        exclude_attrs.add("MLItemSimilarityRecommender")
+        exclude_attrs.add("MLLoaderEvent")
+        exclude_attrs.add("MLModelAsset")
+        exclude_attrs.add("MLMultiArrayAsNSArrayWrapper")
+        exclude_attrs.add("MLNeuralNetworkEngine")
+        exclude_attrs.add("MLNeuralNetworkMLComputeUpdateEngine")
+        exclude_attrs.add("MLNeuralNetworkUpdateEngine")
+        exclude_attrs.add("MLNeuralNetworkV1Engine")
+        exclude_attrs.add("MLProbabilityDictionary")
+        exclude_attrs.add("MLProgramEngine")
+        exclude_attrs.add("MLSequnceAsFeatureValueArray")
+        exclude_attrs.add("MLTreeEnsembleClassifier")
+        exclude_attrs.add("MLTreeEnsembleRegressor")
+        exclude_attrs.add("MSVDefaultDictionary")
+        exclude_attrs.add("MSVOPACKDecoder")
+        exclude_attrs.add("MSVOPACKEncoder")
+        exclude_attrs.add("MSVSegmentedDecoder")
+        exclude_attrs.add("MSVSegmentedEncoder")
+        exclude_attrs.add("MSVXPCConnection")
+        exclude_attrs.add("NSAttributeDictionary")
+        exclude_attrs.add("NSCTFont")
+        exclude_attrs.add("NSCoreTypesetter")
+        exclude_attrs.add("NSDocFormatReader")
+        exclude_attrs.add("NSSingleLineTypesetter")
+        exclude_attrs.add("NSTempAttributeDictionary")
+        exclude_attrs.add("OBEXFilePut")
+        exclude_attrs.add("OBEXSession")
+        exclude_attrs.add("OTInheritanceKey")
+        exclude_attrs.add("PCLog")
+        exclude_attrs.add("SASampleStore")
+        exclude_attrs.add("SATask")
+        exclude_attrs.add("SCDAAccessoryMetricMessage")
+        exclude_attrs.add("SFBLEScanner")
+        exclude_attrs.add("SFCollaborationUtilities")
+        exclude_attrs.add("SFFeatureFlagAdaptor")
+        exclude_attrs.add("SFService")
+        exclude_attrs.add("SFServiceSession")
+        exclude_attrs.add("SFSession")
+        exclude_attrs.add("SSInflightCAMetalLayerIntervalStats")
+        exclude_attrs.add("SignpostIntervalBuilder")
+        exclude_attrs.add("SiriAnalyticsError")
+        exclude_attrs.add("TIHardwareKeyboardLayout")
+        exclude_attrs.add("TIKeyboardCandidateResultSetCoder")
+        exclude_attrs.add("TIKeyboardLayout")
+        exclude_attrs.add("TIKeyedArchiver")
+        exclude_attrs.add("TIKeyedUnarchiver")
+        exclude_attrs.add("TKBERTLVRecord")
+        exclude_attrs.add("TKDataSource")
+        exclude_attrs.add("TKSmartCardATRInterfaceGroup")
+        exclude_attrs.add("TKSmartCardWithError")
+        exclude_attrs.add("TKTokenID")
+        exclude_attrs.add("TRICCommandRunner")
+        exclude_attrs.add("TRICEnvironmentManager")
+        exclude_attrs.add("TRIFBCloudKitTreatmentRecordAsset")
+        exclude_attrs.add("TRIFBFactorLevel")
+        exclude_attrs.add("TRIFBFactorMetadataKeyValue")
+        exclude_attrs.add("TRIFBFastFactorLevels")
+        exclude_attrs.add("TRIFBMobileAssetReference")
+        exclude_attrs.add("TRIFBTrialManagedAsset")
+        exclude_attrs.add("TRILevel")
+        exclude_attrs.add("TRINamespaceResolver")
+        exclude_attrs.add("TRIPBAutocreatedArray")
+        exclude_attrs.add("TRIPBAutocreatedDictionary")
+        exclude_attrs.add("TRIPBBoolArray")
+        exclude_attrs.add("TRIPBBoolBoolDictionary")
+        exclude_attrs.add("TRIPBBoolDoubleDictionary")
+        exclude_attrs.add("TRIPBBoolEnumDictionary")
+        exclude_attrs.add("TRIPBBoolFloatDictionary")
+        exclude_attrs.add("TRIPBBoolInt32Dictionary")
+        exclude_attrs.add("TRIPBBoolInt64Dictionary")
+        exclude_attrs.add("TRIPBBoolObjectDictionary")
+        exclude_attrs.add("TRIPBBoolUInt32Dictionary")
+        exclude_attrs.add("TRIPBBoolUInt64Dictionary")
+        exclude_attrs.add("TRIPBDescriptor")
+        exclude_attrs.add("TRIPBEnumDescriptor")
+        exclude_attrs.add("TRIPBExtensionDescriptor")
+        exclude_attrs.add("TRIPBInt32BoolDictionary")
+        exclude_attrs.add("TRIPBInt64BoolDictionary")
+        exclude_attrs.add("TRIPBOneofDescriptor")
+        exclude_attrs.add("TRIPBStringBoolDictionary")
+        exclude_attrs.add("TRIPBUInt32BoolDictionary")
+        exclude_attrs.add("TRIPBUInt64BoolDictionary")
+        exclude_attrs.add("TSPSaveMeasurements")
+        exclude_attrs.add("TTSRegex")
+        exclude_attrs.add("TTSUnicodeUtils")
+        exclude_attrs.add("UAFAssetExpansion")
+        exclude_attrs.add("UAFAssetSetManager")
+        exclude_attrs.add("UAFAutoAssetManager")
+        exclude_attrs.add("UAFAutoAssetSet")
+        exclude_attrs.add("UAFCommonUtilities")
+        exclude_attrs.add("UAFSubscriptionStoreManager")
+        exclude_attrs.add("UIFont")
+        exclude_attrs.add("UINibDecoder")
+        exclude_attrs.add("UINibEncoder")
+        exclude_attrs.add("UNLocalizedString")
+        exclude_attrs.add("UNSecurityScopedURL")
+        exclude_attrs.add("UserRegistryDB")
+        exclude_attrs.add("VNCCCharBoxContext")
+        exclude_attrs.add("VNCCTextDetector")
+        exclude_attrs.add("VNDisallowedList")
+        exclude_attrs.add("VNEspressoModelClassifier")
+        exclude_attrs.add("VNFingerprintHash")
+        exclude_attrs.add("VNPersonSegmentationGeneratorFast")
+        exclude_attrs.add("VNPersonSegmentationGeneratorInstanceBased4People")
+        exclude_attrs.add("VNPersonSegmentationGeneratorLearnedMatting")
+        exclude_attrs.add("VNPersonSegmentationGeneratorLearnedMattingTiled")
+        exclude_attrs.add("VNPersonSegmentationGeneratorSemantics")
+        exclude_attrs.add("VNSegmentationGenerator")
+        exclude_attrs.add("VNSmartCamClassifier")
+        exclude_attrs.add("VNValidationUtilities")
+        exclude_attrs.add("VisionCoreMetalContext")
+        exclude_attrs.add("WiFiAwareDiscoveryResult")
+        exclude_attrs.add("WiFiP2PXPCConnection")
+        exclude_attrs.add("geo_isolater")
+        exclude_attrs.add("geo_reentrant_isolater")
+        exclude_attrs.add(
+            ("CWInterface", "twoGHzChainDisabledAndReturnReassocRequired_error_")
+        )
+        exclude_attrs.add(
+            ("IOBluetoothDevice", "getRemoteVersionInfo_lmpVersion_lmpSubversion_")
+        )
+        exclude_attrs.add(("IOBluetoothHandsFree", "processIncomingData_length_"))
+        exclude_attrs.add(
+            ("IOBluetoothHandsFreeAudioGateway", "processIncomingData_length_")
+        )
+        exclude_attrs.add(("IOBluetoothHandsFreeDevice", "processIncomingData_length_"))
+        exclude_attrs.add(("IOBluetoothHandsFreeDevice", "saveToFile_bufferSize_"))
+        exclude_attrs.add(
+            ("IOBluetoothHostController", "getPropertyObjectFromIOServiceNamed_forKey_")
+        )
+        exclude_attrs.add(
+            (
+                "IOBluetoothHostController",
+                "readVerboseConfigVersionInfo_outTargetID_outBaseline_outBuild_",
+            )
+        )
+        exclude_attrs.add(
+            (
+                "NSFileProviderManager",
+                "checkDomainsCanBeStored_onVolumeAtURL_unsupportedReason_error_",
+            )
+        )
+        exclude_attrs.add(
+            (
+                "TKSmartCard",
+                "buildIns_p1_p2_data_range_le_protocol_chained_extended_realLe_",
+            )
+        )
+
         # Calculate all (interesting) names in the module. This pokes into
         # the implementation details of objc.ObjCLazyModule to avoid loading
         # all attributes (which is expensive for larger bindings).
-        if isinstance(module, objc.ObjCLazyModule):
+        def is_pyobjc_lazy(module):
+            getter = getattr(module, "__getattr__", None)
+            if getter is None:
+                return False
+            return hasattr(getter, "_pyobjc_parents")
+
+        if is_pyobjc_lazy(module):
+            getter = getattr(module, "__getattr__", None)
             module_names = []
             module_names.extend(
                 cls.__name__
                 for cls in objc.getClassList(True)
                 if (not cls.__name__.startswith("_")) and ("." not in cls.__name__)
             )
-            module_names.extend(module._ObjCLazyModule__funcmap or [])
-            module_names.extend(module.__dict__.keys())
-            todo = list(module._ObjCLazyModule__parents or [])
+            module_names.extend(getattr(getter, "_pyobjc_funcmap", None) or [])
+            todo = list(getter._pyobjc_parents)
             while todo:
                 parent = todo.pop()
-                if isinstance(parent, objc.ObjCLazyModule):
-                    module_names.extend(parent._ObjCLazyModule__funcmap or ())
-                    todo.extend(parent._ObjCLazyModule__parents or ())
+                if is_pyobjc_lazy(parent):
+                    getter = getattr(parent, "__getattr__", None)
+                    module_names.extend(getattr(getter, "_pyobjc_funcmap", None) or [])
+                    todo.extend(getter._pyobjc_parents or ())
                     module_names.extend(parent.__dict__.keys())
+
                 else:
                     module_names.extend(dir(parent))
 
-            # The module_names list might contain duplicates
             module_names = sorted(set(module_names))
-        else:
-
-            def is_pyobjc_lazy(module):
-                getter = getattr(module, "__getattr__", None)
-                if getter is None:
-                    return False
-                return hasattr(getter, "_pyobjc_parents")
-
-            if is_pyobjc_lazy(module):
-                getter = getattr(module, "__getattr__", None)
-                module_names = []
-                module_names.extend(
-                    cls.__name__
-                    for cls in objc.getClassList(True)
-                    if (not cls.__name__.startswith("_")) and ("." not in cls.__name__)
-                )
-                module_names.extend(getattr(getter, "_pyobjc_funcmap", None) or [])
-                todo = list(getter._pyobjc_parents)
-                while todo:
-                    parent = todo.pop()
-                    if is_pyobjc_lazy(parent):
-                        getter = getattr(parent, "__getattr__", None)
-                        module_names.extend(
-                            getattr(getter, "_pyobjc_funcmap", None) or []
-                        )
-                        todo.extend(getter._pyobjc_parents or ())
-                        module_names.extend(parent.__dict__.keys())
-
-                    else:
-                        module_names.extend(dir(parent))
 
-                module_names = sorted(set(module_names))
-
-            else:
-                module_names = sorted(set(dir(module)))
+        else:
+            module_names = sorted(set(dir(module)))
 
         for _idx, nm in enumerate(module_names):
             # print(f"{_idx}/{len(module_names)} {nm}")
@@ -1452,18 +1777,16 @@ class TestCase(_unittest.TestCase):
 
             try:
                 value = getattr(module, nm)
-            except AttributeError:
-                continue
+            except AttributeError:  # pragma: no cover
+                continue  # pragma: no cover
             if isinstance(value, objc.objc_class):
                 with objc.autorelease_pool():
                     if value.__name__ == "Object":
                         # Root class, does not conform to the NSObject
                         # protocol and useless to test.
                         continue
-                    for (
-                        attr_name,
-                        attr,
-                    ) in value.pyobjc_instanceMethods.__dict__.items():
+                    instanceMethodDict = value.pyobjc_instanceMethods.__dict__
+                    for attr_name, attr in instanceMethodDict.items():
                         if attr_name in exclude_method_names:
                             continue
                         if (nm, attr_name) in exclude_attrs:
@@ -1472,6 +1795,12 @@ class TestCase(_unittest.TestCase):
                             # Skip private names
                             continue
 
+                        if value.__name__ == "IOBluetoothHostController" and any(
+                            attr_name.startswith(pfx)
+                            for pfx in ("Bluetooth", "Broadcom")
+                        ):
+                            continue
+
                         with self.subTest(classname=nm, instance_method=attr_name):
                             if isinstance(attr, objc.selector):  # pragma: no branch
                                 self._validateCallableMetadata(
@@ -1481,8 +1810,8 @@ class TestCase(_unittest.TestCase):
                                 )
 
                     for attr_name, attr in value.pyobjc_classMethods.__dict__.items():
-                        if attr_name in exclude_method_names:
-                            continue
+                        if attr_name in exclude_method_names:  # pragma: no branch
+                            continue  # pragma: no cover
                         if (nm, attr_name) in exclude_attrs:
                             continue
                         if attr_name.startswith("_"):

{pyobjc_core-12.0 → pyobjc_core-12.2}/Lib/objc/_bridges.py

@@ -1,6 +1,7 @@
 import collections.abc
 import datetime
 import pathlib
+import numbers
 
 from objc import _objc
 
@@ -10,6 +11,7 @@ __all__ = [
     "registerSetType",
     "registerDateType",
     "registerPathType",
+    "registerNumberType",
 ]
 
 _objc.options._datetime_date_type = datetime.date
@@ -56,6 +58,14 @@ def registerPathType(type_object):
     _objc.options._path_types += (type_object,)
 
 
+def registerNumberType(type_object):
+    """
+    Register 'type' as a date-like type that will be proxied
+    as an NSDate subclass.
+    """
+    _objc.options._number_types += (type_object,)
+
+
 registerListType(collections.abc.Sequence)
 registerListType(range)
 registerMappingType(collections.abc.Mapping)
@@ -66,3 +76,4 @@ registerSetType(collections.abc.Set)
 registerDateType(datetime.date)
 registerDateType(datetime.datetime)
 registerPathType(pathlib.Path)
+registerNumberType(numbers.Number)

{pyobjc_core-12.0 → pyobjc_core-12.2}/Lib/objc/_bridgesupport.py

@@ -669,29 +669,16 @@ def _parseBridgeSupport(data, globals, frameworkName, *args, **kwds):  # noqa: A
         )
 
 
-if sys.version_info[:2] >= (3, 9):  # pragma: no branch
-
-    def resource_exists(package, resource):
-        try:
-            return resources.files(package).joinpath(resource).is_file()
-
-        except ImportError:
-            return False
-
-    def resource_string(package, resource):
-        return resources.files(package).joinpath(resource).read_text()
-
-else:  # pragma: no cover
+def resource_exists(package, resource):
+    try:
+        return resources.files(package).joinpath(resource).is_file()
 
-    def resource_exists(package, resource):
-        try:
-            return resources.is_resource(package, resource)
+    except ImportError:
+        return False
 
-        except ImportError:
-            return False
 
-    def resource_string(package, resource):
-        return resources.read_text(package, resource)
+def resource_string(package, resource):
+    return resources.files(package).joinpath(resource).read_text()
 
 
 def initFrameworkWrapper(

{pyobjc_core-12.0 → pyobjc_core-12.2}/Lib/objc/_convenience.py

@@ -139,7 +139,9 @@ def registerNewKeywordsFromSelector(classname, selector):
         raise TypeError("selector should by a bytes object")
     selname = selector.decode()
     kw = _selectorToKeywords(selname)
-    NEW_MAP.setdefault(classname, {})[kw] = selname.replace(":", "_")
+    map_dict = NEW_MAP.setdefault(classname, {})
+    if kw not in map_dict:
+        map_dict[kw] = selname.replace(":", "_")
 
 
 def registerNewKeywords(classname, keywords, methodname):
@@ -152,7 +154,9 @@ def registerNewKeywords(classname, keywords, methodname):
     """
     if not isinstance(keywords, tuple) or not all(isinstance(x, str) for x in keywords):
         raise TypeError("keywords must be tuple of strings")
-    NEW_MAP.setdefault(classname, {})[keywords] = methodname
+    map_dict = NEW_MAP.setdefault(classname, {})
+    if keywords not in map_dict:
+        map_dict[keywords] = methodname
 
 
 def registerABCForClass(classname, *abc_class):