← Back to branch summary

~tiagosh/telepathy-qt/group-chat2

« back to all changes in this revision

Viewing changes to tests/dbus/cm-protocol.cpp

  • Committer: Package Import Robot
  • Author(s): Ricardo Salveti de Araujo
  • Date: 2013-06-06 04:56:14 UTC
  • Revision ID: package-import@ubuntu.com-20130606045614-inpxexo6765rnmp1
Tags: upstream-0.9.3
Import upstream version 0.9.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/dbus/cm-protocol.cpp
 
1
#include <tests/lib/test.h>
 
2
 
 
3
#include <TelepathyQt/Constants>
 
4
#include <TelepathyQt/ConnectionCapabilities>
 
5
#include <TelepathyQt/ConnectionManager>
 
6
#include <TelepathyQt/PendingReady>
 
7
#include <TelepathyQt/RequestableChannelClassSpec>
 
8
#include <TelepathyQt/Types>
 
9
 
 
10
#include <QtDBus/QtDBus>
 
11
 
 
12
using namespace Tp;
 
13
using namespace Tp::Client;
 
14
 
 
15
namespace
 
16
{
 
17
 
 
18
PresenceSpec getPresenceSpec(const PresenceSpecList &specs, const QString &status)
 
19
{
 
20
    Q_FOREACH (const PresenceSpec &spec, specs) {
 
21
        if (spec.presence().status() == status) {
 
22
            return spec;
 
23
        }
 
24
    }
 
25
    return PresenceSpec();
 
26
}
 
27
 
 
28
}
 
29
 
 
30
class ConnectionManagerAdaptor : public QDBusAbstractAdaptor
 
31
{
 
32
    Q_OBJECT
 
33
    Q_CLASSINFO("D-Bus Interface", "org.freedesktop.Telepathy.ConnectionManager")
 
34
    Q_CLASSINFO("D-Bus Introspection", ""
 
35
"  <interface name=\"org.freedesktop.Telepathy.ConnectionManager\" >\n"
 
36
"    <property name=\"Interfaces\" type=\"as\" access=\"read\" />\n"
 
37
"    <property name=\"Protocols\" type=\"a{sa{sv}}\" access=\"read\" >\n"
 
38
"      <annotation name=\"com.trolltech.QtDBus.QtTypeName\" value=\"Tp::ProtocolPropertiesMap\" />\n"
 
39
"    </property>\n"
 
40
"  </interface>\n"
 
41
        "")
 
42
 
 
43
    Q_PROPERTY(QStringList Interfaces READ Interfaces)
 
44
    Q_PROPERTY(Tp::ProtocolPropertiesMap Protocols READ Protocols)
 
45
 
 
46
public:
 
47
    ConnectionManagerAdaptor(ProtocolPropertiesMap &protocols, QObject *parent)
 
48
        : QDBusAbstractAdaptor(parent),
 
49
          mProtocols(protocols)
 
50
    {
 
51
    }
 
52
 
 
53
    virtual ~ConnectionManagerAdaptor()
 
54
    {
 
55
    }
 
56
 
 
57
public: // Properties
 
58
    inline QStringList Interfaces() const
 
59
    {
 
60
        return QStringList();
 
61
    }
 
62
 
 
63
    inline ProtocolPropertiesMap Protocols() const
 
64
    {
 
65
        return mProtocols;
 
66
    }
 
67
 
 
68
private:
 
69
    ProtocolPropertiesMap mProtocols;
 
70
    ParamSpecList mParameters;
 
71
};
 
72
 
 
73
class ProtocolAdaptor : public QDBusAbstractAdaptor
 
