← Back to branch summary

~timo-jyrinki/ubuntu/trusty/maliit-framework/fix_qt52

« back to all changes in this revision

Viewing changes to .pc/disable-failing-test.patch/tests/ft_mimpluginmanager/ft_mimpluginmanager.cpp

  • Committer: Package Import Robot
  • Author(s): Ricardo Salveti de Araujo, Sergio Schvezov, Ricardo Salveti de Araujo
  • Date: 2013-07-23 19:47:04 UTC
  • mfrom: (1.1.2) (1.2.1 experimental)
  • Revision ID: package-import@ubuntu.com-20130723194704-1lsy1kmlda069cea
Tags: 0.99.0+git20130615+97e8335-0ubuntu1
[ Sergio Schvezov ]
* New build from HEAD 97e8335.
* Packaging import from lp:phablet-extras/maliit-framework.

[ Ricardo Salveti de Araujo ]
* debian/control: adding vcs and fixing dependencies
* General package cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/disable-failing-test.patch/tests/ft_mimpluginmanager/ft_mimpluginmanager.cpp
1
 
#include "ft_mimpluginmanager.h"
2
 
 
3
 
#include "mkeyboardstatetracker_stub.h"
4
 
#include "dummyimplugin.h"
5
 
#include "dummyimplugin3.h"
6
 
#include "dummyinputmethod.h"
7
 
#include "dummyinputmethod3.h"
8
 
#include "core-utils.h"
9
 
#include "mimsettingsqsettings.h"
10
 
 
11
 
#include <minputcontextconnection.h>
12
 
#include <mimpluginmanager.h>
13
 
#include <mimpluginmanager_p.h>
14
 
#include <msharedattributeextensionmanager.h>
15
 
 
16
 
#include <QProcess>
17
 
#include <QGraphicsScene>
18
 
#include <QRegExp>
19
 
#include <QApplication>
20
 
#include <QPointer>
21
 
 
22
 
namespace
23
 
{
24
 
    const QString pluginName  = "DummyImPlugin";
25
 
    const QString pluginName3 = "DummyImPlugin3";
26
 
    const QString pluginId  = "libdummyimplugin.so";
27
 
    const QString pluginId3 = "libdummyimplugin3.so";
28
 
 
29
 
    const QString EnabledPluginsKey = MALIIT_CONFIG_ROOT"onscreen/enabled";
30
 
    const QString ActivePluginKey =   MALIIT_CONFIG_ROOT"onscreen/active";
31
 
 
32
 
    const QString ConfigRoot        = MALIIT_CONFIG_ROOT;
33
 
    const QString MImPluginPaths    = ConfigRoot + "paths";
34
 
    const QString MImPluginActive   = ConfigRoot + "activeplugins";
35
 
    const QString MImPluginDisabled = ConfigRoot + "disabledpluginfiles";
36
 
 
37
 
    const QString PluginRoot         = MALIIT_CONFIG_ROOT"plugins/";
38
 
    const QString PluginSettings     = MALIIT_CONFIG_ROOT"pluginsettings";
39
 
    const QString MImAccesoryEnabled = MALIIT_CONFIG_ROOT"accessoryenabled";
40
 
 
41
 
    const MImPluginDescription* findPluginDescriptions(const QList<MImPluginDescription> &list, const QString &pluginName)
42
 
    {
43
 
        Q_FOREACH (const MImPluginDescription &desc, list) {
44
 
            if (desc.name() == pluginName) {
45
 
                return &desc;
46
 
            }
47
 
        }
48
 
 
49
 
        return 0;
50
 
    }
51
 
}
52
 
 
53
 
 
54
 
// Initialization............................................................
55
 
 
56
 
void Ft_MIMPluginManager::initTestCase()
57
 
{
58
 
    MImSettings::setPreferredSettingsType(MImSettings::TemporarySettings);
59
 
}
60
 
 
61
 
void Ft_MIMPluginManager::cleanupTestCase()
62
 
{
63
 
}
64
 
 
65
 
void Ft_MIMPluginManager::init()
66
 
