pyobjc-framework-SecurityInterface 12.2.2__tar.gz → 13.0__tar.gz

{pyobjc_framework_securityinterface-12.2.2 → pyobjc_framework_securityinterface-13.0}/Lib/SecurityInterface/_metadata.py

@@ -1,7 +1,5 @@
 # This file is generated by objective.metadata
 #
-# Last update: Sun May 24 11:58:12 2026
-#
 # flake8: noqa
 
 import objc, sys

{pyobjc_framework_securityinterface-12.2.2 → pyobjc_framework_securityinterface-13.0}/Lib/pyobjc_framework_SecurityInterface.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobjc-framework-SecurityInterface
-Version: 12.2.2
+Version: 13.0
 Summary: Wrappers for the framework SecurityInterface on macOS
 Home-page: https://github.com/ronaldoussoren/pyobjc
 Author: Ronald Oussoren
@@ -17,22 +17,22 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: 3.16
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
 Classifier: Programming Language :: Objective C
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: User Interfaces
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst; charset=UTF-8
-Requires-Dist: pyobjc-core>=12.2.2
-Requires-Dist: pyobjc-framework-Cocoa>=12.2.2
-Requires-Dist: pyobjc-framework-Security>=12.2.2
+Requires-Dist: pyobjc-core>=13.0
+Requires-Dist: pyobjc-framework-Cocoa>=13.0
+Requires-Dist: pyobjc-framework-Security>=13.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{pyobjc_framework_securityinterface-12.2.2 → pyobjc_framework_securityinterface-13.0}/Lib/pyobjc_framework_SecurityInterface.egg-info/SOURCES.txt

@@ -28,5 +28,5 @@ PyObjCTest/test_sfkeychainsavepanel.py
 PyObjCTest/test_sfkeychainsettingspanel.py
 metadata/SecurityInterface.fwinfo
 metadata/metadata.ini
-metadata/raw/arm64-26.5.fwinfo
-metadata/raw/x86_64-26.5.fwinfo
+metadata/raw/arm64-27.fwinfo
+metadata/raw/x86_64-27.fwinfo

pyobjc_framework_securityinterface-13.0/Lib/pyobjc_framework_SecurityInterface.egg-info/pyobjc-build-info.txt

@@ -0,0 +1,3 @@
+macOS 27.2 (26B123)
+Apple clang version 21.0.0 (clang-2100.4.1.1)
+SDK: macOS 27.2

pyobjc_framework_securityinterface-13.0/Lib/pyobjc_framework_SecurityInterface.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pyobjc-core>=13.0
+pyobjc-framework-Cocoa>=13.0
+pyobjc-framework-Security>=13.0

pyobjc_framework_securityinterface-13.0/Modules/_SecurityInterface.m