74
{
 
75
    Q_OBJECT
 
76
    Q_CLASSINFO("D-Bus Interface", "org.freedesktop.Telepathy.Protocol")
 
77
    Q_CLASSINFO("D-Bus Introspection", ""
 
78
"  <interface name=\"org.freedesktop.Telepathy.Protocol\" >\n"
 
79
"    <property name=\"Interfaces\" type=\"as\" access=\"read\" />\n"
 
80
"    <property name=\"Parameters\" type=\"a(susv)\" access=\"read\" >\n"
 
81
"      <annotation name=\"com.trolltech.QtDBus.QtTypeName\" value=\"Tp::ParamSpecList\" />\n"
 
82
"    </property>\n"
 
83
"    <property name=\"ConnectionInterfaces\" type=\"as\" access=\"read\" />\n"
 
84
"    <property name=\"RequestableChannelClasses\" type=\"a(a{sv}as)\" access=\"read\" >\n"
 
85
"      <annotation name=\"com.trolltech.QtDBus.QtTypeName\" value=\"Tp::RequestableChannelClassList\" />\n"
 
86
"    </property>\n"
 
87
"    <property name=\"VCardField\" type=\"s\" access=\"read\" />\n"
 
88
"    <property name=\"EnglishName\" type=\"s\" access=\"read\" />\n"
 
89
"    <property name=\"Icon\" type=\"s\" access=\"read\" />\n"
 
90
"  </interface>\n"
 
91
        "")
 
92
 
 
93
    Q_PROPERTY(QStringList Interfaces READ Interfaces)
 
94
    Q_PROPERTY(Tp::ParamSpecList Parameters READ Parameters)
 
95
    Q_PROPERTY(QStringList ConnectionInterfaces READ ConnectionInterfaces)
 
96
    Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
 
97
    Q_PROPERTY(QString VCardField READ VCardField)
 
98
    Q_PROPERTY(QString EnglishName READ EnglishName)
 
99
    Q_PROPERTY(QString Icon READ Icon)
 
100
 
 
101
public:
 
102
    ProtocolAdaptor(QObject *parent)
 
103
        : QDBusAbstractAdaptor(parent),
 
104
          introspectionCalled(0)
 
105
    {
 
106
        mInterfaces << TP_QT_IFACE_PROTOCOL_INTERFACE_ADDRESSING <<
 
107
                       TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS <<
 
108
                       TP_QT_IFACE_PROTOCOL_INTERFACE_PRESENCE;
 
109
 
 
110
        mConnInterfaces << TP_QT_IFACE_CONNECTION_INTERFACE_REQUESTS;
 
111
 
 
112
        mRCCs.append(RequestableChannelClassSpec::textChatroom().bareClass());
 
113
 
 
114
        mVCardField = QLatin1String("x-adaptor");
 
115
        mEnglishName = QLatin1String("Adaptor");
 
116
        mIcon = QLatin1String("icon-adaptor");
 
117
    }
 
118
 
 
119
    virtual ~ProtocolAdaptor()
 
120
    {
 
121
    }
 
122
 
 
123
    inline QVariantMap immutableProperties() const
 
124
    {
 
125
        QVariantMap ret;
 
126
        ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".Interfaces"),
 
127
                   mInterfaces);
 
128
        ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".Parameters"),
 
129
                   qVariantFromValue(mParameters));
 
130
        ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".ConnectionInterfaces"),
 
131
                   mConnInterfaces);
 
132
        ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".RequestableChannelClasses"),
 
133
                   qVariantFromValue(mRCCs));
 
134
        ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".VCardField"),
 
135
                   mVCardField);
 
136
        ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".EnglishName"),
 
137
                   mEnglishName);
 
138
        ret.insert(TP_QT_IFACE_PROTOCOL + QLatin1String(".Icon"),
 
139
                   mIcon);
 
140
        return ret;
 
141
    }
 
142
 
 
143
public: // Properties
 
144
    inline QStringList Interfaces() const
 
145
    {
 
146
        // if we request all properties we are going to get here, so marking as
 
147
        // introspectionCalled;
 
148
        introspectionCalled++;
 
149
        return mInterfaces;
 
150
    }
 
151
 
 
152
    inline Tp::ParamSpecList Parameters() const
 
153
    {
 
154
        return mParameters;
 
155
    }
 
156
 
 
157
    inline QStringList ConnectionInterfaces() const
 
158
    {
 
159
        return mConnInterfaces;
 
160
    }
 
161
 
 
162
    inline Tp::RequestableChannelClassList RequestableChannelClasses() const
 
163
    {
 
164
        return mRCCs;
 
165
    }
 
166
 
 
167
    inline QString VCardField() const
 
168
    {
 
169
        return mVCardField;
 
170
    }
 
171
 
 
172
    inline QString EnglishName() const
 
173
    {
 
174
        return mEnglishName;
 
175
    }
 
176
 
 
177
    inline QString Icon() const
 
178
    {
 
179
        return mIcon;
 
180
    }
 
181
 
 
182
    mutable int introspectionCalled;
 
183
 
 
184
private:
 
185
    QStringList mInterfaces;
 
186
    ParamSpecList mParameters;
 
187
    QStringList mConnInterfaces;
 
188
    RequestableChannelClassList mRCCs;
 
189
    QString mVCardField;
 
190
    QString mEnglishName;
 
191
    QString mIcon;
 
192
};
 
193
 
 
194
class ProtocolAddressingAdaptor : public QDBusAbstractAdaptor
 