{
67
 
    MImSettings(MImPluginPaths).set(MaliitTestUtils::getTestPluginPath());
68
 
    MImSettings(MImPluginDisabled).set(QStringList("libdummyimplugin2.so"));
69
 
    MImSettings(MImPluginActive).set(QStringList("DummyImPlugin"));
70
 
 
71
 
    MImSettings(PluginRoot + "hardware").set(pluginId);
72
 
    MImSettings(PluginRoot + "accessory").set(pluginId3);
73
 
 
74
 
    MImSettings enabledPluginsSettings(EnabledPluginsKey);
75
 
    QStringList enabledPlugins;
76
 
    enabledPlugins << pluginId + ":" + "dummyimsv1";
77
 
    enabledPlugins << pluginId + ":" + "dummyimsv2";
78
 
    enabledPlugins << pluginId3 + ":" + "dummyim3sv1";
79
 
    enabledPlugins << pluginId3 + ":" + "dummyim3sv2";
80
 
    enabledPluginsSettings.set(enabledPlugins);
81
 
 
82
 
    MImSettings activePluginSettings(ActivePluginKey);
83
 
    QString activePlugin;
84
 
    activePlugin = pluginId + ":" + "dummyimsv1";
85
 
    activePluginSettings.set(activePlugin);
86
 
 
87
 
    gMKeyboardStateTrackerStub->setOpenState(false);
88
 
    MImSettings(MImAccesoryEnabled).set(QVariant(false));
89
 
 
90
 
    QSharedPointer<MInputContextConnection> icConnection(new MInputContextConnection);
91
 
    subject = new MIMPluginManager(icConnection, QSharedPointer<Maliit::Server::AbstractSurfaceGroupFactory>(new MaliitTestUtils::TestSurfaceGroupFactory));
92
 
}
93
 
 
94
 
void Ft_MIMPluginManager::cleanup()
95
 
{
96
 
    delete subject;
97
 
}
98
 
 
99
 
 
100
 
// Test methods..............................................................
101
 
 
102
 
void Ft_MIMPluginManager::testLoadPlugins()
103
 
{
104
 
    QStringList loadedPlugins = subject->loadedPluginsNames();
105
 
    QCOMPARE(loadedPlugins.count(), 2);
106
 
    QVERIFY(loadedPlugins.contains(pluginId));
107
 
    QVERIFY(loadedPlugins.contains(pluginId3));
108
 
 
109
 
    QStringList activePlugins = subject->activePluginsNames();
110
 
    QCOMPARE(activePlugins.count(), 1);
111
 
    QCOMPARE(activePlugins.first(), pluginId);
112
 
}
113
 
 
114
 
 
115
 
void Ft_MIMPluginManager::testSwitchPluginState()
116
 
{
117
 
    MImSettings(MImAccesoryEnabled).set(QVariant(true));
118
 
 
119
 
    QStringList loadedPlugins = subject->loadedPluginsNames();
120
 
    QCOMPARE(loadedPlugins.count(), 2);
121
 
    QVERIFY(loadedPlugins.contains(pluginId));
122
 
    QVERIFY(loadedPlugins.contains(pluginId3));
123
 
 
124
 
    QStringList activePlugins = subject->activePluginsNames();
125
 
    QCOMPARE(activePlugins.count(), 1);
126
 
    QCOMPARE(activePlugins.first(), pluginId3);
127
 
}
128
 
 
129
 
 
130
 
void Ft_MIMPluginManager::testMultiplePlugins()
131
 
{
132
 
    //QSKIP("This test fails to activate > 1 plugins, for unknown reasons.", SkipAll);
133
 
 
134
 
    gMKeyboardStateTrackerStub->setOpenState(true);
135
 
    MImSettings(MImAccesoryEnabled).set(QVariant(true));
136
 
 
137
 
    QStringList loadedPlugins = subject->loadedPluginsNames();
138
 
    QCOMPARE(loadedPlugins.count(), 2);
139
 
    QVERIFY(loadedPlugins.contains(pluginId));
140
 
    QVERIFY(loadedPlugins.contains(pluginId3));
141
 
 
142
 
    QStringList activePlugins = subject->activePluginsNames();
143
 
    QCOMPARE(activePlugins.count(), 2);
144
 
    QVERIFY(activePlugins.contains(pluginId));
145
 
    QVERIFY(activePlugins.contains(pluginId3));
146
 
}
147
 
 
148
 
void Ft_MIMPluginManager::testSwitchPluginBySignal()
149
 
{
150
 
    DummyImPlugin *plugin = 0;
151
 
    QPointer<DummyInputMethod> inputMethod = 0;
152
 
 
153
 
    for (MIMPluginManagerPrivate::Plugins::iterator iterator(subject->d_ptr->plugins.begin());
154
 
            iterator != subject->d_ptr->plugins.end();
155
 
            ++iterator) {
156
 
        if (pluginName == iterator.key()->name()) {
157
 
            plugin = dynamic_cast<DummyImPlugin *>(iterator.key());
158
 
        }
159
 
    }
160
 
 
161
 
    QVERIFY(plugin != 0);
162
 
    inputMethod = dynamic_cast<DummyInputMethod *>(subject->d_ptr->plugins[plugin].inputMethod);
163
 
    QVERIFY(inputMethod != 0);
164
 
 
165
 
    inputMethod->switchMe();
166
 
 
167
 
    QStringList activePlugins = subject->activePluginsNames();
168
 
    QCOMPARE(activePlugins.count(), 1);
169
 
    QVERIFY(activePlugins.contains(pluginId3));
170
 
    QVERIFY(inputMethod != 0);
171
 
}
172
 
 
173
 
