@react-native-ohos/react-native-mmkv 3.3.1-rc.1

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/tests/object.h

@@ -0,0 +1,205 @@
+#if !defined(__OBJECT_H)
+#    define __OBJECT_H
+
+#    include "constructor_stats.h"
+
+#    include <atomic>
+
+/// Reference counted object base class
+class Object {
+public:
+    /// Default constructor
+    Object() { print_default_created(this); }
+
+    /// Copy constructor
+    Object(const Object &) : m_refCount(0) { print_copy_created(this); }
+
+    /// Return the current reference count
+    int getRefCount() const { return m_refCount; };
+
+    /// Increase the object's reference count by one
+    void incRef() const { ++m_refCount; }
+
+    /** \brief Decrease the reference count of
+     * the object and possibly deallocate it.
+     *
+     * The object will automatically be deallocated once
+     * the reference count reaches zero.
+     */
+    void decRef(bool dealloc = true) const {
+        --m_refCount;
+        if (m_refCount == 0 && dealloc) {
+            delete this;
+        } else if (m_refCount < 0) {
+            throw std::runtime_error("Internal error: reference count < 0!");
+        }
+    }
+
+    virtual std::string toString() const = 0;
+
+protected:
+    /** \brief Virtual protected deconstructor.
+     * (Will only be called by \ref ref)
+     */
+    virtual ~Object() { print_destroyed(this); }
+
+private:
+    mutable std::atomic<int> m_refCount{0};
+};
+
+// Tag class used to track constructions of ref objects.  When we track constructors, below, we
+// track and print out the actual class (e.g. ref<MyObject>), and *also* add a fake tracker for
+// ref_tag.  This lets us check that the total number of ref<Anything> constructors/destructors is
+// correct without having to check each individual ref<Whatever> type individually.
+class ref_tag {};
+
+/**
+ * \brief Reference counting helper
+ *
+ * The \a ref refeference template is a simple wrapper to store a
+ * pointer to an object. It takes care of increasing and decreasing
+ * the reference count of the object. When the last reference goes
+ * out of scope, the associated object will be deallocated.
+ *
+ * \ingroup libcore
+ */
+template <typename T>
+class ref {
+public:
+    /// Create a nullptr reference
+    ref() : m_ptr(nullptr) {
+        print_default_created(this);
+        track_default_created((ref_tag *) this);
+    }
+
+    /// Construct a reference from a pointer
+    explicit ref(T *ptr) : m_ptr(ptr) {
+        if (m_ptr) {
+            ((Object *) m_ptr)->incRef();
+        }
+
+        print_created(this, "from pointer", m_ptr);
+        track_created((ref_tag *) this, "from pointer");
+    }
+
+    /// Copy constructor
+    ref(const ref &r) : m_ptr(r.m_ptr) {
+        if (m_ptr) {
+            ((Object *) m_ptr)->incRef();
+        }
+
+        print_copy_created(this, "with pointer", m_ptr);
+        track_copy_created((ref_tag *) this);
+    }
+
+    /// Move constructor
+    ref(ref &&r) noexcept : m_ptr(r.m_ptr) {
+        r.m_ptr = nullptr;
+
+        print_move_created(this, "with pointer", m_ptr);
+        track_move_created((ref_tag *) this);
+    }
+
+    /// Destroy this reference
+    ~ref() {
+        if (m_ptr) {
+            ((Object *) m_ptr)->decRef();
+        }
+
+        print_destroyed(this);
+        track_destroyed((ref_tag *) this);
+    }
+
+    /// Move another reference into the current one
+    ref &operator=(ref &&r) noexcept {
+        print_move_assigned(this, "pointer", r.m_ptr);
+        track_move_assigned((ref_tag *) this);
+
+        if (*this == r) {
+            return *this;
+        }
+        if (m_ptr) {
+            ((Object *) m_ptr)->decRef();
+        }
+        m_ptr = r.m_ptr;
+        r.m_ptr = nullptr;
+        return *this;
+    }
+
+    /// Overwrite this reference with another reference
+    ref &operator=(const ref &r) {
+        if (this == &r) {
+            return *this;
+        }
+        print_copy_assigned(this, "pointer", r.m_ptr);
+        track_copy_assigned((ref_tag *) this);
+
+        if (m_ptr == r.m_ptr) {
+            return *this;
+        }
+        if (m_ptr) {
+            ((Object *) m_ptr)->decRef();
+        }
+        m_ptr = r.m_ptr;
+        if (m_ptr) {
+            ((Object *) m_ptr)->incRef();
+        }
+        return *this;
+    }
+
+    /// Overwrite this reference with a pointer to another object
+    ref &operator=(T *ptr) {
+        print_values(this, "assigned pointer");
+        track_values((ref_tag *) this, "assigned pointer");
+
+        if (m_ptr == ptr) {
+            return *this;
+        }
+        if (m_ptr) {
+            ((Object *) m_ptr)->decRef();
+        }
+        m_ptr = ptr;
+        if (m_ptr) {
+            ((Object *) m_ptr)->incRef();
+        }
+        return *this;
+    }
+
+    /// Compare this reference with another reference
+    bool operator==(const ref &r) const { return m_ptr == r.m_ptr; }
+
+    /// Compare this reference with another reference
+    bool operator!=(const ref &r) const { return m_ptr != r.m_ptr; }
+
+    /// Compare this reference with a pointer
+    bool operator==(const T *ptr) const { return m_ptr == ptr; }
+
+    /// Compare this reference with a pointer
+    bool operator!=(const T *ptr) const { return m_ptr != ptr; }
+
+    /// Access the object referenced by this reference
+    T *operator->() { return m_ptr; }
+
+    /// Access the object referenced by this reference
+    const T *operator->() const { return m_ptr; }
+
+    /// Return a C++ reference to the referenced object
+    T &operator*() { return *m_ptr; }
+
+    /// Return a const C++ reference to the referenced object
+    const T &operator*() const { return *m_ptr; }
+
+    /// Return a pointer to the referenced object
+    explicit operator T *() { return m_ptr; }
+
+    /// Return a const pointer to the referenced object
+    T *get_ptr() { return m_ptr; }
+
+    /// Return a pointer to the referenced object
+    const T *get_ptr() const { return m_ptr; }
+
+private:
+    T *m_ptr;
+};
+
+#endif /* __OBJECT_H */

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/tests/pybind11_cross_module_tests.cpp