@@ -0,0 +1,354 @@
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#include "pyobjc-api.h"
+
+#ifdef USE_STATIC_ANALYZER
+#include "../../pyobjc-core/Modules/objc/python-api-used.h"
+#endif
+
+#import <Foundation/Foundation.h>
+#import <SecurityInterface/SFAuthorizationView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+static int
+parse_itemset(PyObject* value, AuthorizationItemSet* itemset)
+{
+    itemset->items = NULL;
+
+    if (value == Py_None) {
+        return 1;
+
+    } else {
+        PyObject*  seq = PySequence_Tuple(value);
+        Py_ssize_t i;
+        if (seq == NULL) {
+            return 0;
+        }
+        itemset->count = PyTuple_GET_SIZE(seq);
+        itemset->items = PyMem_Malloc(sizeof(AuthorizationItem) * PyTuple_GET_SIZE(seq));
+        if (itemset->items == NULL) { // LCOV_BR_EXCL_LINE
+            // LCOV_EXCL_START
+            PyErr_NoMemory();
+            return 0;
+            // LCOV_EXCL_STOP
+        }
+
+        for (i = 0; i < PyTuple_GET_SIZE(seq); i++) {
+            PyObject* cur_seq = PySequence_Tuple(PyTuple_GET_ITEM(seq, i));
+            if (cur_seq == NULL) {
+                PyErr_Format(PyExc_TypeError, "items[%ld] is not a sequence", (long)i);
+                PyMem_Free(itemset->items);
+                return 0;
+            }
+            if (PyTuple_GET_SIZE(cur_seq) != 4) {
+                PyErr_Format(PyExc_TypeError, "items[%ld] is not a sequence of 4 items",
+                             (long)i);
+                PyMem_Free(itemset->items);
+                return 0;
+            }
+
+            if (!PyBytes_Check(PyTuple_GET_ITEM(cur_seq, 0))) {
+                PyErr_Format(PyExc_TypeError, "items[%ld].name is not a byte string",
+                             (long)i);
+                PyMem_Free(itemset->items);
+                return 0;
+            }
+
+            itemset->items[i].name = PyBytes_AsString(PyTuple_GET_ITEM(cur_seq, 0));
+
+            if (PyObjC_PythonToObjC(@encode(size_t), PyTuple_GET_ITEM(cur_seq, 1),
+                                    &(itemset->items[i].valueLength))
+                == -1) {
+                PyErr_Format(PyExc_TypeError, "items[%ld].valueLength is not an integer",
+                             (long)i);
+                PyMem_Free(itemset->items);
+                return 0;
+            }
+
+            if (PyTuple_GET_ITEM(cur_seq, 2) == Py_None) {
+                if (itemset->items[i].valueLength != 0) {
+                    PyErr_Format(PyExc_TypeError,
+                                 "items[%ld].value is None, valueLength != 0", (long)i);
+                    PyMem_Free(itemset->items);
+                    return 0;
+                }
+
+                itemset->items[i].value = NULL;
+
+            } else {
+                if (!PyBytes_Check(PyTuple_GET_ITEM(cur_seq, 2))
+                    || PyBytes_Size(PyTuple_GET_ITEM(cur_seq, 2))
+                           != (Py_ssize_t)itemset->items[i].valueLength) {
+                    PyErr_Format(PyExc_TypeError,
+                                 "items[%ld].value is not a byte string of length %ld",
+                                 (long)i, (long)(itemset->items[i].valueLength));
+                    PyMem_Free(itemset->items);
+                    return 0;
+                }
+
+                itemset->items[i].value = PyBytes_AsString(PyTuple_GET_ITEM(cur_seq, 2));
+            }
+
+            if (PyObjC_PythonToObjC(@encode(UInt32), PyTuple_GET_ITEM(cur_seq, 3),
+                                    &(itemset->items[i].flags))
+                == -1) {
+                PyErr_Format(PyExc_TypeError, "items[%ld].flags is not an integer",
+                             (long)i);
+                PyMem_Free(itemset->items);
+                return 0;
+            }
+        }
+    }
+    return 1;
+}
+
+static void
+free_itemset(AuthorizationItemSet* itemset)
+{
+    PyMem_Free(itemset->items);
+}
+
+static PyObject* _Nullable build_itemset(AuthorizationItemSet* _Nonnull itemset)
+{
+    PyObject* result; // = NULL;
+    PyObject* t = NULL;
+    PyObject* o = NULL;
+
+    assert(itemset != NULL);
+
+    UInt32 i;
+    result = PyTuple_New(itemset->count);
+    if (result == NULL) // LCOV_BR_EXCL_LINE
+        return NULL;    // LCOV_EXCL_LINE
+
+    for (i = 0; i < itemset->count; i++) {
+        Py_ssize_t         packed = -1;
+        AuthorizationItem* item   = itemset->items + i;
+
+        assert(item != NULL);
+
+        t = PyObjC_CreateRegisteredStruct("{AuthorizationItem=^cQ^vI}",
+                                          sizeof("{AuthorizationItem=^cQ^vI}") - 1, NULL,
+                                          &packed);
+        if (t == NULL) { // LCOV_BR_EXCL_LINE
+            // LCOV_BR_EXCL_START
+            if (!PyErr_Occurred()) {
+                PyErr_SetString(PyExc_RuntimeError, "No binding for 'AuthorizationItem'");
+            }
+            goto error;
+            // LCOV_BR_EXCL_STOP
+        }
+
+        o = PyBytes_FromString(item->name);
+        if (o == NULL)  // LCOV_BR_EXCL_LINE
+            goto error; // LCOV_EXCL_LINE
+
+        if (PySequence_SetItem(t, 0, o) == -1) // LCOV_BR_EXCL_LINE
+            goto error;                        // LCOV_EXCL_LINE
+
+        Py_CLEAR(o);
+
+        o = PyLong_FromUnsignedLong(item->valueLength);
+        if (o == NULL)  // LCOV_BR_EXCL_LINE
+            goto error; // LCOV_EXCL_LINE
+
+        if (PySequence_SetItem(t, 1, o) == -1) // LCOV_BR_EXCL_LINE
+            goto error;                        // LCOV_EXCL_LINE
+
+        Py_CLEAR(o);
+
+        if (item->value == NULL) {
+            o = Py_None;
+            Py_INCREF(Py_None);
+        } else {
+            o = PyBytes_FromStringAndSize(item->value, item->valueLength);
+            if (o == NULL)  // LCOV_BR_EXCL_LINE
+                goto error; // LCOV_EXCL_LINE
+        }
+
+        if (PySequence_SetItem(t, 2, o) == -1) // LCOV_BR_EXCL_LINE
+            goto error;                        // LCOV_EXCL_LINE
+
+        Py_CLEAR(o);
+
+        o = PyLong_FromUnsignedLong(item->flags);
+        if (o == NULL)  // LCOV_BR_EXCL_LINE
+            goto error; // LCOV_EXCL_LINE
+
+        if (PySequence_SetItem(t, 3, o) == -1) // LCOV_BR_EXCL_LINE
+            goto error;                        // LCOV_EXCL_LINE
+
+        Py_CLEAR(o);
+
+        PyTuple_SET_ITEM(result, i, t);
+    }
+    return result;
+
+error:
+    // LCOV_EXCL_START
+    // as
+    Py_CLEAR(result);
+    Py_CLEAR(t);
+    Py_CLEAR(o);
+    return NULL;
+    // LCOV_EXCL_STOP
+}
+
+static PyObject* _Nullable call_authorizationRights(PyObject* method, PyObject* self,
+                                                    PyObject* const* arguments
+                                                    __attribute__((__unused__)),
+                                                    size_t nargs)
+{
+    struct objc_super    super;
+    AuthorizationRights* rights;
+    PyObject*            py_rights;
+
+    if (PyObjC_CheckArgCount(method, 0, 0, nargs) == -1) {
+        return NULL;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+        @try {
+            super.super_class = PyObjCSelector_GetClass(method);
+            super.receiver    = PyObjCObject_GetObject(self);
+
+            rights = ((AuthorizationRights * (*)(struct objc_super*, SEL))
+                          objc_msgSendSuper)(&super, PyObjCSelector_GetSelector(method));
+
+        } @catch (NSException* localException) { // LCOV_EXCL_LINE
+            PyObjCErr_FromObjC(localException);  // LCOV_EXCL_LINE
+        }
+    Py_END_ALLOW_THREADS
+
+    if (PyErr_Occurred()) // LCOV_BR_EXCL_LINE
+        return NULL;      // LCOV_EXCL_LINE
+
+    if (rights == NULL)
+        Py_RETURN_NONE;
+
+    py_rights = build_itemset(rights);
+    assert(py_rights || PyErr_Occurred());
+    return py_rights;
+}
+
+static PyObject* _Nullable call_setAuthorizationRights_(PyObject* method, PyObject* self,
+                                                        PyObject* const* arguments,
+                                                        size_t           nargs)
+{
+    struct objc_super   super;
+    AuthorizationRights rights;
+    PyObject*           py_rights;
+
+    rights.items = NULL;
+
+    if (PyObjC_CheckArgCount(method, 1, 1, nargs) == -1) {
+        return NULL;
+    }
+    py_rights = arguments[0];
+
+    if (!parse_itemset(py_rights, &rights)) {
+        return NULL;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+        @try {
+            super.super_class = PyObjCSelector_GetClass(method);
+            super.receiver    = PyObjCObject_GetObject(self);
+
+            ((void (*)(struct objc_super*, SEL, AuthorizationRights*))objc_msgSendSuper)(
+                &super, PyObjCSelector_GetSelector(method), &rights);
+
+        } @catch (NSException* localException) { // LCOV_EXCL_LINE
+            PyObjCErr_FromObjC(localException);  // LCOV_EXCL_LINE
+        }
+    Py_END_ALLOW_THREADS
+
+    free_itemset(&rights);
+
+    if (PyErr_Occurred()) // LCOV_BR_EXCL_LINE
+        return NULL;      // LCOV_EXCL_LINE
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyMethodDef mod_methods[] = {
+    {0, 0, 0, 0} /* sentinel */
+};
+
+static int
+mod_exec_module(PyObject* m)
+{
+    Class cls;
+
+    if (PyObjC_ImportAPI(m) == -1) // LCOV_BR_EXCL_LINE
+        return -1;                 // LCOV_EXCL_LINE
+
+    cls = objc_lookUpClass("SFAuthorizationView");
+    if (cls == Nil) { // LCOV_BR_EXCL_LINE
+        return 0;     // LCOV_EXCL_LINE
+    }
+
+    if (PyObjC_RegisterMethodMapping(cls, @selector(authorizationRights),
+                                     call_authorizationRights,
+                                     PyObjCUnsupportedMethod_IMP)
+        < 0) { // LCOV_BR_EXCL_LINE
+
+        return -1; // LCOV_EXCL_LINE
+    }
+
+    if (PyObjC_RegisterMethodMapping(cls, @selector(setAuthorizationRights:),
+                                     call_setAuthorizationRights_,
+                                     PyObjCUnsupportedMethod_IMP)
+        < 0) { // LCOV_BR_EXCL_LINE
+
+        return -1; // LCOV_EXCL_LINE
+    }
+
+    return 0;
+}
+
+static struct PyModuleDef_Slot mod_slots[] = {
+    {.slot = Py_mod_exec, .value = (void*)mod_exec_module},
+#if PY_VERSION_HEX >= 0x030c0000
+    {
+        /* This extension does not use the CPython API other than initializing
+         * the module, hence is safe with subinterpreters and per-interpreter
+         * GILs
+         */
+        .slot  = Py_mod_multiple_interpreters,
+        .value = Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED,
+    },
+#endif
+#if PY_VERSION_HEX >= 0x030d0000
+    {
+        /* The code in this extension should be safe to use without the GIL */
+        .slot  = Py_mod_gil,
+        .value = Py_MOD_GIL_NOT_USED,
+    },
+#endif
+    {/* Sentinel */
+     .slot  = 0,
+     .value = 0}};
+
+static struct PyModuleDef mod_module = {
+    .m_base     = PyModuleDef_HEAD_INIT,
+    .m_name     = "_SecurityInterface",
+    .m_doc      = NULL,
+    .m_size     = 0,
+    .m_methods  = mod_methods,
+    .m_slots    = mod_slots,
+    .m_traverse = NULL,
+    .m_clear    = NULL,
+    .m_free     = NULL,
+};
+
+PyObject* _Nullable PyInit__SecurityInterface(void);
+
+PyObject* _Nullable __attribute__((__visibility__("default")))
+PyInit__SecurityInterface(void)
+{
+    return PyModuleDef_Init(&mod_module);
+}
+NS_ASSUME_NONNULL_END

{pyobjc_framework_securityinterface-12.2.2 → pyobjc_framework_securityinterface-13.0}/Modules/pyobjc-api.h

@@ -60,6 +60,11 @@ typedef int(RegisterMethodMappingFunctionType)(
                                     PyObject* _Nonnull const* _Nonnull, size_t),
     IMP _Nullable (*_Nonnull)(PyObject* _Nonnull, PyObject* _Nonnull));
 
+#ifndef PyObjC_FUNCTION_CALL_H
+typedef PyObject* _Nullable (*PyObjC_FunctionCallFunc)(
+    PyObject* meth, PyObject* _Nonnull const* _Nonnull args, size_t nargs);
+#endif
+
 struct pyobjc_api {
     int                                api_version; /* API version */
     size_t                             struct_len;  /* Length of this struct */
@@ -117,6 +122,9 @@ struct pyobjc_api {
 
     PyObject* _Nullable (*_Nonnull createopaquepointertype)(const char*, const char*,
                                                             const char*);
+    int (*_Nonnull register_functioncaller)(void*, PyObjC_FunctionCallFunc);
+    PyObject* _Nullable (*_Nonnull create_registered_struct)(
+        const char*, Py_ssize_t, const char* _Nonnull* _Nullable, Py_ssize_t*);
 };
 
 #ifndef PYOBJC_BUILD
@@ -159,6 +167,8 @@ static struct pyobjc_api* PyObjC_API;
 #define PyObjC_CheckArgCount (PyObjC_API->checkargcount)
 #define PyObjC_CheckNoKwnames (PyObjC_API->checknokwnames)
 #define PyObjCCreateOpaquePointerType (PyObjC_API->createopaquepointertype)
+#define PyObjCRegister_FunctionCaller (PyObjC_API->register_functioncaller)
+#define PyObjC_CreateRegisteredStruct (PyObjC_API->create_registered_struct)
 
 typedef void (*PyObjC_Function_Pointer)(void);
 typedef struct PyObjC_function_map {
@@ -178,21 +188,25 @@ static inline int
 PyObjC_ImportAPI(PyObject* calling_module)
 {
     PyObjC_API = (struct pyobjc_api*)PyCapsule_Import("objc." PYOBJC_API_NAME, 0);
-    if (PyObjC_API == NULL) {
-        return -1;
+    if (PyObjC_API == NULL) { // LCOV_BR_EXCL_LINE
+        return -1;            // LCOV_EXCL_LINE
     }
-    if (PyObjC_API->api_version != PYOBJC_API_VERSION) {
+    if (PyObjC_API->api_version != PYOBJC_API_VERSION) { // LCOV_BR_EXCL_LINE
+        // LCOV_EXCL_START
         PyErr_Format(PyExc_RuntimeError,
                      "Wrong version of PyObjC C API (got %d, expected %d)",
                      (int)PyObjC_API->api_version, (int)PYOBJC_API_VERSION);
         return -1;
+        // LCOV_EXCL_STOP
     }
 
-    if (PyObjC_API->struct_len < PyObjC_EXPECTED_STRUCT_SIZE) {
+    if (PyObjC_API->struct_len < PyObjC_EXPECTED_STRUCT_SIZE) { // LCOV_EXCL_LINE
+        // LCOV_EXCL_START
         PyErr_Format(PyExc_RuntimeError,
                      "Wrong struct-size of PyObjC C API (got %d, expected %d)",
                      (int)PyObjC_API->struct_len, (int)sizeof(struct pyobjc_api));
         return -1;
+        // LCOV_EXCL_STOP
     }
 
     /* Current pyobjc implementation doesn't allow deregistering

{pyobjc_framework_securityinterface-12.2.2 → pyobjc_framework_securityinterface-13.0}/Modules/pyobjc-compat.h

@@ -167,24 +167,6 @@ _PyObjCTuple_GetItem(PyObject* tuple, Py_ssize_t idx)
         PyGILState_Release(_GILState);                                                   \
     } while (0)
 
-#if PY_VERSION_HEX < 0x030a0000
-
-static inline PyObject*
-Py_NewRef(PyObject* o)
-{
-    Py_INCREF(o);
-    return o;
-}
-
-static inline PyObject*
-Py_XNewRef(PyObject* o)
-{
-    Py_XINCREF(o);
-    return o;
-}
-
-#endif /* PY_VERSION_HEX < 0x030a0000 */
-
 #if PY_VERSION_HEX < 0x030d0000
 #define Py_BEGIN_CRITICAL_SECTION(value)                                                 \
     {                                                                                    \

{pyobjc_framework_securityinterface-12.2.2 → pyobjc_framework_securityinterface-13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobjc-framework-SecurityInterface
-Version: 12.2.2
+Version: 13.0
 Summary: Wrappers for the framework SecurityInterface on macOS
 Home-page: https://github.com/ronaldoussoren/pyobjc
 Author: Ronald Oussoren
@@ -17,22 +17,22 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: 3.16
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
 Classifier: Programming Language :: Objective C
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: User Interfaces
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst; charset=UTF-8
-Requires-Dist: pyobjc-core>=12.2.2
-Requires-Dist: pyobjc-framework-Cocoa>=12.2.2
-Requires-Dist: pyobjc-framework-Security>=12.2.2
+Requires-Dist: pyobjc-core>=13.0
+Requires-Dist: pyobjc-framework-Cocoa>=13.0
+Requires-Dist: pyobjc-framework-Security>=13.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

pyobjc_framework_securityinterface-13.0/PyObjCTest/test_sfauthorizationview.py

@@ -0,0 +1,126 @@
+import SecurityInterface
+import Security
+from PyObjCTools.TestSupport import TestCase
+
+
+class TestSFAuthorizationViewHelper(SecurityInterface.NSObject):
+    def authorizationViewShouldDeauthorize_(self, v):
+        return 1
+
+
+class TestSFAuthorizationView(TestCase):
+    def test_constants(self):
+        self.assertEqual(SecurityInterface.SFAuthorizationStartupState, 0)
+        self.assertEqual(SecurityInterface.SFAuthorizationViewLockedState, 1)
+        self.assertEqual(SecurityInterface.SFAuthorizationViewInProgressState, 2)
+        self.assertEqual(SecurityInterface.SFAuthorizationViewUnlockedState, 3)
+
+    def test_classes(self):
+        SecurityInterface.SFAuthorizationView
+
+    def test_methods(self):
+        self.assertResultIsBOOL(SecurityInterface.SFAuthorizationView.updateStatus_)
+        self.assertArgIsBOOL(SecurityInterface.SFAuthorizationView.setAutoupdate_, 0)
+        self.assertArgIsBOOL(
+            SecurityInterface.SFAuthorizationView.setAutoupdate_interval_, 0
+        )
+        self.assertArgIsBOOL(SecurityInterface.SFAuthorizationView.setEnabled_, 0)
+        self.assertResultIsBOOL(SecurityInterface.SFAuthorizationView.isEnabled)
+        self.assertResultIsBOOL(SecurityInterface.SFAuthorizationView.authorize_)
+        self.assertResultIsBOOL(SecurityInterface.SFAuthorizationView.deauthorize_)
+
+    def test_protocol_methods(self):
+        # Informal protocol
+        self.assertResultIsBOOL(
+            TestSFAuthorizationViewHelper.authorizationViewShouldDeauthorize_
+        )
+
+    def test_manual(self):
+        view = SecurityInterface.SFAuthorizationView.alloc().initWithFrame_(
+            ((0, 0), (300, 300))
+        )
+        self.assertIsInstance(view, SecurityInterface.SFAuthorizationView)
+
+        with self.assertRaisesRegex(TypeError, "expected no arguments, got 1"):
+            view.authorizationRights(1)
+
+        rights = view.authorizationRights()
+        self.assertIs(rights, None)
+
+        with self.assertRaisesRegex(TypeError, "expected 1 arguments, got 2"):
+            view.setAuthorizationRights_(None, 1)
+
+        view.setAuthorizationRights_(None)
+        rights = [
+            Security.AuthorizationItem(
+                name=Security.kAuthorizationRightExecute,
+                valueLength=11,
+                value=b"/usr/bin/id",
+                flags=0,
+            ),
+            Security.AuthorizationItem(
+                name=Security.kAuthorizationEnvironmentPrompt,
+                valueLength=0,
+                value=None,
+                flags=0,
+            ),
+        ]
+
+        view.setAuthorizationRights_(rights)
+
+        rights = view.authorizationRights()
+        self.assertEqual(
+            rights,
+            (
+                (
+                    Security.AuthorizationItem(
+                        name=b"system.privilege.admin",
+                        valueLength=11,
+                        value=b"/usr/bin/id",
+                        flags=0,
+                    ),
+                    (
+                        Security.AuthorizationItem(
+                            name=b"prompt", valueLength=0, value=None, flags=0
+                        )
+                    ),
+                )
+            ),
+        )
+
+        with self.assertRaisesRegex(TypeError, "'int' object is not iterable"):
+            view.setAuthorizationRights_(42)
+
+        with self.assertRaisesRegex(TypeError, r"items\[0\] is not a sequence"):
+            view.setAuthorizationRights_([42])
+
+        with self.assertRaisesRegex(
+            TypeError, r"items\[0\] is not a sequence of 4 items"
+        ):
+            view.setAuthorizationRights_([()])
+
+        with self.assertRaisesRegex(TypeError, r"items\[0\].name is not a byte string"):
+            view.setAuthorizationRights_([("key", 5, b"value", 0)])
+
+        with self.assertRaisesRegex(
+            TypeError, r"items\[0\].valueLength is not an integer"
+        ):
+            view.setAuthorizationRights_([(b"key", "5", b"value", 0)])
+
+        with self.assertRaisesRegex(
+            TypeError, r"items\[0\].value is not a byte string of length 5"
+        ):
+            view.setAuthorizationRights_([(b"key", 5, "value", 0)])
+
+        with self.assertRaisesRegex(
+            TypeError, r"items\[0\].value is None, valueLength != 0"
+        ):
+            view.setAuthorizationRights_([(b"key", 5, None, 0)])
+
+        with self.assertRaisesRegex(
+            TypeError, r"items\[0\].value is not a byte string of length 5"
+        ):
+            view.setAuthorizationRights_([(b"key", 5, "val", 0)])
+
+        with self.assertRaisesRegex(TypeError, r"items\[0\].flags is not an integer"):
+            view.setAuthorizationRights_([(b"key", 5, b"value", "0")])

{pyobjc_framework_securityinterface-12.2.2 → pyobjc_framework_securityinterface-13.0}/PyObjCTest/test_sfcertificatepanel.py

@@ -43,4 +43,6 @@ class TestSFCertificatePanel(TestCase):
         self.assertArgIsBOOL(SecurityInterface.SFCertificatePanel.setShowsHelp_, 0)
         self.assertResultIsBOOL(SecurityInterface.SFCertificatePanel.showsHelp)
 
+    def test_protocol_methods(self):
+        # Informal protocol
         self.assertResultIsBOOL(TestSFCertificatePanelHelper.certificatePanelShowHelp_)

{pyobjc_framework_securityinterface-12.2.2 → pyobjc_framework_securityinterface-13.0}/PyObjCTest/test_sfcertificateview.py

@@ -1,9 +1,8 @@
 import SecurityInterface
-from PyObjCTools.TestSupport import TestCase, expectedFailure
+from PyObjCTools.TestSupport import TestCase
 
 
 class TestSFCertificateView(TestCase):
-    @expectedFailure
     def test_constants(self):
         # Constant is not present on 10.12
         self.assertHasAttr(