diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7aea3f6..d104c9a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,7 +6,7 @@ option(SPIX_BUILD_TESTS "Build Spix unit tests." OFF)
 set(SPIX_QT_MAJOR "6" CACHE STRING "Major Qt version to build Spix against")
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake/modules")
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 
 # Hide symbols unless explicitly flagged with SPIX_EXPORT
 set(CMAKE_CXX_VISIBILITY_PRESET hidden)
diff --git a/examples/Basic/CMakeLists.txt b/examples/Basic/CMakeLists.txt
index 23885d3..8018713 100644
--- a/examples/Basic/CMakeLists.txt
+++ b/examples/Basic/CMakeLists.txt
@@ -1,7 +1,7 @@
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 find_package(Qt${SPIX_QT_MAJOR} COMPONENTS Core Quick REQUIRED)
diff --git a/examples/BasicStandalone/CMakeLists.txt b/examples/BasicStandalone/CMakeLists.txt
index 13dfeb7..9e0d296 100644
--- a/examples/BasicStandalone/CMakeLists.txt
+++ b/examples/BasicStandalone/CMakeLists.txt
@@ -8,7 +8,7 @@ set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/../../cmake/modules")
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 #
diff --git a/examples/GTest/CMakeLists.txt b/examples/GTest/CMakeLists.txt
index 385bcdf..8225d32 100644
--- a/examples/GTest/CMakeLists.txt
+++ b/examples/GTest/CMakeLists.txt
@@ -1,7 +1,7 @@
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(SPIX_QT_MAJOR "6" CACHE STRING "Major Qt version to build Spix against")
diff --git a/examples/ListGridView/CMakeLists.txt b/examples/ListGridView/CMakeLists.txt
index a253032..e6d288a 100644
--- a/examples/ListGridView/CMakeLists.txt
+++ b/examples/ListGridView/CMakeLists.txt
@@ -1,7 +1,7 @@
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(SPIX_QT_MAJOR "6" CACHE STRING "Major Qt version to build Spix against")
diff --git a/examples/RemoteCtrl/CMakeLists.txt b/examples/RemoteCtrl/CMakeLists.txt
index 1675293..b59d021 100644
--- a/examples/RemoteCtrl/CMakeLists.txt
+++ b/examples/RemoteCtrl/CMakeLists.txt
@@ -1,7 +1,7 @@
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(SPIX_QT_MAJOR "6" CACHE STRING "Major Qt version to build Spix against")
diff --git a/examples/RepeaterLoader/CMakeLists.txt b/examples/RepeaterLoader/CMakeLists.txt
index 5df7ef5..434d2f6 100644
--- a/examples/RepeaterLoader/CMakeLists.txt
+++ b/examples/RepeaterLoader/CMakeLists.txt
@@ -1,7 +1,7 @@
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(SPIX_QT_MAJOR "6" CACHE STRING "Major Qt version to build Spix against")
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 723de5e..7a270d3 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -54,6 +54,8 @@ set(SOURCES
     src/Commands/GetTestStatus.h
     src/Commands/InputText.cpp
     src/Commands/InputText.h
+    src/Commands/InvokeMethod.cpp
+    src/Commands/InvokeMethod.h
     src/Commands/Quit.cpp
     src/Commands/Quit.h
     src/Commands/Screenshot.cpp
@@ -92,8 +94,10 @@ set(SOURCES
     src/Scene/Qt/QtScene.cpp
     src/Scene/Qt/QtScene.h
     src/Scene/Scene.h
-
+    
+    src/Utils/AnyRpcUtils.cpp
     src/Utils/AnyRpcUtils.h
+    src/Utils/AnyRpcFunction.h
     src/Utils/DebugDump.cpp
     src/Utils/DebugDump.h
     src/Utils/QtEventRecorder.cpp
diff --git a/lib/include/Spix/Data/Variant.h b/lib/include/Spix/Data/Variant.h
new file mode 100644
index 0000000..63a3997
--- /dev/null
+++ b/lib/include/Spix/Data/Variant.h
@@ -0,0 +1,55 @@
+/***
+ * Copyright (C) Noah Koontz. All rights reserved.
+ * Licensed under the MIT license.
+ * See LICENSE.txt file in the project root for full license information.
+ ****/
+
+#pragma once
+
+#include <chrono>
+#include <map>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include <Spix/spix_export.h>
+
+namespace spix {
+
+struct Variant;
+
+namespace {
+using VariantBaseType = std::variant<std::nullptr_t, bool, int64_t, uint64_t, double, std::string,
+    std::chrono::time_point<std::chrono::system_clock>, std::vector<Variant>, std::map<std::string, Variant>>;
+}
+
+// TODO: make this a block comment
+// NOTE: std::visit is broken for this variant for GCC <= 11.2 and clang <= 14.0 . See
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2162r0.html for more info.
+SPIX_EXPORT struct Variant : VariantBaseType {
+    using ListType = std::vector<Variant>;
+    using MapType = std::map<std::string, Variant>;
+    using VariantType = VariantBaseType;
+    using VariantBaseType::variant;
+    VariantBaseType const& base() const { return *this; }
+    VariantBaseType& base() { return *this; }
+
+    enum TypeIndex
+    {
+        Nullptr = 0,
+        Bool,
+        Int64,
+        Uint64,
+        Double,
+        String,
+        Time,
+        List,
+        Map,
+        TypeIndexCount
+    };
+};
+
+static_assert(
+    Variant::TypeIndexCount == std::variant_size_v<VariantBaseType>, "Variant enum does not cover all Variant types");
+
+} // namespace spix
diff --git a/lib/include/Spix/TestServer.h b/lib/include/Spix/TestServer.h
index 65bd32b..f3da289 100644
--- a/lib/include/Spix/TestServer.h
+++ b/lib/include/Spix/TestServer.h
@@ -13,6 +13,7 @@
 
 #include <Spix/Data/Geometry.h>
 #include <Spix/Data/ItemPath.h>
+#include <Spix/Data/Variant.h>
 #include <Spix/Events/Identifiers.h>
 
 #include <Spix/spix_export.h>
@@ -57,6 +58,7 @@ class SPIX_EXPORT TestServer {
 
     std::string getStringProperty(ItemPath path, std::string propertyName);
     void setStringProperty(ItemPath path, std::string propertyName, std::string propertyValue);
+    Variant invokeMethod(ItemPath path, std::string method, std::vector<Variant> args);
     Rect getBoundingBox(ItemPath path);
     bool existsAndVisible(ItemPath path);
     std::vector<std::string> getErrors();
diff --git a/lib/src/AnyRpcServer.cpp b/lib/src/AnyRpcServer.cpp
index 7e275f4..4551daf 100644
--- a/lib/src/AnyRpcServer.cpp
+++ b/lib/src/AnyRpcServer.cpp
@@ -5,8 +5,8 @@
  ****/
 
 #include <Spix/AnyRpcServer.h>
-#include <Utils/AnyRpcUtils.h>
-#include <anyrpc/anyrpc.h>
+#include <Spix/Data/Variant.h>
+#include <Utils/AnyRpcFunction.h>
 #include <atomic>
 
 namespace spix {
@@ -70,6 +70,12 @@ AnyRpcServer::AnyRpcServer(int anyrpcPort)
             setStringProperty(std::move(path), std::move(property), std::move(value));
         });
 
+    utils::AddFunctionToAnyRpc<Variant(std::string, std::string, std::vector<Variant>)>(methodManager, "invokeMethod",
+        "Invoke a method on a QML object | invokeMethod(string path, string method, any[] args)",
+        [this](std::string path, std::string method, std::vector<Variant> args) {
+            return invokeMethod(std::move(path), std::move(method), std::move(args));
+        });
+
     utils::AddFunctionToAnyRpc<std::vector<double>(std::string)>(methodManager, "getBoundingBox",
         "Return the bounding box of an item in screen coordinates | getBoundingBox(string path) : (doubles) "
         "[topLeft.x, topLeft.y , width, height]",
diff --git a/lib/src/Commands/InvokeMethod.cpp b/lib/src/Commands/InvokeMethod.cpp
new file mode 100644
index 0000000..1ec0ad8
--- /dev/null
+++ b/lib/src/Commands/InvokeMethod.cpp
@@ -0,0 +1,39 @@
+/***
+ * Copyright (C) Falko Axmann. All rights reserved.
+ * Licensed under the MIT license.
+ * See LICENSE.txt file in the project root for full license information.
+ ****/
+
+#include "InvokeMethod.h"
+
+#include <Scene/Scene.h>
+
+namespace spix {
+namespace cmd {
+
+InvokeMethod::InvokeMethod(ItemPath path, std::string method, std::vector<Variant> args, std::promise<Variant> promise)
+: m_path(std::move(path))
+, m_method(std::move(method))
+, m_args(std::move(args))
+, m_promise(std::move(promise))
+{
+}
+
+void InvokeMethod::execute(CommandEnvironment& env)
+{
+    auto item = env.scene().itemAtPath(m_path);
+
+    if (item) {
+        Variant ret;
+        bool success = item->invokeMethod(m_method, m_args, ret);
+        if (!success)
+            env.state().reportError("InvokeMethod: Failed to invoke method: " + m_method);
+        m_promise.set_value(ret);
+    } else {
+        env.state().reportError("InvokeMethod: Item not found: " + m_path.string());
+        m_promise.set_value(Variant(nullptr));
+    }
+}
+
+} // namespace cmd
+} // namespace spix
diff --git a/lib/src/Commands/InvokeMethod.h b/lib/src/Commands/InvokeMethod.h
new file mode 100644
index 0000000..e269215
--- /dev/null
+++ b/lib/src/Commands/InvokeMethod.h
@@ -0,0 +1,34 @@
+/***
+ * Copyright (C) Falko Axmann. All rights reserved.
+ * Licensed under the MIT license.
+ * See LICENSE.txt file in the project root for full license information.
+ ****/
+
+#pragma once
+
+#include <Spix/spix_export.h>
+
+#include "Command.h"
+#include <Spix/Data/ItemPath.h>
+#include <Spix/Data/Variant.h>
+
+#include <future>
+
+namespace spix {
+namespace cmd {
+
+class SPIX_EXPORT InvokeMethod : public Command {
+public:
+    InvokeMethod(ItemPath path, std::string method, std::vector<Variant> args, std::promise<Variant> promise);
+
+    void execute(CommandEnvironment& env) override;
+
+private:
+    ItemPath m_path;
+    std::string m_method;
+    std::vector<Variant> m_args;
+    std::promise<Variant> m_promise;
+};
+
+} // namespace cmd
+} // namespace spix
diff --git a/lib/src/QtQmlBot.cpp b/lib/src/QtQmlBot.cpp
index 46f8e57..b3f67cd 100644
--- a/lib/src/QtQmlBot.cpp
+++ b/lib/src/QtQmlBot.cpp
@@ -7,6 +7,7 @@
 #include <Spix/QtQmlBot.h>
 
 #include <CommandExecuter/CommandExecuter.h>
+#include <QtDebug>
 #include <Scene/Qt/QtScene.h>
 #include <Spix/TestServer.h>
 
@@ -24,6 +25,7 @@ QtQmlBot::~QtQmlBot() = default;
 
 void QtQmlBot::runTestServer(TestServer& server)
 {
+    qInfo() << "Spix server is enabled. Only use this in a safe environment.";
     server.setCommandExecuter(m_cmdExec.get());
     server.start();
 }
diff --git a/lib/src/Scene/Item.h b/lib/src/Scene/Item.h
index c76779d..0d3e887 100644
--- a/lib/src/Scene/Item.h
+++ b/lib/src/Scene/Item.h
@@ -7,6 +7,7 @@
 #pragma once
 
 #include <Spix/Data/Geometry.h>
+#include <Spix/Data/Variant.h>
 
 #include <string>
 
@@ -29,6 +30,7 @@ class Item {
     virtual Rect bounds() const = 0;
     virtual std::string stringProperty(const std::string& name) const = 0;
     virtual void setStringProperty(const std::string& name, const std::string& value) = 0;
+    virtual bool invokeMethod(const std::string& method, const std::vector<Variant>& args, Variant& ret) = 0;
     virtual bool visible() const = 0;
 };
 
diff --git a/lib/src/Scene/Mock/MockItem.cpp b/lib/src/Scene/Mock/MockItem.cpp
index e7a266d..1267a57 100644
--- a/lib/src/Scene/Mock/MockItem.cpp
+++ b/lib/src/Scene/Mock/MockItem.cpp
@@ -40,6 +40,12 @@ void MockItem::setStringProperty(const std::string& name, const std::string& val
 {
 }
 
+bool MockItem::invokeMethod(const std::string& method, const std::vector<Variant>& args, Variant& ret)
+{
+    ret = Variant(nullptr);
+    return true;
+}
+
 bool MockItem::visible() const
 {
     return true;
diff --git a/lib/src/Scene/Mock/MockItem.h b/lib/src/Scene/Mock/MockItem.h
index fa89092..09ef388 100644
--- a/lib/src/Scene/Mock/MockItem.h
+++ b/lib/src/Scene/Mock/MockItem.h
@@ -10,8 +10,6 @@
 
 #include <Scene/Item.h>
 
-#include <map>
-
 namespace spix {
 
 class SPIX_EXPORT MockItem : public Item {
@@ -24,6 +22,7 @@ class SPIX_EXPORT MockItem : public Item {
     Rect bounds() const override;
     std::string stringProperty(const std::string& name) const override;
     void setStringProperty(const std::string& name, const std::string& value) override;
+    bool invokeMethod(const std::string& method, const std::vector<Variant>& args, Variant& ret) override;
     bool visible() const override;
 
     // MockItem specials
diff --git a/lib/src/Scene/Qt/QtItem.cpp b/lib/src/Scene/Qt/QtItem.cpp
index cd364aa..e848686 100644
--- a/lib/src/Scene/Qt/QtItem.cpp
+++ b/lib/src/Scene/Qt/QtItem.cpp
@@ -6,8 +6,13 @@
 
 #include "QtItem.h"
 
+#include <sstream>
+
+#include <QMetaObject>
 #include <QQuickItem>
 
+#include <Scene/Qt/QtItemTools.h>
+
 namespace spix {
 
 QtItem::QtItem(QQuickItem* item)
@@ -49,6 +54,41 @@ void QtItem::setStringProperty(const std::string& name, const std::string& value
     m_item->setProperty(name.c_str(), value.c_str());
 }
 
+bool QtItem::invokeMethod(const std::string& method, const std::vector<Variant>& args, Variant& ret)
+{
+    if (args.size() > 10)
+        return false;
+
+    std::vector<QVariant> qtVars;
+    for (auto arg : args)
+        qtVars.push_back(qt::VariantToQVariant(arg));
+
+    QMetaMethod match;
+    bool matched = spix::qt::GetMethodMetaForArgs(*m_item, method, qtVars, match);
+    if (!matched)
+        return false;
+    // qDebug() << "Method: " << match.methodSignature();
+    // qDebug() << "Args: ";
+    // qDebug() << "Return type:" << match.returnMetaType().name();
+
+    qt::QMLReturnVariant retVar;
+    QGenericReturnArgument retArg = qt::GetReturnArgForQMetaType(match.returnType(), retVar);
+    std::vector<QGenericArgument> qtArgs = qt::ConvertAndCreateQArgumentsForMethod(match, qtVars);
+
+    bool success = match.invoke(m_item, Qt::ConnectionType::DirectConnection, retArg, qtArgs[0], qtArgs[1], qtArgs[2],
+        qtArgs[3], qtArgs[4], qtArgs[5], qtArgs[6], qtArgs[7], qtArgs[8], qtArgs[9]);
+    if (success) {
+        ret = qt::QMLReturnVariantToVariant(retVar);
+
+        // std::stringstream log;
+        // ret.WriteStream(log);
+        // qDebug() << "Ret: " << log.str().data();
+
+        return true;
+    }
+    return false;
+}
+
 bool QtItem::visible() const
 {
     return m_item->isVisible();
diff --git a/lib/src/Scene/Qt/QtItem.h b/lib/src/Scene/Qt/QtItem.h
index 134e1a2..1ee4711 100644
--- a/lib/src/Scene/Qt/QtItem.h
+++ b/lib/src/Scene/Qt/QtItem.h
@@ -22,6 +22,7 @@ class QtItem : public Item {
     Rect bounds() const override;
     std::string stringProperty(const std::string& name) const override;
     void setStringProperty(const std::string& name, const std::string& value) override;
+    bool invokeMethod(const std::string& method, const std::vector<Variant>& args, Variant& ret) override;
     bool visible() const override;
 
     QQuickItem* qquickitem();
diff --git a/lib/src/Scene/Qt/QtItemTools.cpp b/lib/src/Scene/Qt/QtItemTools.cpp
index ef54c33..8b80d9c 100644
--- a/lib/src/Scene/Qt/QtItemTools.cpp
+++ b/lib/src/Scene/Qt/QtItemTools.cpp
@@ -6,6 +6,7 @@
 
 #include "QtItemTools.h"
 
+#include <QDateTime>
 #include <QQmlContext>
 #include <QQuickItem>
 
@@ -85,5 +86,209 @@ QObject* FindChildItem(QObject* object, const QString& name)
     return nullptr;
 }
 
+QGenericReturnArgument GetReturnArgForQMetaType(int type, QMLReturnVariant& retVar)
+{
+    switch (type) {
+    case QMetaType::Type::Void:
+        retVar = nullptr;
+        return QGenericReturnArgument();
+    case QMetaType::Type::Bool:
+        retVar = bool();
+        return Q_RETURN_ARG(bool, std::get<bool>(retVar));
+    case QMetaType::Type::Int:
+        retVar = int();
+        return Q_RETURN_ARG(int, std::get<int>(retVar));
+    case QMetaType::Type::Float:
+        retVar = float();
+        return Q_RETURN_ARG(float, std::get<float>(retVar));
+    case QMetaType::Type::Double:
+        retVar = double();
+        return Q_RETURN_ARG(double, std::get<double>(retVar));
+    case QMetaType::Type::QString:
+        retVar = QString();
+        return Q_RETURN_ARG(QString, std::get<QString>(retVar));
+    case QMetaType::Type::QDateTime:
+        retVar = QDateTime();
+        return Q_RETURN_ARG(QDateTime, std::get<QDateTime>(retVar));
+    default:
+        retVar = QVariant();
+        return Q_RETURN_ARG(QVariant, std::get<QVariant>(retVar));
+    }
+}
+
+QVariant VariantToQVariant(const Variant& var)
+{
+    static_assert(Variant::TypeIndexCount == 9, "VariantToQVariant does not cover all Variant types");
+
+    switch (var.index()) {
+    case Variant::Nullptr:
+        return QVariant();
+    case Variant::Bool:
+        return QVariant(std::get<bool>(var));
+    case Variant::Int64:
+        return QVariant(static_cast<qlonglong>(std::get<int64_t>(var)));
+    case Variant::Uint64:
+        return QVariant(static_cast<qulonglong>(std::get<uint64_t>(var)));
+    case Variant::Double:
+        return QVariant(std::get<double>(var));
+    case Variant::String:
+        return QVariant(QString::fromStdString(std::get<std::string>(var)));
+    case Variant::Time: {
+        auto time = std::get<std::chrono::time_point<std::chrono::system_clock>>(var);
+        std::time_t timet = std::chrono::system_clock::to_time_t(time);
+        return QVariant(QDateTime::fromSecsSinceEpoch(timet));
+    }
+    case Variant::List: {
+        QVariantList list;
+        for (const auto& elem : std::get<Variant::ListType>(var))
+            list.push_back(VariantToQVariant(elem));
+        return QVariant(list);
+    }
+    case Variant::Map: {
+        QVariantMap map;
+        for (const auto& [key, value] : std::get<Variant::MapType>(var))
+            map.insert(QString::fromStdString(key), VariantToQVariant(value));
+        return QVariant(map);
+    }
+    default:
+        throw std::range_error("VariantToQVariant received Variant with unknown type");
+    }
+}
+
+Variant QVariantToVariant(const QVariant& var)
+{
+    qDebug() << var.typeName();
+    switch (static_cast<QMetaType::Type>(var.type())) {
+    case QMetaType::Type::Bool:
+        return Variant(var.toBool());
+    case QMetaType::Type::Char:
+    case QMetaType::Type::SChar:
+    case QMetaType::Type::Short:
+    case QMetaType::Type::Int:
+    case QMetaType::Type::Long:
+    case QMetaType::Type::LongLong:
+        return Variant(static_cast<int64_t>(var.toLongLong()));
+    case QMetaType::Type::UChar:
+    case QMetaType::Type::UShort:
+    case QMetaType::Type::UInt:
+    case QMetaType::Type::ULong:
+    case QMetaType::Type::ULongLong:
+        return Variant(static_cast<uint64_t>(var.toULongLong()));
+    case QMetaType::Type::Float:
+    case QMetaType::Type::Double:
+        return Variant(var.toDouble());
+    case QMetaType::Type::QDateTime: {
+        std::time_t time = var.toDateTime().currentSecsSinceEpoch();
+        return Variant(std::chrono::system_clock::from_time_t(time));
+    }
+    case QMetaType::Type::QString:
+        return Variant(var.toString().toStdString());
+    case QMetaType::Type::Nullptr:
+    case QMetaType::Type::Void:
+    case QMetaType::Type::UnknownType:
+        return Variant(nullptr);
+    default:
+        break;
+    }
+
+    if (var.type() == qMetaTypeId<QJSValue>()) {
+        QJSValue jsval = var.value<QJSValue>();
+        return QVariantToVariant(jsval.toVariant());
+    }
+
+    if (var.canConvert(QMetaType::Type::QVariantList)) {
+        const QVariantList& list = var.toList();
+        Variant::ListType ret;
+        for (const QVariant& elem : list) {
+            Variant convertedElem = QVariantToVariant(elem);
+            ret.push_back(convertedElem);
+        }
+        return Variant(ret);
+    }
+
+    if (var.canConvert(QMetaType::Type::QVariantMap)) {
+        const QVariantMap& map = var.toMap();
+        Variant::MapType ret;
+        for (auto ptr = map.constBegin(); ptr != map.constEnd(); ptr++) {
+            Variant convertedElem = QVariantToVariant(ptr.value());
+            ret[ptr.key().toStdString()] = convertedElem;
+        }
+        return Variant(ret);
+    }
+
+    return Variant(var.toString().toStdString());
+}
+
+Variant QMLReturnVariantToVariant(const QMLReturnVariant& var)
+{
+    return std::visit(
+        [](auto&& arg) {
+            using T = std::decay_t<decltype(arg)>;
+
+            if constexpr (std::is_integral_v<T>) {
+                return Variant(static_cast<int64_t>(arg));
+            } else if constexpr (std::is_unsigned_v<T>) {
+                return Variant(static_cast<uint64_t>(arg));
+            } else if constexpr (std::is_floating_point_v<T>) {
+                return Variant(static_cast<double>(arg));
+            } else if constexpr (std::is_same_v<T, QString>) {
+                return Variant(arg.toStdString());
+            } else if constexpr (std::is_same_v<T, QDateTime>) {
+                return Variant(std::chrono::system_clock::from_time_t(arg.toLocalTime().toSecsSinceEpoch()));
+            } else if constexpr (std::is_same_v<T, QVariant>) {
+                return QVariantToVariant(arg);
+            } else {
+                return Variant(arg);
+            }
+        },
+        var);
+}
+
+bool CanConvertArgTypes(const QMetaMethod& metaMethod, const std::vector<QVariant>& varargs)
+{
+    if (metaMethod.parameterCount() != varargs.size())
+        return false;
+    for (size_t i = 0; i < metaMethod.parameterCount(); i++) {
+        int targetType = metaMethod.parameterType(i);
+        if (targetType != QMetaType::Type::QVariant && !varargs[i].canConvert(targetType))
+            return false;
+    }
+    return true;
+}
+
+bool GetMethodMetaForArgs(
+    const QObject& obj, const std::string& method, const std::vector<QVariant>& varargs, QMetaMethod& ret)
+{
+    const QMetaObject* itemMeta = obj.metaObject();
+    for (size_t i = 0; i < itemMeta->methodCount(); i++) {
+        const QMetaMethod methodMeta = itemMeta->method(i);
+        qDebug() << "Signature: " << methodMeta.methodSignature();
+        if (methodMeta.name().compare(method.data()) == 0 && CanConvertArgTypes(methodMeta, varargs)) {
+            ret = methodMeta;
+            return true;
+        }
+    }
+    return false;
+}
+
+std::vector<QGenericArgument> ConvertAndCreateQArgumentsForMethod(
+    const QMetaMethod& metaMethod, std::vector<QVariant>& varargs)
+{
+    std::vector<QGenericArgument> qtArgs;
+    for (size_t i = 0; i < 10; i++) {
+        if (i < varargs.size()) {
+            int targetType = metaMethod.parameterType(i);
+            if (targetType != QMetaType::Type::QVariant) {
+                varargs[i].convert(targetType);
+                qtArgs.push_back(QGenericArgument(varargs[i].typeName(), varargs[i].data()));
+            } else {
+                qtArgs.push_back(Q_ARG(QVariant, varargs[i]));
+            }
+        } else
+            qtArgs.push_back(QGenericArgument());
+    }
+    return qtArgs;
+}
+
 } // namespace qt
 } // namespace spix
diff --git a/lib/src/Scene/Qt/QtItemTools.h b/lib/src/Scene/Qt/QtItemTools.h
index e125f87..dce53ef 100644
--- a/lib/src/Scene/Qt/QtItemTools.h
+++ b/lib/src/Scene/Qt/QtItemTools.h
@@ -6,8 +6,12 @@
 
 #pragma once
 
+#include <Spix/Data/Variant.h>
+
+#include <QDateTime>
 #include <QObject>
 #include <QQuickItem>
+#include <QVariant>
 
 class QString;
 
@@ -37,5 +41,18 @@ T FindChildItem(QObject* object, const QString& name)
     return qobject_cast<T>(FindChildItem(object, name));
 }
 
+using QMLReturnVariant = std::variant<std::nullptr_t, bool, int, float, double, QString, QDateTime, QVariant>;
+QGenericReturnArgument GetReturnArgForQMetaType(int type, QMLReturnVariant& toInitialize);
+
+QVariant VariantToQVariant(const Variant& var);
+Variant QVariantToVariant(const QVariant& var);
+Variant QMLReturnVariantToVariant(const QMLReturnVariant& var);
+
+bool CanConvertArgTypes(const QMetaMethod& metaMethod, const std::vector<QVariant>& varargs);
+bool GetMethodMetaForArgs(
+    const QObject& obj, const std::string& method, const std::vector<QVariant>& varargs, QMetaMethod& ret);
+std::vector<QGenericArgument> ConvertAndCreateQArgumentsForMethod(
+    const QMetaMethod& metaMethod, std::vector<QVariant>& varargs);
+
 } // namespace qt
 } // namespace spix
diff --git a/lib/src/TestServer.cpp b/lib/src/TestServer.cpp
index c2ccc84..45eee1e 100644
--- a/lib/src/TestServer.cpp
+++ b/lib/src/TestServer.cpp
@@ -19,6 +19,7 @@
 #include <Commands/GetProperty.h>
 #include <Commands/GetTestStatus.h>
 #include <Commands/InputText.h>
+#include <Commands/InvokeMethod.h>
 #include <Commands/Quit.h>
 #include <Commands/Screenshot.h>
 #include <Commands/SetProperty.h>
@@ -119,6 +120,16 @@ void TestServer::setStringProperty(ItemPath path, std::string propertyName, std:
     m_cmdExec->enqueueCommand<cmd::SetProperty>(path, std::move(propertyName), std::move(propertyValue));
 }
 
+Variant TestServer::invokeMethod(ItemPath path, std::string method, std::vector<Variant> args)
+{
+    std::promise<Variant> promise;
+    auto result = promise.get_future();
+    auto cmd = std::make_unique<cmd::InvokeMethod>(path, std::move(method), std::move(args), std::move(promise));
+    m_cmdExec->enqueueCommand(std::move(cmd));
+
+    return result.get();
+}
+
 Rect TestServer::getBoundingBox(ItemPath path)
 {
     std::promise<Rect> promise;
diff --git a/lib/src/Utils/AnyRpcFunction.h b/lib/src/Utils/AnyRpcFunction.h
new file mode 100644
index 0000000..e3870be
--- /dev/null
+++ b/lib/src/Utils/AnyRpcFunction.h
@@ -0,0 +1,190 @@
+/***
+ * Copyright (C) Falko Axmann. All rights reserved.
+ * Licensed under the MIT license.
+ * See LICENSE.txt file in the project root for full license information.
+ ****/
+
+#pragma once
+
+#include <Spix/Data/Variant.h>
+#include <Utils/AnyRpcUtils.h>
+#include <anyrpc/anyrpc.h>
+#include <functional>
+
+/**
+ * Utility type traits
+ */
+
+namespace {
+template <class T, template <class...> class Template>
+struct is_specialization : std::false_type {
+};
+
+template <template <class...> class Template, class... Args>
+struct is_specialization<Template<Args...>, Template> : std::true_type {
+};
+} // namespace
+
+/**
+ * The templates in this file make it easier to register functions with AnyRPC.
+ * It is now sufficient to register a function. The parameter parsing will automatically
+ * be adapted to the signature of the function, including type checks and conversion.
+ */
+
+namespace spix {
+namespace utils {
+/**
+ * Tools to convert an anyrpc::Value to a
+ * particular type. If the requested type does not
+ * match the content of the anyrpc::Value, an excption
+ * is thrown.
+ **/
+template <typename T>
+T unpackAnyRpcParam(anyrpc::Value&);
+
+template <>
+Variant unpackAnyRpcParam(anyrpc::Value& value)
+{
+    return AnyRPCValueToVariant(value);
+}
+
+template <>
+std::vector<Variant> unpackAnyRpcParam(anyrpc::Value& value)
+{
+    if (!value.IsArray()) {
+        throw anyrpc::AnyRpcException(anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Array.");
+    }
+    std::vector<Variant> result;
+    for (size_t i = 0; i < value.Size(); i++)
+        result.push_back(AnyRPCValueToVariant(value[i]));
+    return result;
+}
+
+template <>
+int unpackAnyRpcParam(anyrpc::Value& value)
+{
+    if (!value.IsNumber()) {
+        throw anyrpc::AnyRpcException(anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Int.");
+    }
+    return value.GetInt();
+}
+
+template <>
+unsigned unpackAnyRpcParam(anyrpc::Value& value)
+{
+    if (!value.IsUint()) {
+        throw anyrpc::AnyRpcException(anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Int.");
+    }
+    return value.GetUint();
+}
+
+template <>
+std::string unpackAnyRpcParam(anyrpc::Value& value)
+{
+    if (!value.IsString()) {
+        throw anyrpc::AnyRpcException(anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected String.");
+    }
+    return value.GetString();
+}
+
+template <>
+std::vector<std::string> unpackAnyRpcParam(anyrpc::Value& value)
+{
+    if (!value.IsArray()) {
+        throw anyrpc::AnyRpcException(
+            anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Array of Strings.");
+    }
+    std::vector<std::string> result;
+    result.reserve(value.Size());
+    for (size_t i = 0; i < value.Size(); ++i) {
+        if (!value[i].IsString()) {
+            throw anyrpc::AnyRpcException(
+                anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Array of Strings.");
+        }
+        result.push_back(value[i].GetString());
+    }
+
+    return result;
+}
+
+/**
+ * Functions that call a std::function and assign its returned
+ * value to the given anyrpc::Value. If the return type
+ * of the std::function is 'void', no value is assigned.
+ */
+
+template <typename R, typename... Args>
+void callAndAssignAnyRpcResult(std::function<R(Args...)> func, anyrpc::Value& result, Args... args)
+{
+    if constexpr (std::is_void_v<R>) {
+        func(std::forward<Args>(args)...);
+    } else {
+        R funcResult = func(std::forward<Args>(args)...);
+
+        if constexpr (is_specialization<R, std::vector>::value) {
+            result.SetArray();
+            for (const auto& item : funcResult) {
+                anyrpc::Value value {item};
+                result.PushBack(value);
+            }
+        } else if constexpr (std::is_same_v<R, Variant>) {
+            result = VariantToAnyRPCValue(funcResult);
+        } else {
+            result = funcResult;
+        }
+    }
+}
+
+template <typename... Args, std::size_t... Is, typename F>
+void unpackCallAndAssignAnyRpcResult(F func, anyrpc::Value& result, std::index_sequence<Is...>, anyrpc::Value& params)
+{
+    callAndAssignAnyRpcResult(func, result, unpackAnyRpcParam<Args>(params[Is])...);
+}
+
+/**
+ * The AnyRpcFunction object that takes a std::function that is
+ * to be called. The parameters received from AnyRPC are automatically
+ * converted and type checked to the correct type based on the function signature.
+ **/
+template <typename F>
+class AnyRpcFunction;
+
+template <typename R, typename... Args>
+class AnyRpcFunction<R(Args...)> : public anyrpc::Method {
+public:
+    AnyRpcFunction(
+        std::function<R(Args...)> func, const std::string& name, const std::string& help, bool deleteOnRemove = true)
+    : anyrpc::Method(name, help, deleteOnRemove)
+    , m_func(func)
+    {
+    }
+
+    void Execute(anyrpc::Value& params, anyrpc::Value& result) override
+    {
+        if (!params.IsArray()) {
+            throw anyrpc::AnyRpcException(anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Array.");
+        }
+        if (params.Size() != sizeof...(Args)) {
+            throw anyrpc::AnyRpcException(
+                anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Number of parameters incorrect.");
+        }
+
+        unpackCallAndAssignAnyRpcResult<Args...>(m_func, result, std::make_index_sequence<sizeof...(Args)>(), params);
+    }
+
+private:
+    std::function<R(Args...)> m_func;
+};
+
+/**
+ * Helper function to add a std::function based function to AnyRPC.
+ **/
+template <typename F>
+void AddFunctionToAnyRpc(
+    anyrpc::MethodManager* manager, const std::string& name, const std::string& help, std::function<F> func)
+{
+    manager->AddMethod(new utils::AnyRpcFunction<F>(func, name, help, true));
+}
+
+} // namespace utils
+} // namespace spix
diff --git a/lib/src/Utils/AnyRpcUtils.cpp b/lib/src/Utils/AnyRpcUtils.cpp
new file mode 100644
index 0000000..708c37f
--- /dev/null
+++ b/lib/src/Utils/AnyRpcUtils.cpp
@@ -0,0 +1,110 @@
+/***
+ * Copyright (C) Noah Koontz. All rights reserved.
+ * Licensed under the MIT license.
+ * See LICENSE.txt file in the project root for full license information.
+ ****/
+
+#include "AnyRpcUtils.h"
+
+namespace spix {
+namespace utils {
+
+Variant AnyRPCValueToVariant(const anyrpc::Value& valueConst)
+{
+    anyrpc::Value value(valueConst);
+
+    switch (value.GetType()) {
+    case anyrpc::ValueType::FalseType:
+        return Variant(false);
+    case anyrpc::ValueType::TrueType:
+        return Variant(true);
+    case anyrpc::ValueType::StringType:
+        return Variant(std::string(value.GetString()));
+    case anyrpc::ValueType::NumberType:
+        if (value.IsDouble() || value.IsFloat())
+            return Variant(value.GetDouble());
+        if (value.IsInt() || value.IsInt64())
+            return Variant(value.GetInt64());
+        if (value.IsUint() || value.IsUint64())
+            return Variant(value.GetUint64());
+        else
+            return Variant(nullptr);
+    case anyrpc::ValueType::DateTimeType: {
+        const std::time_t time = value.GetDateTime();
+        return Variant(std::chrono::system_clock::from_time_t(time));
+    }
+    case anyrpc::ValueType::ArrayType: {
+        Variant::ListType list;
+        for (std::size_t i = 0; i < value.Size(); i++)
+            list.push_back(AnyRPCValueToVariant(value[i]));
+        return Variant(list);
+    }
+    case anyrpc::ValueType::MapType: {
+        Variant::MapType map;
+        for (auto ptr = value.MemberBegin(); ptr != value.MemberEnd(); ptr++) {
+            anyrpc::Value key = ptr.GetKey();
+            if (!key.IsString())
+                throw anyrpc::AnyRpcException(
+                    anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters: dict keys must be a string.");
+            map[key.GetString()] = AnyRPCValueToVariant(ptr.GetValue());
+        }
+        return Variant(map);
+    }
+    case anyrpc::ValueType::NullType:
+        return Variant(nullptr);
+    case anyrpc::ValueType::BinaryType:
+    case anyrpc::ValueType::InvalidType:
+    default:
+        throw anyrpc::AnyRpcException(anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters: unknown parameter type");
+    }
+}
+
+anyrpc::Value VariantToAnyRPCValue(const Variant& value)
+{
+    // missing std::visit here :'(
+    static_assert(Variant::TypeIndexCount == 9, "VariantToAnyRPCValue does not cover all Variant types");
+    switch (value.index()) {
+    case Variant::Nullptr:
+        return anyrpc::Value();
+    case Variant::Bool:
+        return anyrpc::Value(std::get<bool>(value));
+    case Variant::Int64:
+        return anyrpc::Value(std::get<int64_t>(value));
+    case Variant::Uint64:
+        return anyrpc::Value(std::get<uint64_t>(value));
+    case Variant::Double:
+        return anyrpc::Value(std::get<double>(value));
+    case Variant::String:
+        return anyrpc::Value(std::get<std::string>(value));
+    case Variant::Time: {
+        auto time = std::get<std::chrono::time_point<std::chrono::system_clock>>(value);
+        std::time_t timet = std::chrono::system_clock::to_time_t(time);
+        anyrpc::Value ret;
+        ret.SetDateTime(timet);
+        return ret;
+    }
+    case Variant::List: {
+        anyrpc::Value ret;
+        ret.SetArray();
+        for (const auto& elem : std::get<Variant::ListType>(value)) {
+            anyrpc::Value val = VariantToAnyRPCValue(elem);
+            ret.PushBack(val);
+        }
+        return ret;
+    }
+    case Variant::Map: {
+        anyrpc::Value ret;
+        ret.SetMap();
+        for (const auto& [key, value] : std::get<Variant::MapType>(value)) {
+            anyrpc::Value temp = VariantToAnyRPCValue(value);
+            ret.AddMember(key, temp);
+        }
+        return ret;
+    }
+    default:
+        throw std::range_error("VariantToAnyRPCValue received Variant with unknown type");
+    }
+}
+
+} // namespace utils
+} // namespace spix
diff --git a/lib/src/Utils/AnyRpcUtils.h b/lib/src/Utils/AnyRpcUtils.h
index 8af6cd6..0bd076c 100644
--- a/lib/src/Utils/AnyRpcUtils.h
+++ b/lib/src/Utils/AnyRpcUtils.h
@@ -6,167 +6,14 @@
 
 #pragma once
 
+#include <Spix/Data/Variant.h>
 #include <anyrpc/anyrpc.h>
-#include <functional>
-
-/**
- * The templates in this file make it easier to register functions with AnyRPC.
- * It is now sufficient to register a function. The parameter parsing will automatically
- * be adapted to the signature of the function, including type checks and conversion.
- */
 
 namespace spix {
 namespace utils {
 
-/**
- * Generic type traits
- */
-template <class T>
-struct is_std_vector {
-    static const bool value = false;
-};
-
-template <class T>
-struct is_std_vector<std::vector<T>> {
-    static const bool value = true;
-};
-
-/**
- * Tools to convert an anyrpc::Value to a
- * particular type. If the requested type does not
- * match the content of the anyrpc::Value, an excption
- * is thrown.
- **/
-template <typename T>
-T unpackAnyRpcParam(anyrpc::Value&);
-
-template <>
-int unpackAnyRpcParam(anyrpc::Value& value)
-{
-    if (!value.IsNumber()) {
-        throw anyrpc::AnyRpcException(anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Int.");
-    }
-    return value.GetInt();
-}
-
-template <>
-unsigned unpackAnyRpcParam(anyrpc::Value& value)
-{
-    if (!value.IsUint()) {
-        throw anyrpc::AnyRpcException(anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Int.");
-    }
-    return value.GetUint();
-}
-
-template <>
-std::string unpackAnyRpcParam(anyrpc::Value& value)
-{
-    if (!value.IsString()) {
-        throw anyrpc::AnyRpcException(anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected String.");
-    }
-    return value.GetString();
-}
-
-template <>
-std::vector<std::string> unpackAnyRpcParam(anyrpc::Value& value)
-{
-    if (!value.IsArray()) {
-        throw anyrpc::AnyRpcException(
-            anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Array of Strings.");
-    }
-    std::vector<std::string> result;
-    result.reserve(value.Size());
-    for (size_t i = 0; i < value.Size(); ++i) {
-        if (!value[i].IsString()) {
-            throw anyrpc::AnyRpcException(
-                anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Array of Strings.");
-        }
-        result.push_back(value[i].GetString());
-    }
-
-    return result;
-}
-
-/**
- * Functions that call a std::function and assign its returned
- * value to the given anyrpc::Value. If the return type
- * of the std::function is 'void', no value is assigned.
- */
-template <typename R, typename = std::enable_if_t<!std::is_void<R>::value>,
-    typename = std::enable_if_t<!is_std_vector<R>::value>, typename... Args>
-void callAndAssignAnyRpcResult(std::function<R(Args...)> func, anyrpc::Value& result, Args... args)
-{
-    result = func(std::forward<Args>(args)...);
-}
-
-template <typename R, typename... Args>
-void callAndAssignAnyRpcResult(std::function<std::vector<R>(Args...)> func, anyrpc::Value& result, Args... args)
-{
-    auto funcResult = func(std::forward<Args>(args)...);
-
-    result.SetArray();
-    for (const auto& item : funcResult) {
-        anyrpc::Value value {item};
-        result.PushBack(value);
-    }
-}
-
-template <typename... Args>
-void callAndAssignAnyRpcResult(std::function<void(Args...)> func, anyrpc::Value& /*result*/, Args... args)
-{
-    func(std::forward<Args>(args)...);
-}
-
-template <typename... Args, std::size_t... Is, typename F>
-void callAndAssignAnyRpcResult(F func, anyrpc::Value& result, std::index_sequence<Is...>, anyrpc::Value& params)
-{
-    callAndAssignAnyRpcResult(func, result, unpackAnyRpcParam<Args>(params[Is])...);
-}
-
-/**
- * The AnyRpcFunction object that takes a std::function that is
- * to be called. The parameters received from AnyRPC are automatically
- * converted and type checked to the correct type based on the function signature.
- **/
-template <typename F>
-class AnyRpcFunction;
-
-template <typename R, typename... Args>
-class AnyRpcFunction<R(Args...)> : public anyrpc::Method {
-public:
-    AnyRpcFunction(
-        std::function<R(Args...)> func, const std::string& name, const std::string& help, bool deleteOnRemove = true)
-    : anyrpc::Method(name, help, deleteOnRemove)
-    , m_func(func)
-    {
-    }
-
-    void Execute(anyrpc::Value& params, anyrpc::Value& result) override
-    {
-        if (!params.IsArray()) {
-            throw anyrpc::AnyRpcException(anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Expected Array.");
-        }
-        if (params.Size() != sizeof...(Args)) {
-            throw anyrpc::AnyRpcException(
-                anyrpc::AnyRpcErrorInvalidParams, "Invalid parameters. Number of parameters incorrect.");
-        }
-
-        callAndAssignAnyRpcResult<Args...>(m_func, result, std::make_index_sequence<sizeof...(Args)>(), params);
-    }
-
-private:
-    std::function<R(Args...)> m_func;
-};
-
-/**
- * Helper function to add a std::function based function to AnyRPC.
- **/
-template <typename F>
-void AddFunctionToAnyRpc(
-    anyrpc::MethodManager* manager, const std::string& name, const std::string& help, std::function<F> func)
-{
-    manager->AddMethod(new utils::AnyRpcFunction<F>(func, name, help, true));
-}
+Variant AnyRPCValueToVariant(const anyrpc::Value& valueConst);
+anyrpc::Value VariantToAnyRPCValue(const Variant& value);
 
 } // namespace utils
 } // namespace spix
diff --git a/lib/tests/CMakeLists.txt b/lib/tests/CMakeLists.txt
index 1bc3c25..3957d5d 100644
--- a/lib/tests/CMakeLists.txt
+++ b/lib/tests/CMakeLists.txt
@@ -14,7 +14,7 @@ set(TEST_SOURCES
     unittests/Data/ItemPosition_test.cpp
     unittests/Data/PasteboardContent_test.cpp
 
-    unittests/Utils/AnyRpcUtils_test.cpp
+    unittests/Utils/AnyRpcFunction_test.cpp
 )
 
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX source FILES ${TEST_SOURCES})
diff --git a/lib/tests/unittests/Utils/AnyRpcUtils_test.cpp b/lib/tests/unittests/Utils/AnyRpcFunction_test.cpp
similarity index 93%
rename from lib/tests/unittests/Utils/AnyRpcUtils_test.cpp
rename to lib/tests/unittests/Utils/AnyRpcFunction_test.cpp
index f960fd3..e40c831 100644
--- a/lib/tests/unittests/Utils/AnyRpcUtils_test.cpp
+++ b/lib/tests/unittests/Utils/AnyRpcFunction_test.cpp
@@ -6,10 +6,10 @@
 
 #include <gtest/gtest.h>
 
-#include <Utils/AnyRpcUtils.h>
+#include <Utils/AnyRpcFunction.h>
 #include <anyrpc/anyrpc.h>
 
-TEST(AnyRpcUtilsTest, ThreeArgsNoReturn)
+TEST(AnyRpcFunctionTest, ThreeArgsNoReturn)
 {
     anyrpc::MethodManager manager;
 
@@ -42,7 +42,7 @@ TEST(AnyRpcUtilsTest, ThreeArgsNoReturn)
     EXPECT_EQ(res_arg_c, "Some String");
 }
 
-TEST(AnyRpcUtilsTest, VecArgsNoReturn)
+TEST(AnyRpcFunctionTest, VecArgsNoReturn)
 {
     anyrpc::MethodManager manager;
 
@@ -76,7 +76,7 @@ TEST(AnyRpcUtilsTest, VecArgsNoReturn)
     EXPECT_EQ(res_arg_b, "World");
 }
 
-TEST(AnyRpcUtilsTest, NoArgWithReturn)
+TEST(AnyRpcFunctionTest, NoArgWithReturn)
 {
     anyrpc::MethodManager manager;
 
@@ -95,7 +95,7 @@ TEST(AnyRpcUtilsTest, NoArgWithReturn)
     EXPECT_EQ(result.GetInt(), 53562);
 }
 
-TEST(AnyRpcUtilsTest, NoArgWithVecReturn)
+TEST(AnyRpcFunctionTest, NoArgWithVecReturn)
 {
     anyrpc::MethodManager manager;