195
{
 
196
    Q_OBJECT
 
197
    Q_CLASSINFO("D-Bus Interface", "org.freedesktop.Telepathy.Protocol.Interface.Addressing")
 
198
    Q_CLASSINFO("D-Bus Introspection", ""
 
199
"  <interface name=\"org.freedesktop.Telepathy.Protocol.Interface.Addressing\" >\n"
 
200
"    <property name=\"AddressableVCardFields\" type=\"as\" access=\"read\" />\n"
 
201
"    <property name=\"AddressableURISchemes\" type=\"as\" access=\"read\" />\n"
 
202
"  </interface>\n"
 
203
        "")
 
204
 
 
205
    Q_PROPERTY(QStringList AddressableVCardFields READ AddressableVCardFields)
 
206
    Q_PROPERTY(QStringList AddressableURISchemes READ AddressableURISchemes)
 
207
 
 
208
public:
 
209
    ProtocolAddressingAdaptor(QObject *parent)
 
210
        : QDBusAbstractAdaptor(parent),
 
211
          introspectionCalled(0)
 
212
    {
 
213
        mVCardFields << QLatin1String("x-adaptor");
 
214
        mUris << QLatin1String("adaptor");
 
215
    }
 
216
 
 
217
    virtual ~ProtocolAddressingAdaptor()
 
218
    {
 
219
    }
 
220
 
 
221
    inline QVariantMap immutableProperties() const
 
222
    {
 
223
        QVariantMap ret;
 
224
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_ADDRESSING + QLatin1String(".AddressableVCardFields"),
 
225
                   mVCardFields);
 
226
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_ADDRESSING + QLatin1String(".AddressableURISchemes"),
 
227
                   mUris);
 
228
        return ret;
 
229
    }
 
230
 
 
231
 
 
232
public: // Properties
 
233
    inline QStringList AddressableVCardFields() const
 
234
    {
 
235
        // if we request all properties we are going to get here, so marking as
 
236
        // introspectionCalled;
 
237
        introspectionCalled++;
 
238
        return mVCardFields;
 
239
    }
 
240
 
 
241
    inline QStringList AddressableURISchemes() const
 
242
    {
 
243
        return mUris;
 
244
    }
 
245
 
 
246
    mutable int introspectionCalled;
 
247
 
 
248
private:
 
249
    QStringList mVCardFields;
 
250
    QStringList mUris;
 
251
};
 
252
 
 
253
class ProtocolAvatarsAdaptor : public QDBusAbstractAdaptor
 
254
{
 
255
    Q_OBJECT
 
256
    Q_CLASSINFO("D-Bus Interface", "org.freedesktop.Telepathy.Protocol.Interface.Avatars")
 
257
    Q_CLASSINFO("D-Bus Introspection", ""
 
258
"  <interface name=\"org.freedesktop.Telepathy.Protocol.Interface.Avatars\" >\n"
 
259
"    <property name=\"SupportedAvatarMIMETypes\" type=\"as\" access=\"read\" />\n"
 
260
"    <property name=\"MinimumAvatarHeight type=\"u\" access=\"read\" />\n"
 
261
"    <property name=\"MinimumAvatarWidth type=\"u\" access=\"read\" />\n"
 
262
"    <property name=\"RecommendedAvatarHeight type=\"u\" access=\"read\" />\n"
 
263
"    <property name=\"RecommendedAvatarWidth type=\"u\" access=\"read\" />\n"
 
264
"    <property name=\"MaximumAvatarHeight type=\"u\" access=\"read\" />\n"
 
265
"    <property name=\"MaximumAvatarWidth type=\"u\" access=\"read\" />\n"
 
266
"    <property name=\"MaximumAvatarBytes type=\"u\" access=\"read\" />\n"
 
267
"  </interface>\n"
 
268
        "")
 
269
 
 
270
    Q_PROPERTY(QStringList SupportedAvatarMIMETypes READ SupportedAvatarMIMETypes)
 
271
    Q_PROPERTY(uint MinimumAvatarHeight READ MinimumAvatarHeight)
 
272
    Q_PROPERTY(uint MinimumAvatarWidth READ MinimumAvatarWidth)
 
273
    Q_PROPERTY(uint RecommendedAvatarHeight READ RecommendedAvatarHeight)
 
274
    Q_PROPERTY(uint RecommendedAvatarWidth READ RecommendedAvatarWidth)
 
275
    Q_PROPERTY(uint MaximumAvatarHeight READ MaximumAvatarHeight)
 
276
    Q_PROPERTY(uint MaximumAvatarWidth READ MaximumAvatarWidth)
 
277
    Q_PROPERTY(uint MaximumAvatarBytes READ MaximumAvatarBytes)
 
278
 
 
279
public:
 
280
    ProtocolAvatarsAdaptor(QObject *parent)
 
281
        : QDBusAbstractAdaptor(parent),
 
282
          introspectionCalled(0)
 
283
    {
 
284
        mMimeTypes << QLatin1String("image/png");
 
285
        mMinimumAvatarHeight = 16;
 
286
        mMinimumAvatarWidth = 16;
 
287
        mRecommendedAvatarHeight = 32;
 
288
        mRecommendedAvatarWidth = 32;
 
289
        mMaximumAvatarHeight = 64;
 
290
        mMaximumAvatarWidth = 64;
 
291
        mMaximumAvatarBytes = 4096;
 
292
    }
 
293
 
 
294
    virtual ~ProtocolAvatarsAdaptor()
 
295
    {
 
296
    }
 
297
 
 
298
    inline QVariantMap immutableProperties() const
 
299
    {
 
300
        QVariantMap ret;
 
301
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".SupportedAvatarMIMETypes"),
 
302
                   mMimeTypes);
 