void Ft_MIMPluginManager::testSwitchToSpecifiedPlugin()
174
 
{
175
 
    DummyImPlugin *plugin = 0;
176
 
    QPointer<DummyInputMethod> inputMethod = 0;
177
 
 
178
 
    for (MIMPluginManagerPrivate::Plugins::iterator iterator(subject->d_ptr->plugins.begin());
179
 
            iterator != subject->d_ptr->plugins.end();
180
 
            ++iterator) {
181
 
        if (pluginName == iterator.key()->name()) {
182
 
            plugin = dynamic_cast<DummyImPlugin *>(iterator.key());
183
 
        }
184
 
    }
185
 
 
186
 
    QVERIFY(plugin != 0);
187
 
    inputMethod = dynamic_cast<DummyInputMethod *>(subject->d_ptr->plugins[plugin].inputMethod);
188
 
    QVERIFY(inputMethod != 0);
189
 
 
190
 
    inputMethod->switchMe(pluginId3);
191
 
 
192
 
    QStringList activePlugins = subject->activePluginsNames();
193
 
    QCOMPARE(activePlugins.count(), 1);
194
 
    QVERIFY(activePlugins.contains(pluginId3));
195
 
    QVERIFY(inputMethod != 0);
196
 
}
197
 
 
198
 
void Ft_MIMPluginManager::testPluginDescriptions()
199
 
{
200
 
    QSignalSpy spy(subject, SIGNAL(pluginsChanged()));
201
 
    QVERIFY(spy.isValid());
202
 
 
203
 
    MImSettings enabledPluginsSettings(EnabledPluginsKey);
204
 
    QStringList enabledPlugins;
205
 
    const MImPluginDescription *description = 0;
206
 
 
207
 
    enabledPlugins << pluginId + ":" + "dummyimsv1";
208
 
    enabledPluginsSettings.set(enabledPlugins);
209
 
    QCOMPARE(spy.count(), 1);
210
 
 
211
 
    description = findPluginDescriptions(subject->pluginDescriptions(Maliit::OnScreen), pluginName);
212
 
    QVERIFY(description);
213
 
    QVERIFY(description->enabled());
214
 
    description = findPluginDescriptions(subject->pluginDescriptions(Maliit::OnScreen), pluginName3);
215
 
    QVERIFY(description);
216
 
    QVERIFY(!description->enabled());
217
 
    description = 0;
218
 
 
219
 
    enabledPlugins << pluginId + ":" + "dummyimsv2";
220
 
    enabledPluginsSettings.set(enabledPlugins);
221
 
    QCOMPARE(spy.count(), 2);
222
 
 
223
 
    description = findPluginDescriptions(subject->pluginDescriptions(Maliit::OnScreen), pluginName);
224
 
    QVERIFY(description);
225
 
    QVERIFY(description->enabled());
226
 
    description = findPluginDescriptions(subject->pluginDescriptions(Maliit::OnScreen), pluginName3);
227
 
    QVERIFY(description);
228
 
    QVERIFY(!description->enabled());
229
 
    description = 0;
230
 
 
231
 
    enabledPlugins << pluginId3 + ":" + "dummyim3sv2";
232
 
    enabledPluginsSettings.set(enabledPlugins);
233
 
    QCOMPARE(spy.count(), 3);
234
 
 
235
 
    description = findPluginDescriptions(subject->pluginDescriptions(Maliit::OnScreen), pluginName);
236
 
    QVERIFY(description);
237
 
    QVERIFY(description->enabled());
238
 
    description = findPluginDescriptions(subject->pluginDescriptions(Maliit::OnScreen), pluginName3);
239
 
    QVERIFY(description);
240
 
    QVERIFY(description->enabled());
241
 
    description = 0;
242
 
 
243
 
    //at least we should not crash here
244
 
    enabledPluginsSettings.set(QStringList());
245
 
}
246
 
 
247
 
Q_DECLARE_METATYPE(QList<int>)
248
 
 
249
 
void Ft_MIMPluginManager::testPluginSetting()
250
 
