1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 *

     5 * This program is free software: you can redistribute it and/or modify

     6 * it under the terms of the GNU Lesser General Public License as published by

     7 * the Free Software Foundation, version 2.1 of the License.

     8 * 

     9 * This program is distributed in the hope that it will be useful,

    10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12 * GNU Lesser General Public License for more details.

    13 *

    14 * You should have received a copy of the GNU Lesser General Public License

    15 * along with this program.  If not, 

    16 * see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

    17 *

    18 * Description:                                                         

    19 *

    20 */

    21 

    22 #include <QtTest>

    23 #include <qmetaobject.h>

    24 #include <QVariant>

    25 

    26 #include "xqservicerequest.h"

    27 #include "xqserviceprovider.h"

    28 

    29 class testServiceProvider;

    30 

    31 class ut_XQServiceRequest : public QObject

    32 {

    33     Q_OBJECT

    34 public:

    35     ut_XQServiceRequest() {}

    36     ~ut_XQServiceRequest() {}

    37 

    38 private slots:

    39     void initTestCase();

    40 

    41     void testClassIstantiation();

    42     void testSerializeArguments();

    43     

    44     void testParam1();

    45     void testParam2();

    46     void testParam3();

    47     void testParam4();

    48     void testParam5();

    49 

    50     void testRetParamBool();

    51     void testRetParamInt();

    52     void testRetParamUInt();

    53     void testRetParamQString();

    54     void testRetParamQStringList();

    55     void testRetParamQByteArray();

    56     void testRetParamQDate();

    57     void testRetParamQTime();

    58     void testRetParamQDateTime();

    59     void testRetParamQUrl();

    60     void testRetParamQSize();

    61     void testRetParamQSizeF();

    62     void testRetParamQPoint();

    63     void testRetParamQPointF();

    64     void testRetParamQRect();

    65     void testRetParamQRectF();

    66     void testRetParamTestContact();

    67     void testLatestError();

    68     

    69 public slots:

    70 

    71 signals:

    72 

    73 private:

    74     testServiceProvider* provider;

    75 };

    76 

    77 class TestContact

    78 {

    79     friend bool operator==( const TestContact &c1, const TestContact &c2 );

    80 public:

    81     

    82     TestContact();

    83     ~TestContact();

    84     void setSurname(const QString&);

    85     void setFirstname(const QString&);

    86     void setNumber(const QString&);

    87     void setDate(const QDate&);

    88     void setUid(const QUuid&);

    89 

    90     QString surname();

    91     QString firstname();

    92     QString number();

    93     QDate date();

    94     QUuid uid();

    95 

    96     template <typename Stream> void serialize(Stream &stream) const;

    97     template <typename Stream> void deserialize(Stream &stream);

    98    

    99 private:

   100     QString mSurname;

   101     QString mFirstname;

   102     QString mNumber;

   103     QDate   mBorn;

   104     QUuid    mUid;

   105 };

   106 

   107 inline bool operator== ( const TestContact & c1, const TestContact & c2 )

   108 {

   109     return (c1.mSurname == c2.mSurname) && 

   110            (c1.mFirstname == c2.mFirstname) && 

   111            (c1.mNumber == c2.mNumber) && 

   112            (c1.mBorn == c2.mBorn) && 

   113            (c1.mUid == c2.mUid);

   114 }

   115 

   116 

   117 

   118 Q_DECLARE_USER_METATYPE(TestContact)

   119 

   120 #define METHOD_TEST1 "test1(bool,int,uint,QString,QStringList,QVariant)"

   121 #define METHOD_TEST2 "test2(QByteArray,QDate,QTime,QDateTime,QUrl)"

   122 #define METHOD_TEST3 "test3(QSize,QSizeF,QPoint,QPointF,QRect,QRectF)"

   123 #define METHOD_TEST4 "test4(TestContact)"

   124 #define METHOD_TEST5 "test5(QString,QString,QString,QString)"

   125 #define SERVICE_TEST "com.nokia.services.TestInterface"

   126 

   127 class testServiceProvider : public XQServiceProvider

   128 {

   129     Q_OBJECT

   130 public:

   131     testServiceProvider( QObject *parent = 0 );

   132     ~testServiceProvider();

   133     

   134 public slots:

   135     QString test1(bool parBool,

   136                   int parInt, 

   137                   uint parUint, 

   138                   const QString& parQstring, 

   139                   const QStringList& parQStringList,

   140                   const QVariant& parVariant);

   141 

   142     QString test2(const QByteArray& parQByteArray,

   143                   const QDate& parQdate,

   144                   const QTime& parQTime, 

   145                   const QDateTime& parQDateTime, 

   146                   const QUrl& parQUrl);

   147 

   148     QString test3(const QSize& parQSize,

   149                   const QSizeF& parQSizeF, 

   150                   const QPoint& parQPoint,

   151                   const QPointF& parQPointF,

   152                   const QRect& parQRect, 

   153                   const QRectF& parQRectF);

   154 

   155     QString test4(const TestContact& parTestContact) ;

   156 

   157     QString test5(

   158             const QString& par1,

   159             const QString& par2,

   160             const QString& par3,

   161             const QString& par4);

   162 

   163     bool retParamBool();

   164     int retParamInt();

   165     uint retParamUInt();

   166     QString retParamQString(int size);

   167     QStringList retParamQStringList();

   168     QByteArray retParamQByteArray(int size);

   169     QDate retParamQDate();

   170     QTime retParamQTime();

   171     QDateTime retParamQDateTime();    

   172     QUrl retParamQUrl();

   173     QSize retParamQSize();

   174     QSizeF retParamQSizeF();

   175     QPoint retParamQPoint();

   176     QPointF retParamQPointF();

   177     QRect retParamQRect();

   178     QRectF retParamQRectF();

   179 

   180     TestContact retParamTestContact();

   181 

   182 public:

   183     void reset();

   184 

   185     QString mMessage;

   186     QString mRetValue;

   187 

   188     bool mParBool;

   189     int mParInt;

   190     uint mParUint;

   191     QString mParQString;

   192     QStringList mParQStringList;

   193     QVariant mParVariant;

   194 

   195     QString mParQString1;

   196     QString mParQString2;

   197     QString mParQString3;

   198     QString mParQString4;

   199     

   200     QByteArray mParQByteArray;

   201     QDate mParQDate;

   202     QTime mParQTime; 

   203     QDateTime mParQDateTime; 

   204     QUrl mParQUrl;

   205 

   206     QSize mParQSize;

   207     QSizeF mParQSizeF;

   208     QPoint mParQPoint;

   209     QPointF mParQPointF;

   210     QRect mParQRect;

   211     QRectF mParQRectF; 

   212     

   213     TestContact mParTestContact;

   214     

   215 };

   216 

   217 testServiceProvider::testServiceProvider(QObject *parent)

   218 : XQServiceProvider(QLatin1String(SERVICE_TEST),parent)

   219 {

   220 publishAll();

   221 }

   222 

   223 testServiceProvider::~testServiceProvider()

   224 {

   225 }

   226 

   227 void testServiceProvider::reset()

   228 {

   229     mMessage.clear();

   230     

   231     mParBool=false;

   232     mParInt=0;

   233     mParUint=0;

   234     mParQString.clear();

   235     mParQStringList.clear();

   236     mParVariant.clear();

   237     

   238     mRetValue.clear();

   239 

   240     mParQByteArray.clear();

   241     mParQDate.setDate(0,0,0);

   242     

   243 }

   244 

   245 QString testServiceProvider::test1(

   246         bool parBool,

   247         int parInt, 

   248         uint parUint, 

   249         const QString& parQstring, 

   250         const QStringList& parQStringList, 

   251         const QVariant& parVariant)

   252 {

   253     mMessage=QString(METHOD_TEST1);

   254     mRetValue = "retTest1";

   255     mParBool=parBool;

   256     mParInt=parInt;

   257     mParUint=parUint;

   258     mParQString=parQstring;

   259     mParQStringList=parQStringList;

   260     mParVariant=parVariant;

   261     return mRetValue;

   262 }

   263 

   264 QString testServiceProvider::test2(

   265         const QByteArray& parQByteArray,

   266         const QDate& parQdate,

   267         const QTime& parQTime, 

   268         const QDateTime& parQDateTime, 

   269         const QUrl& parQUrl)

   270 {

   271     mMessage=QString(METHOD_TEST2);

   272     mRetValue = "retTest2";

   273     mParQByteArray=parQByteArray;

   274     mParQDate=parQdate;

   275     mParQTime=parQTime; 

   276     mParQDateTime=parQDateTime; 

   277     mParQUrl=parQUrl;

   278     return mRetValue;

   279 }

   280 

   281 QString testServiceProvider::test3(

   282         const QSize& parQSize,

   283         const QSizeF& parQSizeF, 

   284         const QPoint& parQPoint,

   285         const QPointF& parQPointF,

   286         const QRect& parQRect, 

   287         const QRectF& parQRectF)

   288 {

   289     mMessage=QString(METHOD_TEST3);

   290     mRetValue = "retTest3";

   291     mParQSize=parQSize;

   292     mParQSizeF=parQSizeF;

   293     mParQPoint=parQPoint;

   294     mParQPointF=parQPointF;

   295     mParQRect=parQRect;

   296     mParQRectF=parQRectF; 

   297     return mRetValue;

   298 }

   299 

   300 QString testServiceProvider::test4(const TestContact& parTestContact)

   301 {

   302     mMessage=QString(METHOD_TEST4);

   303     mRetValue = "retTest4";

   304     mParTestContact=parTestContact;

   305     return mRetValue;

   306 }

   307 

   308 QString testServiceProvider::test5(

   309         const QString& par1,

   310         const QString& par2,

   311         const QString& par3,

   312         const QString& par4)

   313 {

   314     mMessage=QString(METHOD_TEST5);

   315     mRetValue = "retTest5";

   316     mParQString1=par1;

   317     mParQString2=par2;

   318     mParQString3=par3;

   319     mParQString4=par4;

   320     return mRetValue;

   321 }

   322 

   323 bool testServiceProvider::retParamBool()

   324 {

   325 mParBool = true;

   326 return mParBool;

   327 }

   328 

   329 int testServiceProvider::retParamInt()

   330 {

   331 mParInt = -98765;

   332 return mParInt;

   333 }

   334 

   335 uint testServiceProvider::retParamUInt()

   336 {

   337 mParUint = 98765;

   338 return mParUint;

   339 }

   340 

   341 QString testServiceProvider::retParamQString(int size)

   342 {

   343 mParQString.clear();

   344 mParQString = QString(size,'A');

   345 return mParQString;

   346 }

   347 

   348 QStringList testServiceProvider::retParamQStringList()

   349 {

   350 mParQStringList.clear();

   351 for (int i = 0 ; i < 10 ; i++)

   352     mParQStringList << "string "+QString::number(i); 

   353 return mParQStringList;

   354 }

   355 

   356 QByteArray testServiceProvider::retParamQByteArray(int size)

   357 {

   358 mParQByteArray=QByteArray(size,'A');

   359 return mParQByteArray;

   360 }

   361 

   362 QDate testServiceProvider::retParamQDate()

   363 {

   364 mParQDate = QDate(2009,12,11);

   365 return mParQDate;

   366 }

   367 

   368 QTime testServiceProvider::retParamQTime()

   369 {

   370 mParQTime = QTime(10,9,8);

   371 return mParQTime;

   372 }

   373 

   374 QDateTime testServiceProvider::retParamQDateTime()

   375 {

   376 mParQDateTime = QDateTime(mParQDate,mParQTime);

   377 return mParQDateTime;

   378 }

   379 

   380 QUrl testServiceProvider::retParamQUrl()

   381 {

   382 mParQUrl = QUrl("http://www.nokia.com");

   383 return mParQUrl;

   384 }

   385 

   386 QSize testServiceProvider::retParamQSize()

   387 {

   388 mParQSize = QSize(123,321);

   389 return mParQSize;

   390 }

   391 

   392 QSizeF testServiceProvider::retParamQSizeF()

   393 {

   394 mParQSizeF = QSizeF(1234567890.54321,987654321.12345);

   395 return mParQSizeF;

   396 }

   397 

   398 QPoint testServiceProvider::retParamQPoint()

   399 {

   400 mParQPoint = QPoint(1234,4321);

   401 return mParQPoint;

   402 }

   403 

   404 QPointF testServiceProvider::retParamQPointF()

   405 {

   406 mParQPointF = QPointF(1234567890.54321,987654321.12345);

   407 return mParQPointF;

   408 }

   409 

   410 QRect testServiceProvider::retParamQRect()

   411 {

   412 mParQRect = QRect(mParQPoint,mParQSize); 

   413 return mParQRect;

   414 }

   415 

   416 QRectF testServiceProvider::retParamQRectF()

   417 {

   418 mParQRectF = QRectF(mParQPointF,mParQSizeF); 

   419 return mParQRectF;

   420 }

   421 

   422 TestContact testServiceProvider::retParamTestContact()

   423 {

   424 mParTestContact.setSurname("piro-RetParam");

   425 mParTestContact.setFirstname("stephen-RetParam");

   426 mParTestContact.setNumber(QString("+35850987654321"));

   427 mParTestContact.setDate(QDate(1963,12,17));

   428 mParTestContact.setUid(QUuid::createUuid());

   429 return mParTestContact;

   430 }

   431 

   432 void ut_XQServiceRequest::initTestCase()

   433 {

   434     provider = new testServiceProvider(this); 

   435 }

   436 

   437 void ut_XQServiceRequest::testClassIstantiation()

   438 {

   439     QString service("com.nokia.service.test");

   440     QString msg("test(QString)");

   441 

   442     {

   443         XQServiceRequest snd;

   444         QVERIFY(snd.isNull());

   445         snd.setService(service);

   446         snd.setMessage(msg);        

   447         QVERIFY(!snd.isNull());

   448         QCOMPARE(snd.service(),service);

   449         QCOMPARE(snd.message(),msg);

   450     }

   451 

   452     {

   453         XQServiceRequest snd(service,msg);

   454         QVERIFY(!snd.isNull());

   455         QCOMPARE(snd.service(),service);

   456         QCOMPARE(snd.message(),msg);

   457         

   458         XQServiceRequest snd1(snd);

   459         QVERIFY(!snd1.isNull());

   460         QCOMPARE(snd1.service(),service);

   461         QCOMPARE(snd1.message(),msg);

   462         

   463         QCOMPARE(snd,snd1);

   464     }

   465 }

   466 

   467 void ut_XQServiceRequest::testSerializeArguments()

   468 {

   469     XQServiceRequest snd(QLatin1String(SERVICE_TEST),"test(QString,QDate,QTime)");

   470     

   471     snd << QString("test")

   472         << QDate(2009,1,1)

   473         << QTime(8,1,2);

   474     

   475     QByteArray ret = XQServiceRequest::serializeArguments(snd);

   476 

   477     XQServiceRequest snd1(QLatin1String(SERVICE_TEST),"test(QString,QDate,QTime)");

   478     XQServiceRequest::deserializeArguments(snd1, ret);

   479 

   480 

   481     QCOMPARE(snd,snd1);

   482 }

   483 

   484 void ut_XQServiceRequest::testParam1()

   485 {

   486     QString service(SERVICE_TEST);

   487     QVariant ret;

   488     bool par1 = true;

   489     int par2 = -12345;

   490     uint par3 = 54321;

   491     QString par4("Test String");

   492     QStringList par5;

   493     par5 << "string 1" << "string 2" << "string 3" ; 

   494     QVariant par6 = qVariantFromValue(QDate(1963,12,17));

   495 

   496     QString msg(METHOD_TEST1);

   497     XQServiceRequest snd(service,msg);

   498     

   499     snd << par1 << par2 << par3 << par4 << par5 << par6;

   500     bool res = snd.send(ret);        

   501     // Check that the correct values were delivered.

   502     QCOMPARE(res,true);        

   503     QCOMPARE(provider->mParBool,par1);        

   504     QCOMPARE(provider->mParInt, par2);

   505     QCOMPARE(provider->mParUint, par3);

   506     QCOMPARE(provider->mParQString, par4);

   507     QCOMPARE(provider->mParQStringList, par5);

   508     QCOMPARE(provider->mParVariant, par6);

   509     QCOMPARE(provider->mMessage, msg);        

   510     QCOMPARE(provider->mRetValue, ret.toString());

   511 }

   512 

   513 void ut_XQServiceRequest::testParam2()

   514 {

   515     QString service(SERVICE_TEST);

   516     QVariant ret;

   517     QByteArray par1(1024,'A');

   518     QDate par2(2009,12,17);

   519     QTime par3(11,12,13); 

   520     QDateTime par4(par2,par3); 

   521     QUrl par5("http://www.nokia.com");

   522 

   523     QString msg(METHOD_TEST2);

   524     XQServiceRequest snd(service,msg);

   525     

   526     snd << par1 << par2 << par3 << par4 << par5;

   527     bool res = snd.send(ret);        

   528     // Check that the correct values were delivered.

   529     QCOMPARE(res,true);        

   530     QCOMPARE(provider->mParQByteArray,par1);        

   531     QCOMPARE(provider->mParQDate, par2);

   532     QCOMPARE(provider->mParQTime, par3);

   533     QCOMPARE(provider->mParQDateTime, par4);

   534     QCOMPARE(provider->mParQUrl, par5);

   535     QCOMPARE(provider->mMessage, msg);        

   536     QCOMPARE(provider->mRetValue, ret.toString());        

   537 }

   538 

   539 void ut_XQServiceRequest::testParam3()

   540 {

   541     QString service(SERVICE_TEST);

   542     QVariant ret;

   543     QSize par1(123,321);

   544     QSizeF par2(1234567890.54321,987654321.12345);

   545     QPoint par3(1234,4321);

   546     QPointF par4(1234567890.54321,987654321.12345);

   547     QRect par5(par3,par1); 

   548     QRectF par6(par4,par2);

   549 

   550     QString msg(METHOD_TEST3);

   551     XQServiceRequest snd(service,msg);

   552     

   553     snd << par1 << par2 << par3 << par4 << par5 << par6;

   554     bool res = snd.send(ret);        

   555     // Check that the correct values were delivered.

   556     QCOMPARE(res,true);        

   557     QCOMPARE(provider->mParQSize,par1);        

   558     QCOMPARE(provider->mParQSizeF, par2);

   559     QCOMPARE(provider->mParQPoint, par3);

   560     QCOMPARE(provider->mParQPointF, par4);

   561     QCOMPARE(provider->mParQRect, par5);

   562     QCOMPARE(provider->mParQRectF, par6);

   563     QCOMPARE(provider->mMessage, msg);        

   564     QCOMPARE(provider->mRetValue, ret.toString());        

   565 }

   566 

   567 void ut_XQServiceRequest::testParam4()

   568 {

   569     QString service(SERVICE_TEST);

   570     QVariant ret;

   571     TestContact par1;

   572     par1.setSurname("piro");

   573     par1.setFirstname("stephen");

   574     par1.setNumber(QString("+35850987654321"));

   575     par1.setDate(QDate(1963,12,17));

   576     par1.setUid(QUuid::createUuid());

   577     

   578     QString msg(METHOD_TEST4);

   579     XQServiceRequest snd(service,msg);

   580     

   581     snd << par1 ;

   582     bool res = snd.send(ret);        

   583     // Check that the correct values were delivered.

   584     QCOMPARE(res,true);        

   585     QCOMPARE(provider->mParTestContact,par1);        

   586     QCOMPARE(provider->mMessage, msg);        

   587     QCOMPARE(provider->mRetValue, ret.toString());        

   588 }

   589 

   590 void ut_XQServiceRequest::testParam5()

   591 {

   592     QString service(SERVICE_TEST);

   593     QVariant ret;

   594     QString par1 = "parameter 1";

   595     QString par2 = "parameter 2";

   596     QString par3 = "parameter 3";

   597     QString par4 = "parameter 4";

   598     

   599     QString msg(METHOD_TEST5);

   600     XQServiceRequest snd(service,msg);

   601     

   602     snd << par1 << par2 << par3 << par4;

   603     bool res = snd.send(ret);        

   604     // Check that the correct values were delivered.

   605     QCOMPARE(res,true);        

   606     QCOMPARE(provider->mParQString1,par1);        

   607     QCOMPARE(provider->mParQString2,par2);        

   608     QCOMPARE(provider->mParQString3,par3);        

   609     QCOMPARE(provider->mParQString4,par4);        

   610     QCOMPARE(provider->mMessage, msg);        

   611     QCOMPARE(provider->mRetValue, ret.toString());        

   612 }

   613 

   614 void ut_XQServiceRequest::testRetParamBool()

   615 {

   616     XQServiceRequest snd(SERVICE_TEST,"retParamBool()");

   617     bool ret;

   618     bool res = snd.send(ret);        

   619     QCOMPARE(res,true);        

   620     QCOMPARE(provider->mParBool, ret);        

   621 }

   622 

   623 void ut_XQServiceRequest::testRetParamInt()

   624 {

   625     XQServiceRequest snd(SERVICE_TEST,"retParamInt()");

   626     int ret;

   627     bool res = snd.send(ret);        

   628     QCOMPARE(res,true);        

   629     QCOMPARE(provider->mParInt, ret);        

   630 }

   631 

   632 void ut_XQServiceRequest::testRetParamUInt()

   633 {

   634     XQServiceRequest snd(SERVICE_TEST,"retParamUInt()");

   635     uint ret;

   636     bool res = snd.send(ret);        

   637     QCOMPARE(res,true);        

   638     QCOMPARE(provider->mParUint, ret);        

   639 }

   640 

   641 void ut_XQServiceRequest::testRetParamQString()

   642 {

   643     XQServiceRequest snd(SERVICE_TEST,"retParamQString(int)");

   644     QList<int> testSizes;

   645     testSizes << 100 << 1024 << 2048 << 4096 ;

   646     foreach(int size,testSizes) {

   647         QString ret;

   648         snd.setMessage("retParamQString(int)");

   649         snd << size ;

   650         bool res = snd.send(ret);        

   651         QCOMPARE(res,true);        

   652         QCOMPARE(provider->mParQString, ret);

   653     }

   654 }

   655 

   656 void ut_XQServiceRequest::testRetParamQStringList()

   657 {

   658     XQServiceRequest snd(SERVICE_TEST,"retParamQStringList()");

   659     QStringList ret;

   660     bool res = snd.send(ret);        

   661     QCOMPARE(res,true);        

   662     QCOMPARE(provider->mParQStringList, ret);        

   663 }

   664 

   665 void ut_XQServiceRequest::testRetParamQByteArray()

   666 {

   667     XQServiceRequest snd(SERVICE_TEST,"retParamQByteArray(int)");

   668     QList<int> testSizes;

   669     testSizes << 100 << 1024 << 2048 << 4096 ;

   670     foreach(int size,testSizes) {

   671         QByteArray ret;

   672         snd.setMessage("retParamQByteArray(int)");

   673         snd << size ;

   674         bool res = snd.send(ret);        

   675         QCOMPARE(res,true);        

   676         QCOMPARE(provider->mParQByteArray, ret);        

   677     }

   678 

   679 }

   680 

   681 void ut_XQServiceRequest::testRetParamQDate()

   682 {

   683     XQServiceRequest snd(SERVICE_TEST,"retParamQDate()");

   684     QDate ret;

   685     bool res = snd.send(ret);        

   686     QCOMPARE(res,true);        

   687     QCOMPARE(provider->mParQDate, ret);        

   688 }

   689 

   690 void ut_XQServiceRequest::testRetParamQTime()

   691 {

   692     XQServiceRequest snd(SERVICE_TEST,"retParamQTime()");

   693     QTime ret;

   694     bool res = snd.send(ret);        

   695     QCOMPARE(res,true);        

   696     QCOMPARE(provider->mParQTime, ret);        

   697 }

   698 

   699 void ut_XQServiceRequest::testRetParamQDateTime()

   700 {

   701     XQServiceRequest snd(SERVICE_TEST,"retParamQDateTime()");

   702     QDateTime ret;

   703     bool res = snd.send(ret);        

   704     QCOMPARE(res,true);        

   705     QCOMPARE(provider->mParQDateTime, ret);        

   706 }

   707 

   708 void ut_XQServiceRequest::testRetParamQUrl()

   709 {

   710     XQServiceRequest snd(SERVICE_TEST,"retParamQUrl()");

   711     QUrl ret;

   712     bool res = snd.send(ret);        

   713     QCOMPARE(res,true);        

   714     QCOMPARE(provider->mParQUrl, ret);        

   715 }

   716 

   717 void ut_XQServiceRequest::testRetParamQSize()

   718 {

   719     XQServiceRequest snd(SERVICE_TEST,"retParamQSize()");

   720     QSize ret;

   721     bool res = snd.send(ret);        

   722     QCOMPARE(res,true);        

   723     QCOMPARE(provider->mParQSize, ret);        

   724 }

   725 

   726 void ut_XQServiceRequest::testRetParamQSizeF()

   727 {

   728     XQServiceRequest snd(SERVICE_TEST,"retParamQSizeF()");

   729     QSizeF ret;

   730     bool res = snd.send(ret);        

   731     QCOMPARE(res,true);        

   732     QCOMPARE(provider->mParQSizeF, ret);        

   733 }

   734 

   735 void ut_XQServiceRequest::testRetParamQPoint()

   736 {

   737     XQServiceRequest snd(SERVICE_TEST,"retParamQPoint()");

   738     QPoint ret;

   739     bool res = snd.send(ret);        

   740     QCOMPARE(res,true);        

   741     QCOMPARE(provider->mParQPoint, ret);        

   742 }

   743 

   744 void ut_XQServiceRequest::testRetParamQPointF()

   745 {

   746     XQServiceRequest snd(SERVICE_TEST,"retParamQPointF()");

   747     QPointF ret;

   748     bool res = snd.send(ret);        

   749     QCOMPARE(res,true);        

   750     QCOMPARE(provider->mParQPointF, ret);        

   751 }

   752 

   753 void ut_XQServiceRequest::testRetParamQRect()

   754 {

   755     XQServiceRequest snd(SERVICE_TEST,"retParamQRect()");

   756     QRect ret;

   757     bool res = snd.send(ret);        

   758     QCOMPARE(res,true);        

   759     QCOMPARE(provider->mParQRect, ret);        

   760 }

   761 

   762 void ut_XQServiceRequest::testRetParamQRectF()

   763 {

   764     XQServiceRequest snd(SERVICE_TEST,"retParamQRectF()");

   765     QRectF ret;

   766     bool res = snd.send(ret);        

   767     QCOMPARE(res,true);        

   768     QCOMPARE(provider->mParQRectF, ret);        

   769 }

   770 

   771 void ut_XQServiceRequest::testRetParamTestContact()

   772 {

   773     XQServiceRequest snd(SERVICE_TEST,"retParamTestContact()");

   774     TestContact ret;

   775     bool res = snd.send(ret);        

   776     QCOMPARE(res,true);        

   777     QCOMPARE(provider->mParTestContact,ret);        

   778 }

   779 

   780 void ut_XQServiceRequest::testLatestError()

   781 {

   782     QString service(SERVICE_TEST);

   783     QString msg(METHOD_TEST1);

   784     XQServiceRequest snd(service,msg);

   785     int error = snd.latestError();    

   786     QCOMPARE(error,-4998);    

   787 }

   788 

   789 

   790 TestContact::TestContact()

   791 {

   792 }

   793 

   794 TestContact::~TestContact()

   795 {

   796 }

   797 

   798 void TestContact::setSurname(const QString& surname)

   799 {

   800 mSurname = surname;

   801 }

   802 

   803 void TestContact::setFirstname(const QString& name)

   804 {

   805 mFirstname = name;

   806 }

   807 

   808 void TestContact::setNumber(const QString& number)

   809 {

   810 mNumber = number;

   811 }

   812 

   813 void TestContact::setDate(const QDate& date)

   814 {

   815 mBorn = date;

   816 }

   817 

   818 void TestContact::setUid(const QUuid& uid)

   819 {

   820 mUid = uid;

   821 }

   822 

   823 

   824 QString TestContact::surname()

   825 {

   826 return mSurname;

   827 }

   828 

   829 QString TestContact::firstname()

   830 {

   831 return mFirstname;

   832 }

   833 

   834 QString TestContact::number()

   835 {

   836 return mNumber;

   837 }

   838 

   839 QDate TestContact::date()

   840 {

   841 return mBorn;

   842 }

   843 

   844 QUuid TestContact::uid()

   845 {

   846 return mUid;

   847 }

   848 

   849 Q_IMPLEMENT_USER_METATYPE(TestContact)

   850 

   851 

   852 template <typename Stream> void TestContact::serialize(Stream &s) const

   853 {

   854     s << mSurname;

   855     s << mFirstname;

   856     s << mNumber;

   857     s << mBorn;

   858     s << mUid;

   859 }

   860 

   861 template <typename Stream> void TestContact::deserialize(Stream &s)

   862 {

   863     s >> mSurname;

   864     s >> mFirstname;

   865     s >> mNumber;

   866     s >> mBorn;

   867     s >> mUid;

   868 }

   869         

   870 QTEST_MAIN(ut_XQServiceRequest)

   871 

   872 #include "ut_xqservicerequest.moc"