303
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarHeight"),
 
304
                   mMinimumAvatarHeight);
 
305
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MinimumAvatarWidth"),
 
306
                   mMinimumAvatarWidth);
 
307
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarHeight"),
 
308
                   mMaximumAvatarHeight);
 
309
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarWidth"),
 
310
                   mMaximumAvatarWidth);
 
311
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".RecommendedAvatarHeight"),
 
312
                   mRecommendedAvatarHeight);
 
313
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".RecommendedAvatarWidth"),
 
314
                   mRecommendedAvatarWidth);
 
315
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_AVATARS + QLatin1String(".MaximumAvatarBytes"),
 
316
                   mMaximumAvatarBytes);
 
317
        return ret;
 
318
    }
 
319
 
 
320
public: // Properties
 
321
    inline QStringList SupportedAvatarMIMETypes() const
 
322
    {
 
323
        // if we request all properties we are going to get here, so marking as
 
324
        // introspectionCalled;
 
325
        introspectionCalled++;
 
326
        return mMimeTypes;
 
327
    }
 
328
 
 
329
    inline uint MinimumAvatarHeight() const
 
330
    {
 
331
        return mMinimumAvatarHeight;
 
332
    }
 
333
 
 
334
    inline uint MinimumAvatarWidth() const
 
335
    {
 
336
        return mMinimumAvatarWidth;
 
337
    }
 
338
 
 
339
    inline uint RecommendedAvatarHeight() const
 
340
    {
 
341
        return mRecommendedAvatarHeight;
 
342
    }
 
343
 
 
344
    inline uint RecommendedAvatarWidth() const
 
345
    {
 
346
        return mRecommendedAvatarWidth;
 
347
    }
 
348
 
 
349
    inline uint MaximumAvatarHeight() const
 
350
    {
 
351
        return mMaximumAvatarHeight;
 
352
    }
 
353
 
 
354
    inline uint MaximumAvatarWidth() const
 
355
    {
 
356
        return mMaximumAvatarWidth;
 
357
    }
 
358
 
 
359
    inline uint MaximumAvatarBytes() const
 
360
    {
 
361
        return mMaximumAvatarBytes;
 
362
    }
 
363
 
 
364
    mutable int introspectionCalled;
 
365
 
 
366
private:
 
367
    QStringList mMimeTypes;
 
368
    uint mMinimumAvatarHeight;
 
369
    uint mMinimumAvatarWidth;
 
370
    uint mRecommendedAvatarHeight;
 
371
    uint mRecommendedAvatarWidth;
 
372
    uint mMaximumAvatarHeight;
 
373
    uint mMaximumAvatarWidth;
 
374
    uint mMaximumAvatarBytes;
 
375
};
 
376
 
 
377
class ProtocolPresenceAdaptor : public QDBusAbstractAdaptor
 
378
{
 
379
    Q_OBJECT
 
380
    Q_CLASSINFO("D-Bus Interface", "org.freedesktop.Telepathy.Protocol.Interface.Presence")
 
381
    Q_CLASSINFO("D-Bus Introspection", ""
 
382
"  <interface name=\"org.freedesktop.Telepathy.Protocol.Interface.Presence\" >\n"
 
383
"    <property name=\"Statuses\" type=\"a{s(ubb)}\" access=\"read\" >\n"
 
384
"      <annotation name=\"com.trolltech.QtDBus.QtTypeName\" value=\"Tp::SimpleStatusSpecMap\" />\n"
 
385
"    </property>\n"
 
386
"  </interface>\n"
 
387
        "")
 
388
 
 
389
    Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ Statuses)
 
390
 
 
391
public:
 
392
    ProtocolPresenceAdaptor(QObject *parent)
 
