aboutsummaryrefslogtreecommitdiff
path: root/tests/client
diff options
context:
space:
mode:
Diffstat (limited to 'tests/client')
-rw-r--r--tests/client/actiongrouptest.cpp99
-rw-r--r--tests/client/cachetest.cpp5
-rw-r--r--tests/client/convertertest.cpp231
-rw-r--r--tests/client/modelsignalstest.cpp5
-rw-r--r--tests/client/treetest.cpp5
5 files changed, 230 insertions, 115 deletions
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;