experiment how to get the protocol types to the qt methods

Author: mathisloge

libs/probeqt/rpc/create_snapshot.cpp

@@ -26,8 +26,8 @@ exec::task<void> CreateScreenshotRpcHandler::operator()(CreateScreenshotRPC &rpc
             grpc::Status{grpc::StatusCode::NOT_FOUND, fmt::format("could not find {}", request.object_id())});
         co_return;
     }
-    auto expected_image = co_await stdexec::on(QtStdExec::qThreadAsScheduler(QCoreApplication::instance()->thread()),
-                                               take_snapshot(*object));
+    auto expected_image = co_await stdexec::starts_on(
+        QtStdExec::qThreadAsScheduler(QCoreApplication::instance()->thread()), take_snapshot(*object));
     if (expected_image.has_value())
     {
         constexpr std::int64_t k4Mb = 4000000;

libs/protocol/CMakeLists.txt

@@ -12,6 +12,7 @@ asio_grpc_protobuf_generate(
         "${proto_inc_dir}/keyboard.proto"
         "${proto_inc_dir}/mouse.proto"
         "${proto_inc_dir}/types.proto"
+        "${proto_inc_dir}/methods.proto"
 )
 
 add_library(quite_protocol_proto STATIC)

libs/protocol/quite/proto/methods.proto

@@ -0,0 +1,14 @@
+syntax = "proto3";
+
+package quite.proto;
+
+import "quite/proto/types.proto";
+
+message MethodCall {
+    string method_name = 1;
+    repeated Value arguments = 2;
+};
+
+message MethodReturnValue {
+    optional Value value = 1;
+}

libs/protocol/quite/proto/probe.proto

@@ -5,6 +5,7 @@ import "quite/proto/common.proto";
 import "quite/proto/keyboard.proto";
 import "quite/proto/mouse.proto";
 import "quite/proto/types.proto";
+import "quite/proto/methods.proto";
 
 service ProbeService {
     rpc Exit(ExitRequest) returns (ExitReponse) {}
@@ -16,6 +17,8 @@ service ProbeService {
     rpc CreateScreenshot(ScreenshotRequest) returns (stream ImageResponse) {};
 
     rpc GetViews(GetViewsRequest) returns (GetViewsResponse) {};
+
+    rpc InvokeMethod(MethodCallRequest) returns (MethodCallResponse) {};
 }
 
 message ExitRequest {};
@@ -77,3 +80,12 @@ message GetViewsRequest {
 message GetViewsResponse {
   repeated uint64 object_id = 1;
 }
+
+message MethodCallRequest {
+  uint64 object_id = 1;
+  MethodCall method_call = 2;
+}
+
+message MethodCallResponse {
+  MethodReturnValue return_value = 1;
+}

python/quite/__init__.pyi

@@ -1,5 +1,5 @@
 """
-quite - the (q)t (ui) (te)sting framework. See https://github.com/mathisloge/ng-quite
+quite - a ui testing framework. See https://github.com/mathisloge/ng-quite
 """
 
 from __future__ import annotations

python/quite/_quite.pyi

@@ -1,5 +1,5 @@
 """
-quite - the (q)t (ui) (te)sting framework. See https://github.com/mathisloge/ng-quite
+quite - a ui testing framework. See https://github.com/mathisloge/ng-quite
 """
 
 from __future__ import annotations

test/meta/test_object_registry.cpp

@@ -1,10 +1,10 @@
 #include <QObject>
-#include <atomic>
 #include <catch2/catch_test_macros.hpp>
 #include <entt/meta/factory.hpp>
 #include <fmt/base.h>
 #include <qmetaobject.h>
 #include <quite/proto/types.pb.h>
+#include <value_converters.hpp>
 
 using namespace entt::literals;
 
@@ -93,6 +93,17 @@ TEST_CASE("Register struct and convert it to a protocol value", "[meta,design-te
 class MyOwnClass : public QObject
 {
     Q_OBJECT
+
+  public Q_SLOTS:
+    quint64 compute(quint64 val1, quint8 val2)
+    {
+        return val1 + val2;
+    }
+
+    quint64 compute(float val1, qint8 val2)
+    {
+        return val1 * val2;
+    }
 };
 
 TEST_CASE("API DESIGN META RUNTIME")
@@ -102,4 +113,39 @@ TEST_CASE("API DESIGN META RUNTIME")
     kMetaType.metaObject()->method(0).parameterType(0);
 }
 
+TEST_CASE("Test meta method call")
+{
+    quite::probe::register_converters();
+
+    MyOwnClass test_obj{};
+
+    QByteArray normalized_signature = QMetaObject::normalizedSignature("compute(float, qint8)");
+    const auto *meta_object = test_obj.metaObject();
+    int method_index = meta_object->indexOfMethod(normalized_signature);
+
+    for (int i = 0; i < meta_object->methodCount(); i++)
+    {
+        qDebug() << meta_object->method(i).name();
+    }
+
+    QMetaMethod method = test_obj.metaObject()->method(method_index);
+    REQUIRE(method.isValid());
+
+    auto &&param1 = method.parameterMetaType(0);
+
+    double initial_val{5};
+    REQUIRE(QMetaType::canConvert(QMetaType::fromType<double>(), QMetaType::fromType<float>()));
+    auto *val1 = param1.create();
+    QMetaType::convert(QMetaType::fromType<double>(), &initial_val, param1, val1);
+    QMetaMethodArgument arg3{.metaType = param1.iface(), .name = param1.name(), .data = val1};
+
+    qDebug() << arg3.metaType << arg3.name << arg3.data;
+
+    quint64 result{};
+    auto infoke_result = method.invoke(&test_obj, Qt::DirectConnection, qReturnArg(result), arg3, qint8{5});
+
+    REQUIRE(infoke_result);
+    REQUIRE(result == 25);
+}
+
 #include "test_object_registry.moc"