393
        : QDBusAbstractAdaptor(parent),
 
394
          introspectionCalled(0)
 
395
    {
 
396
        SimpleStatusSpec spec;
 
397
        spec.type = ConnectionPresenceTypeAvailable;
 
398
        spec.maySetOnSelf = true;
 
399
        spec.canHaveMessage = false;
 
400
        mStatuses.insert(QLatin1String("available"), spec);
 
401
    }
 
402
 
 
403
    virtual ~ProtocolPresenceAdaptor()
 
404
    {
 
405
    }
 
406
 
 
407
    inline QVariantMap immutableProperties() const
 
408
    {
 
409
        QVariantMap ret;
 
410
        ret.insert(TP_QT_IFACE_PROTOCOL_INTERFACE_PRESENCE + QLatin1String(".Statuses"),
 
411
                   qVariantFromValue(mStatuses));
 
412
        return ret;
 
413
    }
 
414
 
 
415
public: // Properties
 
416
    inline SimpleStatusSpecMap Statuses() const
 
417
    {
 
418
        // if we request all properties we are going to get here, so marking as
 
419
        // introspectionCalled;
 
420
        introspectionCalled++;
 
421
        return mStatuses;
 
422
    }
 
423
 
 
424
    mutable int introspectionCalled;
 
425
 
 
426
private:
 
427
    SimpleStatusSpecMap mStatuses;
 
428
};
 
429
 
 
430
struct CMHelper
 
431
{
 
432
    CMHelper(const QString &cmName,
 
433
             bool withProtocolProps = false,
 
434
             bool withProtocolAddressingProps = false,
 
435
             bool withProtocolAvatarsProps = false,
 
436
             bool withProtocolPresenceProps = false)
 
437
    {
 
438
        QDBusConnection bus = QDBusConnection::sessionBus();
 
439
 
 
440
        QString cmBusNameBase = TP_QT_CONNECTION_MANAGER_BUS_NAME_BASE;
 
441
        QString cmPathBase = TP_QT_CONNECTION_MANAGER_OBJECT_PATH_BASE;
 
442
 
 
443
        protocolObject = new QObject();
 
444
        protocolAdaptor = new ProtocolAdaptor(protocolObject);
 
445
        protocolAddressingAdaptor = new ProtocolAddressingAdaptor(protocolObject);
 
446
        protocolAvatarsAdaptor = new ProtocolAvatarsAdaptor(protocolObject);
 
447
        protocolPresenceAdaptor = new ProtocolPresenceAdaptor(protocolObject);
 
448
        QVERIFY(bus.registerService(cmBusNameBase + cmName));
 
449
        QVERIFY(bus.registerObject(cmPathBase + cmName + QLatin1String("/") + cmName,
 
450
                    protocolObject));
 
451
 
 
452
        ProtocolPropertiesMap protocols;
 
453
        QVariantMap immutableProperties;
 
454
        if (withProtocolProps) {
 
455
            immutableProperties.unite(protocolAdaptor->immutableProperties());
 
456
        }
 
457
        if (withProtocolAddressingProps) {
 
458
            immutableProperties.unite(protocolAddressingAdaptor->immutableProperties());
 
459
        }
 
460
        if (withProtocolAvatarsProps) {
 
461
            immutableProperties.unite(protocolAvatarsAdaptor->immutableProperties());
 
462
        }
 
463
        if (withProtocolPresenceProps) {
 
464
            immutableProperties.unite(protocolPresenceAdaptor->immutableProperties());
 
465
        }
 
466
        protocols.insert(cmName, immutableProperties);
 
467
 
 
468
        cmObject = new QObject();
 
469
        cmAdaptor = new ConnectionManagerAdaptor(protocols, cmObject);
 
470
        QVERIFY(bus.registerService(cmBusNameBase + cmName));
 
471
        QVERIFY(bus.registerObject(cmPathBase + cmName, cmObject));
 
472
 
 
473
        cm = ConnectionManager::create(bus, cmName);
 
474
    }
 
475
 
 
476
    ~CMHelper()
 
477
    {
 
478
        delete cmObject;
 
479
        delete protocolObject;
 
480
    }
 
481
 
 
482
    ConnectionManagerPtr cm;
 
483
    QObject *cmObject;
 
484
    QObject *protocolObject;
 
485
    ConnectionManagerAdaptor *cmAdaptor;
 
486
    ProtocolAdaptor *protocolAdaptor;
 
487
    ProtocolAddressingAdaptor *protocolAddressingAdaptor;
 
488
    ProtocolAvatarsAdaptor *protocolAvatarsAdaptor;
 
489
    ProtocolPresenceAdaptor *protocolPresenceAdaptor;
 
490
};
 
