diff options
| -rw-r--r-- | debian/changelog | 6 | ||||
| -rw-r--r-- | libqmenumodel/src/converter.cpp | 30 | ||||
| -rw-r--r-- | libqmenumodel/src/converter.h | 2 | ||||
| -rw-r--r-- | libqmenumodel/src/qdbusobject.cpp | 1 | ||||
| -rw-r--r-- | libqmenumodel/src/qstateaction.cpp | 20 | ||||
| -rw-r--r-- | libqmenumodel/src/qstateaction.h | 2 | ||||
| -rw-r--r-- | libqmenumodel/src/unitymenumodel.cpp | 18 | ||||
| -rw-r--r-- | libqmenumodel/src/unitymenumodel.h | 2 | ||||
| -rw-r--r-- | tests/client/actiongrouptest.cpp | 99 | ||||
| -rw-r--r-- | tests/client/cachetest.cpp | 5 | ||||
| -rw-r--r-- | tests/client/convertertest.cpp | 231 | ||||
| -rw-r--r-- | tests/client/modelsignalstest.cpp | 5 | ||||
| -rw-r--r-- | tests/client/treetest.cpp | 5 |
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 ¶meter) 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 ¶meter) +{ + 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 ¶meter = QVariant()); + Q_INVOKABLE void activateByVariantString(const QString ¶meter = QString()); Q_INVOKABLE void updateState(const QVariant ¶meter); + Q_INVOKABLE void updateStateByVariantString(const QString ¶meter); 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; |