Add ability to activate or change state of an action by variant string

13 files changed, 308 insertions, 118 deletions

diff --git a/debian/changelog b/debian/changelog
index 9f44317..37c0c3e 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+qmenumodel (0.2.10) UNRELEASED; urgency=medium
+
+  * Add ability to activate or change state of an action by variant string
+
+ -- Marco Trevisan (Treviño) <marco@ubuntu.com>  Fri, 14 Oct 2016 17:07:41 +0200
+
 qmenumodel (0.2.9+16.04.20160329-0ubuntu1) xenial; urgency=medium
 
   [ Nick Dedekind ]
diff --git a/libqmenumodel/src/converter.cpp b/libqmenumodel/src/converter.cpp
index 69e6629..527ae85 100644
--- a/libqmenumodel/src/converter.cpp
+++ b/libqmenumodel/src/converter.cpp
@@ -24,6 +24,7 @@ extern "C" {
 #include "converter.h"
 
 #include <QDebug>
+#include <QString>
 #include <QVariant>
 
 /*! \internal */
@@ -137,6 +138,29 @@ static GVariant* toGVariant(const QString &typeName, const QVariant &value)
     return NULL;
 }
 
+QVariant Converter::toQVariantFromVariantString(const QString &variantString)
+{
+    GVariant *gvariant;
+    GError *error = NULL;
+
+    if (variantString.isEmpty()) {
+        return QVariant();
+    }
+
+    gvariant = g_variant_parse (NULL, variantString.toUtf8().data(), NULL, NULL, &error);
+
+    if (error) {
+        qWarning() << "Impossible to parse" << variantString << "as variant string:"<< error->message;
+        g_error_free (error);
+        return QVariant();
+    }
+
+    const QVariant& qvariant = Converter::toQVariant(gvariant);
+    g_variant_unref (gvariant);
+
+    return qvariant;
+}
+
 GVariant* Converter::toGVariant(const QVariant &value)
 {
     GVariant *result = NULL;
@@ -156,12 +180,18 @@ GVariant* Converter::toGVariant(const QVariant &value)
     case QVariant::Int:
         result = g_variant_new_int32(value.toInt());
         break;
+    case QVariant::LongLong:
+        result = g_variant_new_int64(value.toLongLong());
+        break;
     case QVariant::String:
         result = g_variant_new_string(value.toString().toUtf8().data());
         break;
     case QVariant::UInt:
         result = g_variant_new_uint32(value.toUInt());
         break;
+    case QVariant::ULongLong:
+        result = g_variant_new_uint64(value.toULongLong());
+        break;
     case QVariant::Map:
     {
         GVariantBuilder *b;
diff --git a/libqmenumodel/src/converter.h b/libqmenumodel/src/converter.h
index f47c09e..27cdcae 100644
--- a/libqmenumodel/src/converter.h
+++ b/libqmenumodel/src/converter.h
@@ -21,12 +21,14 @@
 #define CONVERTER_H
 
 typedef struct _GVariant GVariant;
+class QString;
 class QVariant;
 
 class Converter
 {
 public:
     static QVariant toQVariant(GVariant *value);
+    static QVariant toQVariantFromVariantString(const QString &variantString);
     static GVariant* toGVariant(const QVariant &value);
 
     // This converts a QVariant to a GVariant using a provided gvariant schema as
diff --git a/libqmenumodel/src/qdbusobject.cpp b/libqmenumodel/src/qdbusobject.cpp
index be9fb93..fab2df7 100644
--- a/libqmenumodel/src/qdbusobject.cpp
+++ b/libqmenumodel/src/qdbusobject.cpp
@@ -81,7 +81,6 @@ QDBusObject::QDBusObject(QObject* listener)
      m_busType(DBusEnums::None),
      m_status(DBusEnums::Disconnected)
 {
-    g_type_init();
     qRegisterMetaType<DBusEnums::ConnectionStatus>("DBusEnums::ConnectionStatus");
 }
 
diff --git a/libqmenumodel/src/qstateaction.cpp b/libqmenumodel/src/qstateaction.cpp
index 983064a..fcffa44 100644
--- a/libqmenumodel/src/qstateaction.cpp
+++ b/libqmenumodel/src/qstateaction.cpp
@@ -19,6 +19,7 @@
 
 #include "qstateaction.h"
 
+#include "converter.h"
 #include "qdbusactiongroup.h"
 
 /*!
@@ -99,6 +100,15 @@ void QStateAction::updateState(const QVariant &state)
 }
 
 /*!
+    Request for the state of action to be changed to \a paramenter.
+    This call merely requests a change. The action may refuse to change its state or may change its state to something other than \a paramenter.
+*/
+void QStateAction::updateStateByVariantString(const QString &state)
+{
+    updateState(Converter::toQVariantFromVariantString(state));
+}
+
+/*!
     Activates the action passing \a parameter.
     \a parameter must be the correct type of parameter for the action
 */
@@ -107,6 +117,16 @@ void QStateAction::activate(const QVariant &parameter)
     m_group->activateAction(m_name, parameter);
 }
 
+/*!
+    Activates the action passing \a parameter using GLib Variant String format.
+    \a parameter must be the correct type of parameter for the action
+*/
+void QStateAction::activateByVariantString(const QString &parameter)
+{
+    activate(Converter::toQVariantFromVariantString(parameter));
+}
+
+
 /*! \internal */
 QString QStateAction::name() const
 {
diff --git a/libqmenumodel/src/qstateaction.h b/libqmenumodel/src/qstateaction.h
index 0fc68c2..4d05a7a 100644
--- a/libqmenumodel/src/qstateaction.h
+++ b/libqmenumodel/src/qstateaction.h
@@ -36,7 +36,9 @@ public:
     bool isValid() const;
 
     Q_INVOKABLE void activate(const QVariant &parameter = QVariant());
+    Q_INVOKABLE void activateByVariantString(const QString &parameter = QString());
     Q_INVOKABLE void updateState(const QVariant &parameter);
+    Q_INVOKABLE void updateStateByVariantString(const QString &parameter);
 
 Q_SIGNALS:
     void stateChanged(QVariant state);
diff --git a/libqmenumodel/src/unitymenumodel.cpp b/libqmenumodel/src/unitymenumodel.cpp
index 70412a4..aac1d92 100644
--- a/libqmenumodel/src/unitymenumodel.cpp
+++ b/libqmenumodel/src/unitymenumodel.cpp
@@ -661,7 +661,7 @@ bool UnityMenuModel::loadExtendedAttributes(int position, const QVariantMap &sch
             continue;
         }
 
-        QVariant qvalue = attributeToQVariant(value, type);
+        const QVariant &qvalue = attributeToQVariant(value, type);
         if (qvalue.isValid())
             extendedAttrs->insert(qtify_name (name.toUtf8()), qvalue);
         else
@@ -692,6 +692,8 @@ void UnityMenuModel::activate(int index, const QVariant& parameter)
 {
     GSequenceIter *it;
     GtkMenuTrackerItem *item;
+    GVariant *value;
+    const GVariantType *parameter_type;
 
     it = g_sequence_get_iter_at_pos (priv->items, index);
     if (g_sequence_iter_is_end (it)) {
@@ -707,7 +709,9 @@ void UnityMenuModel::activate(int index, const QVariant& parameter)
         gchar *action;
 
         action = gtk_menu_tracker_item_get_action_name (item);
-        g_action_group_activate_action (G_ACTION_GROUP (priv->muxer), action, Converter::toGVariant(parameter));
+        parameter_type = g_action_group_get_action_parameter_type (G_ACTION_GROUP (priv->muxer), action);
+        value = Converter::toGVariantWithSchema(parameter, g_variant_type_peek_string (parameter_type));
+        g_action_group_activate_action (G_ACTION_GROUP (priv->muxer), action, value);
 
         g_free (action);
     } else {
@@ -715,6 +719,16 @@ void UnityMenuModel::activate(int index, const QVariant& parameter)
     }
 }
 
+void UnityMenuModel::activateByVariantString(int index, const QString& parameter)
+{
+    activate(index, Converter::toQVariantFromVariantString(parameter));
+}
+
+void UnityMenuModel::changeStateByVariantString(int index, const QString& parameter)
+{
+    changeState(index, Converter::toQVariantFromVariantString(parameter));
+}
+
 void UnityMenuModel::changeState(int index, const QVariant& parameter)
 {
     GSequenceIter *it;
diff --git a/libqmenumodel/src/unitymenumodel.h b/libqmenumodel/src/unitymenumodel.h
index 8816d22..ed3bcd7 100644
--- a/libqmenumodel/src/unitymenumodel.h
+++ b/libqmenumodel/src/unitymenumodel.h
@@ -63,7 +63,9 @@ public:
     Q_INVOKABLE QVariant get(int row, const QByteArray &role);
 
     Q_INVOKABLE void activate(int index, const QVariant& parameter = QVariant());
+    Q_INVOKABLE void activateByVariantString(int index, const QString& parameter = QString());
     Q_INVOKABLE void changeState(int index, const QVariant& parameter);
+    Q_INVOKABLE void changeStateByVariantString(int index, const QString& parameter);
 
     void registerAction(UnityMenuAction* action);
     void unregisterAction(UnityMenuAction* action);
diff --git a/tests/client/actiongrouptest.cpp b/tests/client/actiongrouptest.cpp
index d187ea7..3ab329c 100644
--- a/tests/client/actiongrouptest.cpp
+++ b/tests/client/actiongrouptest.cpp
@@ -31,21 +31,23 @@ class ActionGroupTest : public QObject
 {
     Q_OBJECT
 private:
-    DBusMenuScript m_script;
     QDBusMenuModel m_model;
     QDBusActionGroup m_actionGroup;
+    DBusMenuScript m_script;
 
-private Q_SLOTS:
-    void initTestCase()
+    void getMenuAction(QStateAction **act, int index)
     {
-        QVERIFY(m_script.connect());
-    }
+        // Append 2 menus
+        m_script.walk(2);
 
-    void cleanupTestCase()
-    {
-        m_script.quit();
+        // Get Action
+        QVariant action = m_model.data(m_model.index(index, 0), QMenuModel::Action);
+        QVERIFY(action.isValid());
+        *act = m_actionGroup.action(action.toString());
+        QVERIFY(act);
     }
 
+private Q_SLOTS:
     void init()
     {
         m_model.stop();
@@ -57,6 +59,23 @@ private Q_SLOTS:
         m_actionGroup.setBusType(DBusEnums::SessionBus);
         m_actionGroup.setBusName(MENU_SERVICE_NAME);
         m_actionGroup.setObjectPath(MENU_OBJECT_PATH);
+
+        // start model
+        m_model.start();
+        m_actionGroup.start();
+
+        // Make menu available
+        m_script.publishMenu();
+    }
+
+    void initTestCase()
+    {
+        QVERIFY(m_script.connect());
+    }
+
+    void cleanupTestCase()
+    {
+        m_script.quit();
     }
 
     void cleanup()
@@ -88,11 +107,11 @@ private Q_SLOTS:
      */
     void testServiceAppear()
     {
-        m_model.start();
-        m_actionGroup.start();
+        m_script.unpublishMenu();
         QCOMPARE(m_actionGroup.status(), DBusEnums::Connecting);
 
         // Make menu available
+        m_script.connect();
         m_script.publishMenu();
 
         QCOMPARE(m_actionGroup.status(), DBusEnums::Connected);
@@ -104,11 +123,6 @@ private Q_SLOTS:
      */
     void testServiceDisappear()
     {
-        m_model.start();
-        m_actionGroup.start();
-
-        // Make menu available
-        m_script.publishMenu();
         QCOMPARE(m_actionGroup.status(), DBusEnums::Connected);
 
         // Append menus
@@ -122,35 +136,42 @@ private Q_SLOTS:
         QCOMPARE(m_actionGroup.status(), DBusEnums::Disconnected);
     }
 
+    void testActionName()
+    {
+        QStateAction *act;
+        getMenuAction(&act, 1);
+        QCOMPARE(act->property("name").toString(), QString("Menu1Act"));
+    }
+
     /*
      * Test if Action::trigger active the action over DBus
      */
-    void testActiveAction()
+    void testStringActionActivation()
     {
-        // start model
-        m_model.start();
-        m_actionGroup.start();
+        QStateAction *act;
+        getMenuAction(&act, 1);
+        act->activate(QVariant("42"));
 
-        // Make menu available
-        m_script.publishMenu();
-        m_script.walk(2);
+        // wait for dbus propagation
+        QTest::qWait(500);
 
-        // Get Action
-        QVariant action = m_model.data(m_model.index(1, 0), QMenuModel::Action);
-        QVERIFY(action.isValid());
-        QStateAction *act = m_actionGroup.action(action.toString());
-        QVERIFY(act);
+        QPair<QString, QVariant> result = m_script.popActivatedAction();
+        QCOMPARE(result.first, QString("Menu1Act"));
+        QCOMPARE(result.second.toString(), QString("42"));
+    }
 
-        // test action name
-        QCOMPARE(act->property("name").toString(), QString("Menu1Act"));
+    void testStringActionActivationByVariantString()
+    {
+        QStateAction *act;
+        getMenuAction(&act, 1);
+        act->activateByVariantString("\"53\"");
 
-        act->activate(QVariant("42"));
         // wait for dbus propagation
         QTest::qWait(500);
 
         QPair<QString, QVariant> result = m_script.popActivatedAction();
         QCOMPARE(result.first, QString("Menu1Act"));
-        QCOMPARE(result.second.toString(), QString("42"));
+        QCOMPARE(result.second.toString(), QString("53"));
     }
 
     /*
@@ -158,12 +179,7 @@ private Q_SLOTS:
      */
     void testRemoveAction()
     {
-        // start model
-        m_model.start();
-        m_actionGroup.start();
-
-        // Make menu available and append 2 menus
-        m_script.publishMenu();
+        // Append 2 menus
         m_script.walk(2);
 
         // Get Action
@@ -183,13 +199,6 @@ private Q_SLOTS:
      */
     void testActionIsValid()
     {
-        // start model
-        m_model.start();
-        m_actionGroup.start();
-
-        // Make menu available and append 2 menus
-        m_script.publishMenu();
-
         // Get invalid Action
         QStateAction *act = m_actionGroup.action(QString("Menu1Act"));
         QVERIFY(act);
@@ -204,6 +213,6 @@ private Q_SLOTS:
     }
 };
 
-QTEST_MAIN(ActionGroupTest)
+QTEST_MAIN(ActionGroupTest);
 
 #include "actiongrouptest.moc"
diff --git a/tests/client/cachetest.cpp b/tests/client/cachetest.cpp
index 22fe5d3..8ad65af 100644
--- a/tests/client/cachetest.cpp
+++ b/tests/client/cachetest.cpp
@@ -77,11 +77,6 @@ class CacheTest : public QObject
     Q_OBJECT
 
 private Q_SLOTS:
-    void initTestCase()
-    {
-        g_type_init();
-    }
-
     // Verify that normal menu items are not cached (only sub-menus are)
     void testCacheContents()
     {
diff --git a/tests/client/convertertest.cpp b/tests/client/convertertest.cpp
index db2807f..cd791c7 100644
--- a/tests/client/convertertest.cpp
+++ b/tests/client/convertertest.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 Canonical Ltd.
+ * Copyright 2012-2016 Canonical Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -15,6 +15,7 @@
  *
  * Authors:
  *      Renato Araujo Oliveira Filho <renato@canonical.com>
+ *      Marco Trevisan <marco.trevisan@canonical.com>
  */
 
 extern "C" {
@@ -27,6 +28,37 @@ extern "C" {
 #include <QtTest>
 #include <QDebug>
 
+class QGVariantType : public QObject
+{
+    Q_OBJECT
+public:
+    QGVariantType() : type(NULL) {}
+    QGVariantType(const GVariantType *gvtype) : type(gvtype) {}
+    QGVariantType(const QGVariantType &other) : type(other.type) {}
+    const GVariantType *getType() const { return type; }
+    operator const GVariantType*() const { return type; }
+
+private:
+    const GVariantType *type;
+};
+Q_DECLARE_METATYPE(QGVariantType);
+
+class QGVariant : public QObject
+{
+    Q_OBJECT
+public:
+    QGVariant() : variant(NULL) {}
+    ~QGVariant() { if (variant) g_variant_unref(variant); }
+    QGVariant(GVariant *gv) : variant(g_variant_ref_sink(gv)) {}
+    QGVariant(const QGVariant &other) : variant(g_variant_ref_sink(other.variant)) {}
+    GVariant *gvariant() const { return variant; }
+    operator GVariant*() const { return variant; }
+
+private:
+    GVariant *variant;
+};
+Q_DECLARE_METATYPE(QGVariant);
+
 class ConverterTest : public QObject
 {
     Q_OBJECT
@@ -39,8 +71,21 @@ private:
         result = g_variant_type_equal(g_variant_get_type(gv), type);
         if (!result) {
             qWarning() << "types are different: QVariant:" << qv.typeName()
-                       << "Result:" << (const char*) g_variant_get_type(gv)
-                       << "Expected:"<< (const char*) type;
+                       << "Result:" << g_variant_type_peek_string(g_variant_get_type(gv))
+                       << "Expected:"<< g_variant_type_peek_string(type);
+        }
+        g_variant_unref(gv);
+        return result;
+    }
+    bool compare(GVariant *gv, const QVariant::Type type)
+    {
+        g_variant_ref_sink(gv);
+        const QVariant& qv = Converter::toQVariant(gv);
+        bool result = (qv.type() == type);
+        if (!result) {
+            qWarning() << "types are different: GVariant:" << g_variant_type_peek_string(g_variant_get_type(gv))
+                       << "Result:" << qv.type()
+                       << "Expected:"<< type;
         }
         g_variant_unref(gv);
         return result;
@@ -55,8 +100,8 @@ private:
         result = g_variant_type_equal(g_variant_get_type(gv), expected_type);
         if (!result) {
             qWarning() << "types are different: QVariant:" << qv.typeName()
-                       << "Result:" << (const char*) g_variant_get_type(gv)
-                       << "Expected:"<< (const char*) expected_type;
+                       << "Result:" << g_variant_type_peek_string(g_variant_get_type(gv))
+                       << "Expected:"<< g_variant_type_peek_string(expected_type);
         }
         g_variant_unref(gv);
         return result;
@@ -67,44 +112,35 @@ private Q_SLOTS:
     /*
      * Test converter QVariant to GVariant
      */
-    void testToGVariant()
-    {
-        // Boolean
-        QVERIFY(compare(QVariant(true), G_VARIANT_TYPE_BOOLEAN));
-
-        // Byte
-        QVERIFY(compare(QVariant::fromValue<uchar>(42), G_VARIANT_TYPE_BYTE));
-
-        // Int16
-        QVERIFY(compare(QVariant::fromValue<short>(-42), G_VARIANT_TYPE_INT16));
-
-        // UInt16
-        QVERIFY(compare(QVariant::fromValue<ushort>(-42), G_VARIANT_TYPE_UINT16));
-
-        // Int32
-        QVERIFY(compare(QVariant(-42), G_VARIANT_TYPE_INT32));
-
-        // UInt32
-        QVERIFY(compare(QVariant((uint)42), G_VARIANT_TYPE_UINT32));
-
-        // Int64
-        QVERIFY(compare(QVariant::fromValue<long>(-42), G_VARIANT_TYPE_INT64));
-
-        // UInt64
-        QVERIFY(compare(QVariant::fromValue<ulong>(42), G_VARIANT_TYPE_UINT64));
-
-        // Double
-        QVERIFY(compare(QVariant((double)42.42), G_VARIANT_TYPE_DOUBLE));
 
-        // String
-        QVERIFY(compare(QVariant(QString("42")), G_VARIANT_TYPE_STRING));
-
-        // ByteArray
-        QVERIFY(compare(QVariant(QByteArray("42")), G_VARIANT_TYPE_BYTESTRING));
+    void testConvertToGVariant_data()
+    {
+        QTest::addColumn<QVariant>("value");
+        QTest::addColumn<QGVariantType>("expectedType");
+
+        QTest::newRow("Boolean") << QVariant(true) << QGVariantType(G_VARIANT_TYPE_BOOLEAN);
+        QTest::newRow("Byte") << QVariant::fromValue<uchar>(42) << QGVariantType(G_VARIANT_TYPE_BYTE);
+        QTest::newRow("Int16") << QVariant::fromValue<short>(-42) << QGVariantType(G_VARIANT_TYPE_INT16);
+        QTest::newRow("UInt16") << QVariant::fromValue<ushort>(-42) << QGVariantType(G_VARIANT_TYPE_UINT16);
+        QTest::newRow("Int32") << QVariant(-42) << QGVariantType(G_VARIANT_TYPE_INT32);
+        QTest::newRow("UInt32") << QVariant((uint)42) << QGVariantType(G_VARIANT_TYPE_UINT32);
+        QTest::newRow("Int64") << QVariant::fromValue<long>(-42) << QGVariantType(G_VARIANT_TYPE_INT64);
+        QTest::newRow("UInt64") << QVariant::fromValue<ulong>(42) << QGVariantType(G_VARIANT_TYPE_UINT64);
+        QTest::newRow("Int64") << QVariant::fromValue<qlonglong>(-42) << QGVariantType(G_VARIANT_TYPE_INT64);
+        QTest::newRow("UInt64") << QVariant::fromValue<qulonglong>(42) << QGVariantType(G_VARIANT_TYPE_UINT64);
+        QTest::newRow("Double") << QVariant((double)42.42) << QGVariantType(G_VARIANT_TYPE_DOUBLE);
+        QTest::newRow("String") << QVariant(QString("42")) << QGVariantType(G_VARIANT_TYPE_STRING);
+        QTest::newRow("ByteArray") << QVariant(QByteArray("42")) << QGVariantType(G_VARIANT_TYPE_BYTESTRING);
+        QTest::newRow("Map") << QVariant(QVariantMap()) << QGVariantType(G_VARIANT_TYPE_VARDICT);
+        QTest::newRow("List") << QVariant(QVariantList()) << QGVariantType(G_VARIANT_TYPE_UNIT);
+    }
 
-        // Map
-        QVERIFY(compare(QVariantMap(), G_VARIANT_TYPE_VARDICT));
+    void testConvertToGVariant()
+    {
+        QFETCH(QVariant, value);
+        QFETCH(QGVariantType, expectedType);
 
+        QVERIFY(compare(value, expectedType));
     }
 
     void testTupleConversion()
@@ -134,41 +170,126 @@ private Q_SLOTS:
         g_variant_unref(gTuple);
     }
 
-    void testSchemaConvert()
+    void testConvertToGVariantWithSchema_data()
     {
-        // convert to integer
-        compareWithSchema(QVariant::fromValue<int>(1), "i");
-        compareWithSchema(QVariant::fromValue<double>(1.1), "i");
+        QTest::addColumn<QVariant>("value");
+        QTest::addColumn<QString>("schema");
 
         // convert to integer
-        compareWithSchema(QVariant::fromValue<bool>(true), "b");
-        compareWithSchema(QVariant::fromValue<int>(1), "b");
+        QTest::newRow("integer") << QVariant::fromValue<int>(1) << "i";
+        QTest::newRow("integer from double") << QVariant::fromValue<double>(1.1) << "i";
+
+        // convert to bool
+        QTest::newRow("bool") << QVariant::fromValue<bool>(true) << "b";
+        QTest::newRow("bool from int") << QVariant::fromValue<int>(1) << "b";
 
         // convert to double
-        compareWithSchema(QVariant::fromValue<double>(1.0), "d");
-        compareWithSchema(QVariant::fromValue<int>(1), "d");
+        QTest::newRow("double") << QVariant::fromValue<double>(1.0) << "d";
+        QTest::newRow("double from int") << QVariant::fromValue<int>(1) << "d";
 
         // convert to string
-        compareWithSchema(QVariant::fromValue<int>(1), "s");
-        compareWithSchema(QVariant::fromValue<double>(1.1), "s");
+        QTest::newRow("string") << QVariant::fromValue<QString>("FoooBar") << "s";
+        QTest::newRow("string from int") << QVariant::fromValue<int>(1) << "s";
+        QTest::newRow("string from double") << QVariant::fromValue<double>(1.1) << "s";
 
         // convert to tuple
-        compareWithSchema(QVariantList() << QVariant::fromValue<bool>(true) << QVariant::fromValue<int>(1) << QVariant::fromValue<int>(1) << QVariant::fromValue<QString>("test1"), "(bdis)");
+        QVariantList list = QVariantList() << QVariant::fromValue<bool>(true) << QVariant::fromValue<int>(1) << QVariant::fromValue<int>(1) << QVariant::fromValue<QString>("test1");
+        QTest::newRow("tuple") << QVariant(list) << "(bdis)";
 
         // convert to array
-        compareWithSchema(QVariantList() << QVariant::fromValue<int>(1) << QVariant::fromValue<int>(1), "ad");
-        compareWithSchema(QVariantList() << QVariant::fromValue<QString>("test1") << QVariant::fromValue<QString>("test2"), "as");
+        list = QVariantList() << QVariant::fromValue<int>(1) << QVariant::fromValue<int>(1);
+        QTest::newRow("int list") << QVariant(list) << "ad";
+        list = QVariantList() << QVariant::fromValue<QString>("test1") << QVariant::fromValue<QString>("test2");
+        QTest::newRow("string list") << QVariant(list) << "as";
 
         // convert to array of tuple
         QVariantList si1(QVariantList() << QVariant::fromValue<QString>("test1") << QVariant::fromValue<int>(1));
         QVariantList si2(QVariantList() << QVariant::fromValue<QString>("test1") << QVariant::fromValue<int>(1));
-        compareWithSchema(QVariantList() << QVariant::fromValue(si1) << QVariant::fromValue(si2), "a(sd)");
+        list = QVariantList() << QVariant::fromValue(si1) << QVariant::fromValue(si2);
+        QTest::newRow("array of tuple") << QVariant(list) << "a(sd)";
 
         // convert to vardict
         QVariantMap map;
         map["test1"] = QVariant::fromValue<int>(1);
         map["test2"] = QVariant::fromValue<double>(1);
-        compareWithSchema(map, "a{sv}");
+        QTest::newRow("map") << QVariant(map) << "a{sv}";
+    }
+
+    void testConvertToGVariantWithSchema()
+    {
+        QFETCH(QVariant, value);
+        QFETCH(QString, schema);
+
+        QVERIFY(compareWithSchema(value, schema));
+    }
+
+    /*
+     * Test converter GVariant to QVariant
+     */
+
+    void testConvertToQVariant_data()
+    {
+        QTest::addColumn<QGVariant>("value");
+        QTest::addColumn<unsigned>("expectedType");
+
+        QTest::newRow("Boolean") << QGVariant(g_variant_new_boolean(TRUE)) << (unsigned) QVariant::Bool;
+        QTest::newRow("Byte") << QGVariant(g_variant_new_byte(53)) << (unsigned) QMetaType::UChar;
+        QTest::newRow("Int16") << QGVariant(g_variant_new_int16(-53)) << (unsigned) QMetaType::Short;
+        QTest::newRow("UInt16") << QGVariant(g_variant_new_uint16(53)) << (unsigned) QMetaType::UShort;
+        QTest::newRow("Int32") << QGVariant(g_variant_new_int32(-53)) << (unsigned) QVariant::Int;
+        QTest::newRow("UInt32") << QGVariant(g_variant_new_uint32(53)) << (unsigned) QVariant::UInt;
+        QTest::newRow("Int64") << QGVariant(g_variant_new_int64(-53)) << (unsigned) QVariant::LongLong;
+        QTest::newRow("UInt64") << QGVariant(g_variant_new_uint64(53)) << (unsigned) QVariant::ULongLong;
+        QTest::newRow("Double") << QGVariant(g_variant_new_double(53.3)) << (unsigned) QVariant::Double;
+        QTest::newRow("String") << QGVariant(g_variant_new_string("53")) << (unsigned) QVariant::String;
+        QTest::newRow("Tuple") << QGVariant(g_variant_new("(si)", "foo", 53)) << (unsigned) QVariant::List;
+
+        GVariantBuilder* builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+        g_variant_builder_add(builder, "{sv}", "fooo", g_variant_new_variant(g_variant_new_int64(53)));
+        QTest::newRow("Map") << QGVariant(g_variant_new("a{sv}", builder)) << (unsigned) QVariant::Map;
+        g_variant_builder_unref(builder);
+
+        builder = g_variant_builder_new(G_VARIANT_TYPE("ai"));
+        g_variant_builder_add(builder, "i", g_variant_new_int32(53));
+        QTest::newRow("List") << QGVariant(g_variant_new("ai", builder)) << (unsigned) QVariant::List;
+        g_variant_builder_unref(builder);
+    }
+
+    void testConvertToQVariant()
+    {
+        QFETCH(QGVariant, value);
+        QFETCH(unsigned, expectedType);
+
+        QVERIFY(compare(value, (QVariant::Type) expectedType));
+    }
+
+    void testConvertToQVariantFromString_data()
+    {
+        QTest::addColumn<QString>("value");
+        QTest::addColumn<unsigned>("expectedType");
+
+        QTest::newRow("Boolean") << "true" << (unsigned) QVariant::Bool;
+        QTest::newRow("Byte") << "byte 0xFF" << (unsigned) QMetaType::UChar;
+        QTest::newRow("Int16") << "int16 65" << (unsigned) QMetaType::Short;
+        QTest::newRow("UInt16") << "uint16 65" << (unsigned) QMetaType::UShort;
+        QTest::newRow("Int32") << "int32 65" << (unsigned) QVariant::Int;
+        QTest::newRow("UInt32") << "uint32 65" << (unsigned) QVariant::UInt;
+        QTest::newRow("Int64") << "int64 65" << (unsigned) QVariant::LongLong;
+        QTest::newRow("UInt64") << "uint64 65" << (unsigned) QVariant::ULongLong;
+        QTest::newRow("Double") << "double 65" << (unsigned) QVariant::Double;
+        QTest::newRow("String") << "string '65'" << (unsigned) QVariant::String;
+        QTest::newRow("String simple") << "\"65\"" << (unsigned) QVariant::String;
+        QTest::newRow("Map") << "{'foo': <65>}" << (unsigned) QVariant::Map;
+        QTest::newRow("List") << "[65, 66]" << (unsigned) QVariant::List;
+        QTest::newRow("Tuple") << "('foo', 65)" << (unsigned) QVariant::List;
+    }
+
+    void testConvertToQVariantFromString()
+    {
+        QFETCH(QString, value);
+        QFETCH(unsigned, expectedType);
+
+        QCOMPARE(Converter::toQVariantFromVariantString(value).type(), (QVariant::Type) expectedType);
     }
 
 };
diff --git a/tests/client/modelsignalstest.cpp b/tests/client/modelsignalstest.cpp
index 40a76c6..3064778 100644
--- a/tests/client/modelsignalstest.cpp
+++ b/tests/client/modelsignalstest.cpp
@@ -192,11 +192,6 @@ class ModelSignalsTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
-    void initTestCase()
-    {
-        g_type_init();
-    }
-
     /*
      * Test if the model state still correct before and after insert a new row
      */
diff --git a/tests/client/treetest.cpp b/tests/client/treetest.cpp
index b6fec3c..81399f7 100644
--- a/tests/client/treetest.cpp
+++ b/tests/client/treetest.cpp
@@ -62,11 +62,6 @@ class TreeTest : public QObject
     Q_OBJECT
 
 private Q_SLOTS:
-    void initTestCase()
-    {
-        g_type_init();
-    }
-
     void testMenuBuild()
     {
         TestModel menu;