491
 
 
492
class TestCmProtocol : public Test
 
493
{
 
494
    Q_OBJECT
 
495
 
 
496
public:
 
497
    TestCmProtocol(QObject *parent = 0)
 
498
        : Test(parent),
 
499
          mCM(0)
 
500
    {
 
501
    }
 
502
 
 
503
private Q_SLOTS:
 
504
    void initTestCase();
 
505
    void init();
 
506
 
 
507
    void testIntrospection();
 
508
    void testIntrospectionWithManager();
 
509
    void testIntrospectionWithProperties();
 
510
    void testIntrospectionWithSomeProperties();
 
511
 
 
512
    void cleanup();
 
513
    void cleanupTestCase();
 
514
 
 
515
private:
 
516
    void testIntrospectionWithAdaptorCommon(const ConnectionManagerPtr &cm);
 
517
 
 
518
    CMHelper *mCM;
 
519
};
 
520
 
 
521
void TestCmProtocol::initTestCase()
 
522
{
 
523
    initTestCaseImpl();
 
524
}
 
525
 
 
526
void TestCmProtocol::init()
 
527
{
 
528
    initImpl();
 
529
}
 
530
 
 
531
void TestCmProtocol::testIntrospection()
 
532
{
 
533
    mCM = new CMHelper(QLatin1String("protocolnomanager"), false);
 
534
 
 
535
    ConnectionManagerPtr cm = mCM->cm;
 
536
 
 
537
    QVERIFY(connect(cm->becomeReady(),
 
538
                    SIGNAL(finished(Tp::PendingOperation *)),
 
539
                    SLOT(expectSuccessfulCall(Tp::PendingOperation *))));
 
540
    QCOMPARE(mLoop->exec(), 0);
 
541
    QCOMPARE(cm->isReady(), true);
 
542
 
 
543
    testIntrospectionWithAdaptorCommon(cm);
 
544
 
 
545
    QVERIFY(mCM->protocolAdaptor->introspectionCalled > 0);
 
546
    QVERIFY(mCM->protocolAddressingAdaptor->introspectionCalled > 0);
 
547
    QVERIFY(mCM->protocolAvatarsAdaptor->introspectionCalled > 0);
 
548
    QVERIFY(mCM->protocolPresenceAdaptor->introspectionCalled > 0);
 
549
}
 
550
 
 
551
void TestCmProtocol::testIntrospectionWithManager()
 