{
251
 
    qRegisterMetaType<QList<int> >();
252
 
 
253
 
    QString pluginId;
254
 
    QSignalSpy spy(subject->d_ptr->sharedAttributeExtensionManager.data(),
255
 
                   SIGNAL(notifyExtensionAttributeChanged(QList<int>,int,QString,QString,QString,QVariant)));
256
 
    QList<QVariant> arguments;
257
 
 
258
 
    DummyImPlugin3 *plugin = 0;
259
 
    DummyInputMethod3 *inputMethod = 0;
260
 
 
261
 
    for (MIMPluginManagerPrivate::Plugins::iterator iterator(subject->d_ptr->plugins.begin());
262
 
            iterator != subject->d_ptr->plugins.end();
263
 
            ++iterator) {
264
 
        if (pluginName3 == iterator.key()->name()) {
265
 
            plugin = dynamic_cast<DummyImPlugin3 *>(iterator.key());
266
 
            pluginId = iterator.value().pluginId;
267
 
        }
268
 
    }
269
 
 
270
 
    QVERIFY(plugin != 0);
271
 
    inputMethod = dynamic_cast<DummyInputMethod3 *>(subject->d_ptr->plugins[plugin].inputMethod);
272
 
    QVERIFY(inputMethod != 0);
273
 
 
274
 
    QCOMPARE(inputMethod->setting->value(), QVariant("Test"));
275
 
 
276
 
    QString settingKey = PluginSettings + "/" + pluginId + "/setting";
277
 
 
278
 
    // tests
279
 
    // - that plugin settings are registered in a per-plugin namespace
280
 
    // - that they are correctly registered in the shared attribute extension manager
281
 
    // - that the data returned to clients reflects plugin settings
282
 
    // - that changing setting value notifies both subscribed clients and the plugin
283
 
 
284
 
    // setting registered in global setting list
285
 
    bool setting_registered = false;
286
 
 
287
 
    Q_FOREACH (const MImPluginSettingsInfo &info, subject->d_ptr->settings) {
288
 
        if (info.plugin_name == pluginId) {
289
 
            setting_registered = true;
290
 
 
291
 
            QCOMPARE(info.plugin_description, QString("DummyImPlugin3"));
292
 
            QCOMPARE(info.entries.count(), 1);
293
 
            QCOMPARE(info.entries[0].description, QString("Example setting"));
294
 
            QCOMPARE(info.entries[0].extension_key, settingKey);
295
 
            QCOMPARE(info.entries[0].type, Maliit::StringType);
296
 
            QCOMPARE(info.entries[0].attributes[Maliit::SettingEntryAttributes::defaultValue], QVariant("Test"));
297
 
            break;
298
 
        }
299
 
    }
300
 
 
301
 
    QVERIFY(setting_registered);
302
 
 
303
 
    // simulate client susbcription
304
 
    subject->d_ptr->sharedAttributeExtensionManager->handleAttributeExtensionRegistered(12, MSharedAttributeExtensionManager::PluginSettings, settingKey);
305
 
 
306
 
    MImSettings setting(settingKey);
307
 
 
308
 
    // setting the value from the server
309
 
    setting.set("Test1");
310
 
 
311
 
    QCOMPARE(spy.count(), 1);
312
 
    QCOMPARE(inputMethod->setting->value(), QVariant("Test1"));
313
 
    QCOMPARE(inputMethod->localSettingValue, QVariant("Test1"));
314
 
 
315
 
    arguments = spy[0];
316
 
    QCOMPARE(arguments[2], QVariant("/maliit"));
317
 
    QCOMPARE(arguments[3], QVariant("pluginsettings/" + pluginId));
318
 
    QCOMPARE(arguments[4], QVariant("setting"));
319
 
    QCOMPARE(arguments[5].value<QVariant>(), QVariant("Test1"));
320
 
 
321
 
    // setting the value from the plugin
322
 
    inputMethod->setting->set("Test2");
323
 
 
324
 
    QCOMPARE(spy.count(), 2);
325
 
    QCOMPARE(setting.value(), QVariant("Test2"));
326
 
    QCOMPARE(inputMethod->localSettingValue, QVariant("Test2"));
327
 
 
328
 
    arguments = spy[1];
329
 
    QCOMPARE(arguments[2], QVariant("/maliit"));
330
 
    QCOMPARE(arguments[3], QVariant("pluginsettings/" + pluginId));
331
 
    QCOMPARE(arguments[4], QVariant("setting"));
332
 
    QCOMPARE(arguments[5].value<QVariant>(), QVariant("Test2"));
333
 
}
334
 
 
335
 
QTEST_MAIN(Ft_MIMPluginManager)
336