@@ -0,0 +1,149 @@
+/*
+    tests/pybind11_cross_module_tests.cpp -- contains tests that require multiple modules
+
+    Copyright (c) 2017 Jason Rhinelander <jason@imaginary.ca>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include <pybind11/stl_bind.h>
+
+#include "local_bindings.h"
+#include "pybind11_tests.h"
+#include "test_exceptions.h"
+
+#include <numeric>
+#include <utility>
+
+PYBIND11_MODULE(pybind11_cross_module_tests, m, py::mod_gil_not_used()) {
+    m.doc() = "pybind11 cross-module test module";
+
+    // test_local_bindings.py tests:
+    //
+    // Definitions here are tested by importing both this module and the
+    // relevant pybind11_tests submodule from a test_whatever.py
+
+    // test_load_external
+    bind_local<ExternalType1>(m, "ExternalType1", py::module_local());
+    bind_local<ExternalType2>(m, "ExternalType2", py::module_local());
+
+    // test_exceptions.py
+    py::register_local_exception<LocalSimpleException>(m, "LocalSimpleException");
+    m.def("raise_runtime_error", []() {
+        py::set_error(PyExc_RuntimeError, "My runtime error");
+        throw py::error_already_set();
+    });
+    m.def("raise_value_error", []() {
+        py::set_error(PyExc_ValueError, "My value error");
+        throw py::error_already_set();
+    });
+    m.def("throw_pybind_value_error", []() { throw py::value_error("pybind11 value error"); });
+    m.def("throw_pybind_type_error", []() { throw py::type_error("pybind11 type error"); });
+    m.def("throw_stop_iteration", []() { throw py::stop_iteration(); });
+    m.def("throw_local_error", []() { throw LocalException("just local"); });
+    m.def("throw_local_simple_error", []() { throw LocalSimpleException("external mod"); });
+    py::register_exception_translator([](std::exception_ptr p) {
+        try {
+            if (p) {
+                std::rethrow_exception(p);
+            }
+        } catch (const shared_exception &e) {
+            py::set_error(PyExc_KeyError, e.what());
+        }
+    });
+
+    // translate the local exception into a key error but only in this module
+    py::register_local_exception_translator([](std::exception_ptr p) {
+        try {
+            if (p) {
+                std::rethrow_exception(p);
+            }
+        } catch (const LocalException &e) {
+            py::set_error(PyExc_KeyError, e.what());
+        }
+    });
+
+    // test_local_bindings.py
+    // Local to both:
+    bind_local<LocalType, 1>(m, "LocalType", py::module_local()).def("get2", [](LocalType &t) {
+        return t.i + 2;
+    });
+
+    // Can only be called with our python type:
+    m.def("local_value", [](LocalType &l) { return l.i; });
+
+    // test_nonlocal_failure
+    // This registration will fail (global registration when LocalFail is already registered
+    // globally in the main test module):
+    m.def("register_nonlocal", [m]() { bind_local<NonLocalType, 0>(m, "NonLocalType"); });
+
+    // test_stl_bind_local
+    // stl_bind.h binders defaults to py::module_local if the types are local or converting:
+    py::bind_vector<LocalVec>(m, "LocalVec");
+    py::bind_map<LocalMap>(m, "LocalMap");
+
+    // test_stl_bind_global
+    // and global if the type (or one of the types, for the map) is global (so these will fail,
+    // assuming pybind11_tests is already loaded):
+    m.def("register_nonlocal_vec", [m]() { py::bind_vector<NonLocalVec>(m, "NonLocalVec"); });
+    m.def("register_nonlocal_map", [m]() { py::bind_map<NonLocalMap>(m, "NonLocalMap"); });
+    // The default can, however, be overridden to global using `py::module_local()` or
+    // `py::module_local(false)`.
+    // Explicitly made local:
+    py::bind_vector<NonLocalVec2>(m, "NonLocalVec2", py::module_local());
+    // Explicitly made global (and so will fail to bind):
+    m.def("register_nonlocal_map2",
+          [m]() { py::bind_map<NonLocalMap2>(m, "NonLocalMap2", py::module_local(false)); });
+
+    // test_mixed_local_global
+    // We try this both with the global type registered first and vice versa (the order shouldn't
+    // matter).
+    m.def("register_mixed_global_local",
+          [m]() { bind_local<MixedGlobalLocal, 200>(m, "MixedGlobalLocal", py::module_local()); });
+    m.def("register_mixed_local_global", [m]() {
+        bind_local<MixedLocalGlobal, 2000>(m, "MixedLocalGlobal", py::module_local(false));
+    });
+    m.def("get_mixed_gl", [](int i) { return MixedGlobalLocal(i); });
+    m.def("get_mixed_lg", [](int i) { return MixedLocalGlobal(i); });
+
+    // test_internal_locals_differ
+    m.def("local_cpp_types_addr",
+          []() { return (uintptr_t) &py::detail::get_local_internals().registered_types_cpp; });
+
+    // test_stl_caster_vs_stl_bind
+    py::bind_vector<std::vector<int>>(m, "VectorInt");
+
+    m.def("load_vector_via_binding",
+          [](std::vector<int> &v) { return std::accumulate(v.begin(), v.end(), 0); });
+
+    // test_cross_module_calls
+    m.def("return_self", [](LocalVec *v) { return v; });
+    m.def("return_copy", [](const LocalVec &v) { return LocalVec(v); });
+
+    class Dog : public pets::Pet {
+    public:
+        explicit Dog(std::string name) : Pet(std::move(name)) {}
+    };
+    py::class_<pets::Pet>(m, "Pet", py::module_local()).def("name", &pets::Pet::name);
+    // Binding for local extending class:
+    py::class_<Dog, pets::Pet>(m, "Dog").def(py::init<std::string>());
+    m.def("pet_name", [](pets::Pet &p) { return p.name(); });
+
+    py::class_<MixGL>(m, "MixGL", py::module_local()).def(py::init<int>());
+    m.def("get_gl_value", [](MixGL &o) { return o.i + 100; });
+
+    py::class_<MixGL2>(m, "MixGL2", py::module_local()).def(py::init<int>());
+
+    // test_vector_bool
+    // We can't test both stl.h and stl_bind.h conversions of `std::vector<bool>` within
+    // the same module (it would be an ODR violation). Therefore `bind_vector` of `bool`
+    // is defined here and tested in `test_stl_binders.py`.
+    py::bind_vector<std::vector<bool>>(m, "VectorBool");
+
+    // test_missing_header_message
+    // The main module already includes stl.h, but we need to test the error message
+    // which appears when this header is missing.
+    m.def("missing_header_arg", [](const std::vector<float> &) {});
+    m.def("missing_header_return", []() { return std::vector<float>(); });
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/tests/pybind11_tests.cpp

@@ -0,0 +1,131 @@
+/*
+    tests/pybind11_tests.cpp -- pybind example plugin
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "pybind11_tests.h"
+
+#include "constructor_stats.h"
+
+#include <functional>
+#include <list>
+
+/*
+For testing purposes, we define a static global variable here in a function that each individual
+test .cpp calls with its initialization lambda.  It's convenient here because we can just not
+compile some test files to disable/ignore some of the test code.
+
+It is NOT recommended as a way to use pybind11 in practice, however: the initialization order will
+be essentially random, which is okay for our test scripts (there are no dependencies between the
+individual pybind11 test .cpp files), but most likely not what you want when using pybind11
+productively.
+
+Instead, see the "How can I reduce the build time?" question in the "Frequently asked questions"
+section of the documentation for good practice on splitting binding code over multiple files.
+*/
+std::list<std::function<void(py::module_ &)>> &initializers() {
+    static std::list<std::function<void(py::module_ &)>> inits;
+    return inits;
+}
+
+test_initializer::test_initializer(Initializer init) { initializers().emplace_back(init); }
+
+test_initializer::test_initializer(const char *submodule_name, Initializer init) {
+    initializers().emplace_back([=](py::module_ &parent) {
+        auto m = parent.def_submodule(submodule_name);
+        init(m);
+    });
+}
+
+void bind_ConstructorStats(py::module_ &m) {
+    py::class_<ConstructorStats>(m, "ConstructorStats")
+        .def("alive", &ConstructorStats::alive)
+        .def("values", &ConstructorStats::values)
+        .def_readwrite("default_constructions", &ConstructorStats::default_constructions)
+        .def_readwrite("copy_assignments", &ConstructorStats::copy_assignments)
+        .def_readwrite("move_assignments", &ConstructorStats::move_assignments)
+        .def_readwrite("copy_constructions", &ConstructorStats::copy_constructions)
+        .def_readwrite("move_constructions", &ConstructorStats::move_constructions)
+        .def_static("get",
+                    (ConstructorStats & (*) (py::object)) & ConstructorStats::get,
+                    py::return_value_policy::reference_internal)
+
+        // Not exactly ConstructorStats, but related: expose the internal pybind number of
+        // registered instances to allow instance cleanup checks (invokes a GC first)
+        .def_static("detail_reg_inst", []() {
+            ConstructorStats::gc();
+            return py::detail::num_registered_instances();
+        });
+}
+
+const char *cpp_std() {
+    return
+#if defined(PYBIND11_CPP20)
+        "C++20";
+#elif defined(PYBIND11_CPP17)
+        "C++17";
+#elif defined(PYBIND11_CPP14)
+        "C++14";
+#else
+        "C++11";
+#endif
+}
+
+PYBIND11_MODULE(pybind11_tests, m, py::mod_gil_not_used()) {
+    m.doc() = "pybind11 test module";
+
+    // Intentionally kept minimal to not create a maintenance chore
+    // ("just enough" to be conclusive).
+#if defined(__VERSION__)
+    m.attr("compiler_info") = __VERSION__;
+#elif defined(_MSC_FULL_VER)
+    m.attr("compiler_info") = "MSVC " PYBIND11_TOSTRING(_MSC_FULL_VER);
+#else
+    m.attr("compiler_info") = py::none();
+#endif
+    m.attr("cpp_std") = cpp_std();
+    m.attr("PYBIND11_INTERNALS_ID") = PYBIND11_INTERNALS_ID;
+    // Free threaded Python uses UINT32_MAX for immortal objects.
+    m.attr("PYBIND11_REFCNT_IMMORTAL") = UINT32_MAX;
+    m.attr("PYBIND11_SIMPLE_GIL_MANAGEMENT") =
+#if defined(PYBIND11_SIMPLE_GIL_MANAGEMENT)
+        true;
+#else
+        false;
+#endif
+    m.attr("PYBIND11_NUMPY_1_ONLY") =
+#if defined(PYBIND11_NUMPY_1_ONLY)
+        true;
+#else
+        false;
+#endif
+
+    bind_ConstructorStats(m);
+
+#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+    m.attr("detailed_error_messages_enabled") = true;
+#else
+    m.attr("detailed_error_messages_enabled") = false;
+#endif
+
+    py::class_<UserType>(m, "UserType", "A `py::class_` type for testing")
+        .def(py::init<>())
+        .def(py::init<int>())
+        .def("get_value", &UserType::value, "Get value using a method")
+        .def("set_value", &UserType::set, "Set value using a method")
+        .def_property("value", &UserType::value, &UserType::set, "Get/set value using a property")
+        .def("__repr__", [](const UserType &u) { return "UserType({})"_s.format(u.value()); });
+
+    py::class_<IncType, UserType>(m, "IncType")
+        .def(py::init<>())
+        .def(py::init<int>())
+        .def("__repr__", [](const IncType &u) { return "IncType({})"_s.format(u.value()); });
+
+    for (const auto &initializer : initializers()) {
+        initializer(m);
+    }
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/tests/pybind11_tests.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <pybind11/eval.h>
+#include <pybind11/pybind11.h>
+
+#include <memory>
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+
+class test_initializer {
+    using Initializer = void (*)(py::module_ &);
+
+public:
+    explicit test_initializer(Initializer init);
+    test_initializer(const char *submodule_name, Initializer init);
+};
+
+#define TEST_SUBMODULE(name, variable)                                                            \
+    void test_submodule_##name(py::module_ &);                                                    \
+    test_initializer name(#name, test_submodule_##name);                                          \
+    void test_submodule_##name(py::module_ &(variable))
+
+/// Dummy type which is not exported anywhere -- something to trigger a conversion error
+struct UnregisteredType {};
+
+/// A user-defined type which is exported and can be used by any test
+class UserType {
+public:
+    UserType() = default;
+    explicit UserType(int i) : i(i) {}
+
+    int value() const { return i; }
+    void set(int set) { i = set; }
+
+private:
+    int i = -1;
+};
+
+/// Like UserType, but increments `value` on copy for quick reference vs. copy tests
+class IncType : public UserType {
+public:
+    using UserType::UserType;
+    IncType() = default;
+    IncType(const IncType &other) : IncType(other.value() + 1) {}
+    IncType(IncType &&) = delete;
+    IncType &operator=(const IncType &) = delete;
+    IncType &operator=(IncType &&) = delete;
+};
+
+/// A simple union for basic testing
+union IntFloat {
+    int i;
+    float f;
+};
+
+class UnusualOpRef {
+public:
+    using NonTrivialType = std::shared_ptr<int>; // Almost any non-trivial type will do.
+    // Overriding operator& should not break pybind11.
+    NonTrivialType operator&() { return non_trivial_member; }
+    NonTrivialType operator&() const { return non_trivial_member; }
+
+private:
+    NonTrivialType non_trivial_member;
+};
+
+/// Custom cast-only type that casts to a string "rvalue" or "lvalue" depending on the cast
+/// context. Used to test recursive casters (e.g. std::tuple, stl containers).
+struct RValueCaster {};
+PYBIND11_NAMESPACE_BEGIN(pybind11)
+PYBIND11_NAMESPACE_BEGIN(detail)
+template <>
+class type_caster<RValueCaster> {
+public:
+    PYBIND11_TYPE_CASTER(RValueCaster, const_name("RValueCaster"));
+    static handle cast(RValueCaster &&, return_value_policy, handle) {
+        return py::str("rvalue").release();
+    }
+    static handle cast(const RValueCaster &, return_value_policy, handle) {
+        return py::str("lvalue").release();
+    }
+};
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(pybind11)
+
+template <typename F>
+void ignoreOldStyleInitWarnings(F &&body) {
+    py::exec(R"(
+    message = "pybind11-bound class '.+' is using an old-style placement-new '(?:__init__|__setstate__)' which has been deprecated"
+
+    import warnings
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message=message, category=FutureWarning)
+        body()
+    )",
+             py::dict(py::arg("body") = py::cpp_function(body)));
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/tests/pytest.ini

@@ -0,0 +1,23 @@
+[pytest]
+minversion = 3.10
+norecursedirs = test_* extra_*
+xfail_strict = True
+addopts =
+    # show summary of tests
+    -ra
+    # capture only Python print and C++ py::print, but not C output (low-level Python errors)
+    --capture=sys
+    # Show local info when a failure occurs
+    --showlocals
+log_cli_level = info
+filterwarnings =
+    # make warnings into errors but ignore certain third-party extension issues
+    error
+    # somehow, some DeprecationWarnings do not get turned into errors
+    always::DeprecationWarning
+    # importing scipy submodules on some version of Python
+    ignore::ImportWarning
+    # bogus numpy ABI warning (see numpy/#432)
+    ignore:.*numpy.dtype size changed.*:RuntimeWarning
+    ignore:.*numpy.ufunc size changed.*:RuntimeWarning
+    default:The global interpreter lock:RuntimeWarning

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/tests/requirements.txt

@@ -0,0 +1,13 @@
+--only-binary=:all:
+build~=1.0; python_version>="3.7"
+numpy~=1.20.0; python_version=="3.7" and platform_python_implementation=="PyPy"
+numpy~=1.23.0; python_version=="3.8" and platform_python_implementation=="PyPy"
+numpy~=1.25.0; python_version=="3.9" and platform_python_implementation=='PyPy'
+numpy~=1.21.5; platform_python_implementation!="PyPy" and python_version>="3.7" and python_version<"3.10"
+numpy~=1.22.2; platform_python_implementation!="PyPy" and python_version=="3.10"
+numpy~=1.26.0; platform_python_implementation!="PyPy" and python_version>="3.11" and python_version<"3.13"
+pytest~=7.0
+pytest-timeout
+scipy~=1.5.4; platform_python_implementation!="PyPy" and python_version<"3.10"
+scipy~=1.8.0; platform_python_implementation!="PyPy" and python_version=="3.10" and sys_platform!='win32'
+scipy~=1.11.1; platform_python_implementation!="PyPy" and python_version>="3.11" and python_version<"3.13" and sys_platform!='win32'

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/tests/test_async.cpp

@@ -0,0 +1,25 @@
+/*
+    tests/test_async.cpp -- __await__ support
+
+    Copyright (c) 2019 Google Inc.
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "pybind11_tests.h"
+
+TEST_SUBMODULE(async_module, m) {
+    struct DoesNotSupportAsync {};
+    py::class_<DoesNotSupportAsync>(m, "DoesNotSupportAsync").def(py::init<>());
+    struct SupportsAsync {};
+    py::class_<SupportsAsync>(m, "SupportsAsync")
+        .def(py::init<>())
+        .def("__await__", [](const SupportsAsync &self) -> py::object {
+            static_cast<void>(self);
+            py::object loop = py::module_::import("asyncio.events").attr("get_event_loop")();
+            py::object f = loop.attr("create_future")();
+            f.attr("set_result")(5);
+            return f.attr("__await__")();
+        });
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/tests/test_async.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import pytest
+
+asyncio = pytest.importorskip("asyncio")
+m = pytest.importorskip("pybind11_tests.async_module")
+
+
+@pytest.fixture()
+def event_loop():
+    loop = asyncio.new_event_loop()
+    yield loop
+    loop.close()
+
+
+async def get_await_result(x):
+    return await x
+
+
+def test_await(event_loop):
+    assert event_loop.run_until_complete(get_await_result(m.SupportsAsync())) == 5
+
+
+def test_await_missing(event_loop):
+    with pytest.raises(TypeError):
+        event_loop.run_until_complete(get_await_result(m.DoesNotSupportAsync()))