552
{
 
553
    mCM = new CMHelper(QLatin1String("protocol"), false);
 
554
 
 
555
    ConnectionManagerPtr cm = mCM->cm;
 
556
 
 
557
    QVERIFY(connect(cm->becomeReady(),
 
558
                    SIGNAL(finished(Tp::PendingOperation *)),
 
559
                    SLOT(expectSuccessfulCall(Tp::PendingOperation *))));
 
560
    QCOMPARE(mLoop->exec(), 0);
 
561
    QCOMPARE(cm->isReady(), true);
 
562
 
 
563
    QCOMPARE(cm->interfaces(), QStringList());
 
564
    QCOMPARE(cm->supportedProtocols(), QStringList() << QLatin1String("protocol"));
 
565
 
 
566
    QVERIFY(cm->hasProtocol(QLatin1String("protocol")));
 
567
    QVERIFY(!cm->hasProtocol(QLatin1String("not-there")));
 
568
 
 
569
    ProtocolInfo info = cm->protocol(QLatin1String("protocol"));
 
570
    QVERIFY(info.isValid());
 
571
 
 
572
    QCOMPARE(info.cmName(), QLatin1String("protocol"));
 
573
    QCOMPARE(info.name(), QLatin1String("protocol"));
 
574
    QCOMPARE(info.parameters().size(), 1);
 
575
    ProtocolParameter param = info.parameters().at(0);
 
576
    QCOMPARE(param.name(), QLatin1String("account"));
 
577
    QCOMPARE(static_cast<uint>(param.type()), static_cast<uint>(QVariant::String));
 
578
    QCOMPARE(param.defaultValue().isNull(), true);
 
579
    QCOMPARE(param.dbusSignature().signature(), QLatin1String("s"));
 
580
    QCOMPARE(param.isRequired(), true);
 
581
    QCOMPARE(param.isRequiredForRegistration(), true); // though it can't register!
 
582
    QCOMPARE(param.isSecret(), false);
 
583
    QVERIFY(!info.canRegister());
 
584
    QVERIFY(!info.capabilities().isSpecificToContact());
 
585
    QVERIFY(!info.capabilities().textChatrooms());
 
586
    QVERIFY(info.capabilities().textChats());
 
587
    QCOMPARE(info.vcardField(), QLatin1String("x-telepathy-protocol"));
 
588
    QCOMPARE(info.englishName(), QLatin1String("Telepathy Protocol"));
 
589
    QCOMPARE(info.iconName(), QLatin1String("im-protocol"));
 
590
 
 
591
    QStringList addressableVCardFields = info.addressableVCardFields();
 
592
    QCOMPARE(addressableVCardFields, QStringList() << QLatin1String("x-protocol"));
 
593
    QStringList addressableUriSchemes = info.addressableUriSchemes();
 
594
    QCOMPARE(addressableUriSchemes, QStringList() << QLatin1String("protocol"));
 
595
 
 
596
    AvatarSpec avatarReqs = info.avatarRequirements();
 
597
    QStringList supportedMimeTypes = avatarReqs.supportedMimeTypes();
 
598
    QCOMPARE(supportedMimeTypes, QStringList() << QLatin1String("image/jpeg"));
 
599
    QCOMPARE(avatarReqs.minimumHeight(), (uint) 32);
 
600
    QCOMPARE(avatarReqs.maximumHeight(), (uint) 96);
 
601
    QCOMPARE(avatarReqs.recommendedHeight(), (uint) 64);
 
602
    QCOMPARE(avatarReqs.minimumWidth(), (uint) 32);
 
603
    QCOMPARE(avatarReqs.maximumWidth(), (uint) 96);
 
604
    QCOMPARE(avatarReqs.recommendedWidth(), (uint) 64);
 
605
    QCOMPARE(avatarReqs.maximumBytes(), (uint) 37748736);
 
606
 
 
607
    PresenceSpecList statuses = info.allowedPresenceStatuses();
 
608
    QCOMPARE(statuses.size(), 2);
 
609
    PresenceSpec spec = getPresenceSpec(statuses, QLatin1String("available"));
 
610
    QVERIFY(spec.isValid());
 
611
    QVERIFY(spec.presence().type() == ConnectionPresenceTypeAvailable);
 
612
    QVERIFY(spec.maySetOnSelf());
 
613
    QVERIFY(spec.canHaveStatusMessage());
 
614
    spec = getPresenceSpec(statuses, QLatin1String("offline"));
 
615
    QVERIFY(spec.isValid());
 
616
    QVERIFY(spec.presence().type() == ConnectionPresenceTypeOffline);
 
617
    QVERIFY(!spec.maySetOnSelf());
 
618
    QVERIFY(!spec.canHaveStatusMessage());
 
619
 
 
620
    QCOMPARE(mCM->protocolAdaptor->introspectionCalled, 0);
 
621
    QCOMPARE(mCM->protocolAddressingAdaptor->introspectionCalled, 0);
 
622
    QCOMPARE(mCM->protocolAvatarsAdaptor->introspectionCalled, 0);
 
623
    QCOMPARE(mCM->protocolPresenceAdaptor->introspectionCalled, 0);
 
624
}
 
625
 
 
626
void TestCmProtocol::testIntrospectionWithProperties()
 
627
{
 
628
    mCM = new CMHelper(QLatin1String("protocolwithprops"),
 
629
            true, true, true, true);
 
630
 
 
631
    ConnectionManagerPtr cm = mCM->cm;
 
632
 
 
633
    QVERIFY(connect(cm->becomeReady(),
 
634
                    SIGNAL(finished(Tp::PendingOperation *)),
 
635
                    SLOT(expectSuccessfulCall(Tp::PendingOperation *))));
 
636
    QCOMPARE(mLoop->exec(), 0);
 
637
    QCOMPARE(cm->isReady(), true);
 
638
 
 
639
    testIntrospectionWithAdaptorCommon(cm);
 
640
 
 
641
    QCOMPARE(mCM->protocolAdaptor->introspectionCalled, 0);
 
642
    QCOMPARE(mCM->protocolAddressingAdaptor->introspectionCalled, 0);
 
643
    QCOMPARE(mCM->protocolAvatarsAdaptor->introspectionCalled, 0);
 
644
    QCOMPARE(mCM->protocolPresenceAdaptor->introspectionCalled, 0);
 
645
}
 
646
 
 
647
void TestCmProtocol::testIntrospectionWithSomeProperties()
 
648
{
 
649
    mCM = new CMHelper(QLatin1String("protocolwithsomeprops"),
 
650
            false, false, true, true);
 
651
 
 
652
    ConnectionManagerPtr cm = mCM->cm;
 
653
 
 
654
    QVERIFY(connect(cm->becomeReady(),
 
655
                    SIGNAL(finished(Tp::PendingOperation *)),
 
656
                    SLOT(expectSuccessfulCall(Tp::PendingOperation *))));
 
657
    QCOMPARE(mLoop->exec(), 0);
 
658
    QCOMPARE(cm->isReady(), true);
 
659
 
 
660
    testIntrospectionWithAdaptorCommon(cm);
 
661
 
 
662
    QVERIFY(mCM->protocolAdaptor->introspectionCalled > 0);
 
663
    QVERIFY(mCM->protocolAddressingAdaptor->introspectionCalled > 0);
 
664
    QCOMPARE(mCM->protocolAvatarsAdaptor->introspectionCalled, 0);
 
665
    QCOMPARE(mCM->protocolPresenceAdaptor->introspectionCalled, 0);
 
666
}
 
667
 
 
668
void TestCmProtocol::testIntrospectionWithAdaptorCommon(const ConnectionManagerPtr &cm)
 
669
{
 
670
    QCOMPARE(cm->interfaces(), QStringList());
 
671
    QCOMPARE(cm->supportedProtocols(), QStringList() << cm->name());
 
672
 
 
673
    QVERIFY(cm->hasProtocol(cm->name()));
 
674
    QVERIFY(!cm->hasProtocol(QLatin1String("not-there")));
 
675
 
 
676
    ProtocolInfo info = cm->protocol(cm->name());
 
677
    QVERIFY(info.isValid());
 
678
 
 
679
    QCOMPARE(info.cmName(), cm->name());
 
680
    QCOMPARE(info.name(), cm->name());
 
681
 
 
682
    QCOMPARE(info.parameters().size(), 0);
 
683
    QVERIFY(!info.canRegister());
 
684
    QVERIFY(!info.capabilities().isSpecificToContact());
 
685
    QVERIFY(info.capabilities().textChatrooms());
 
686
    QVERIFY(!info.capabilities().textChats());
 
687
    QCOMPARE(info.vcardField(), QLatin1String("x-adaptor"));
 
688
    QCOMPARE(info.englishName(), QLatin1String("Adaptor"));
 
689
    QCOMPARE(info.iconName(), QLatin1String("icon-adaptor"));
 
690
 
 
691
    QStringList addressableVCardFields = info.addressableVCardFields();
 
692
    QCOMPARE(addressableVCardFields, QStringList() << QLatin1String("x-adaptor"));
 
693
    QStringList addressableUriSchemes = info.addressableUriSchemes();
 
694
    QCOMPARE(addressableUriSchemes, QStringList() << QLatin1String("adaptor"));
 
695
 
 
696
    AvatarSpec avatarReqs = info.avatarRequirements();
 
697
    QStringList supportedMimeTypes = avatarReqs.supportedMimeTypes();
 
698
    QCOMPARE(supportedMimeTypes, QStringList() << QLatin1String("image/png"));
 
699
    QCOMPARE(avatarReqs.minimumHeight(), (uint) 16);
 
700
    QCOMPARE(avatarReqs.maximumHeight(), (uint) 64);
 
701
    QCOMPARE(avatarReqs.recommendedHeight(), (uint) 32);
 
702
    QCOMPARE(avatarReqs.minimumWidth(), (uint) 16);
 
703
    QCOMPARE(avatarReqs.maximumWidth(), (uint) 64);
 
704
    QCOMPARE(avatarReqs.recommendedWidth(), (uint) 32);
 
705
    QCOMPARE(avatarReqs.maximumBytes(), (uint) 4096);
 
706
 
 
707
    PresenceSpecList statuses = info.allowedPresenceStatuses();
 
708
    QCOMPARE(statuses.size(), 1);
 
709
    PresenceSpec spec = getPresenceSpec(statuses, QLatin1String("available"));
 
710
    QVERIFY(spec.isValid());
 
711
    QVERIFY(spec.presence().type() == ConnectionPresenceTypeAvailable);
 
712
    QVERIFY(spec.maySetOnSelf());
 
713
    QVERIFY(!spec.canHaveStatusMessage());
 
714
    spec = getPresenceSpec(statuses, QLatin1String("offline"));
 
715
    QVERIFY(!spec.isValid());
 
716
}
 
717
 
 
718
void TestCmProtocol::cleanup()
 
719
{
 
720
    cleanupImpl();
 
721
}
 
722
 
 
723
void TestCmProtocol::cleanupTestCase()
 
724
{
 
725
    delete mCM;
 
726
 
 
727
    cleanupTestCaseImpl();
 
728
}
 
729
 
 
730
QTEST_MAIN(TestCmProtocol)
 
731
#include "_gen/cm-protocol.cpp.moc.hpp"