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 <QtCore/qmetaobject.h>

    24 

    25 #include "xqservicerequest.h"

    26 #include "xqserviceprovider.h"

    27 

    28 class testServiceProvider;

    29 

    30 class ut_XQServiceProvider : public QObject

    31 {

    32     Q_OBJECT

    33 public:

    34     ut_XQServiceProvider() {}

    35     ~ut_XQServiceProvider() {}

    36 

    37 private slots:

    38     void initTestCase();

    39 

    40     void send_data();

    41     void send();

    42     

    43 public slots:

    44 

    45 signals:

    46 

    47 private:

    48     testServiceProvider* service;

    49 };

    50 

    51 class testServiceProvider : public XQServiceProvider

    52 {

    53     Q_OBJECT

    54 public:

    55     testServiceProvider( QObject *parent = 0 );

    56     ~testServiceProvider();

    57     

    58 public slots:

    59     QString test1(const QString& par1);

    60     QString test2(const QString& par1, int par2);

    61     QString test3(const QString& par1, int par2, const QByteArray& par3);

    62     

    63 public:

    64     void reset();

    65 

    66     QString mMessage;

    67     QString mPar1;

    68     int mPar2;

    69     QByteArray mPar3;

    70     QString mRetValue;

    71 };

    72 

    73 testServiceProvider::testServiceProvider(QObject *parent)

    74 : XQServiceProvider(QLatin1String("com.nokia.services.TestInterface"),parent)

    75 {

    76 publishAll();

    77 }

    78 

    79 testServiceProvider::~testServiceProvider()

    80 {

    81 }

    82 

    83 void testServiceProvider::reset()

    84 {

    85 mMessage.clear();

    86 mPar1.clear();

    87 mPar2=0;

    88 mPar3.clear();

    89 mRetValue.clear();

    90 }

    91 

    92 QString testServiceProvider::test1(const QString& par1)

    93 {

    94 mMessage=QString("test1(QString)");

    95 mRetValue = par1+"-retTest1";

    96 mPar1 = par1;

    97 return mRetValue;

    98 }

    99 

   100 QString testServiceProvider::test2(const QString& par1, int par2)

   101 {

   102 mMessage=QString("test2(QString,int)");

   103 mRetValue = par1+"-retTest2";

   104 mPar1 = par1;

   105 mPar2 = par2;

   106 return mRetValue;

   107 }

   108 

   109 QString testServiceProvider::test3(const QString& par1, int par2, const QByteArray& par3)

   110 {

   111 mMessage=QString("test3(QString,int,QByteArray)");

   112 mRetValue = par1+"-retTest3";

   113 mPar1 = par1;

   114 mPar2 = par2;

   115 mPar3 = par3;

   116 return mRetValue;

   117 }

   118 

   119 void ut_XQServiceProvider::initTestCase()

   120 {

   121     service = new testServiceProvider(this); 

   122 }

   123 

   124 void ut_XQServiceProvider::send_data()

   125 {

   126     QTest::addColumn<QString>("par1");

   127     QTest::addColumn<int>("par2");

   128     QTest::addColumn<QByteArray>("par3");

   129 

   130     QTest::newRow("simple") 

   131         << QString("PARAM1")

   132         << 1000

   133         << QByteArray(32, 'A');

   134 

   135     QTest::newRow("longdata-1024")

   136         << QString("PARAM1")+QString(1024, QChar('X'))

   137         << 1000

   138         << QByteArray(1024, 'A');

   139 

   140     QTest::newRow("longdata-2048")

   141         << QString("PARAM1")+QString(2048, QChar('X'))

   142         << 1000

   143         << QByteArray(2048, 'A');

   144 

   145     QTest::newRow("longdata-4096")

   146         << QString("PARAM1")+QString(4096, QChar('X'))

   147         << 1000

   148         << QByteArray(4096, 'A');

   149     

   150     QTest::newRow("longdata-64K")

   151         << QString("PARAM1")+QString(65535, QChar('X'))

   152         << 1000

   153         << QByteArray(65535, 'A');

   154 }

   155 

   156 void ut_XQServiceProvider::send()

   157 {

   158     QFETCH(QString, par1);

   159     QFETCH(int, par2);

   160     QFETCH(QByteArray, par3);

   161     

   162     QVariant retValue;

   163     bool res;

   164     

   165     QString msg1=QString("test1(QString)");

   166     XQServiceRequest snd1(QLatin1String("com.nokia.services.TestInterface"),msg1);

   167     snd1 << par1;

   168     res = snd1.send(retValue);        

   169     // Check that the correct values were delivered.

   170     QCOMPARE(res, true);        

   171     QCOMPARE(service->mPar1, par1);        

   172     QCOMPARE(service->mMessage, msg1);        

   173     QCOMPARE(service->mRetValue, retValue.toString());        

   174 

   175 

   176     QString msg2=QString("test2(QString,int)");

   177     XQServiceRequest snd2(QLatin1String("com.nokia.services.TestInterface"),msg2);

   178     snd2 << par1;

   179     snd2 << par2;

   180     res = snd2.send(retValue);        

   181     // Check that the correct values were delivered.

   182     QCOMPARE(res, true);        

   183     QCOMPARE(service->mPar1, par1);        

   184     QCOMPARE(service->mPar2, par2);

   185     QCOMPARE(service->mMessage, msg2);        

   186     QCOMPARE(service->mRetValue, retValue.toString());        

   187 

   188     QString msg3=QString("test3(QString,int,QByteArray)");

   189     XQServiceRequest snd3(QLatin1String("com.nokia.services.TestInterface"),msg3);

   190     snd3 << par1;

   191     snd3 << par2;

   192     snd3 << par3;

   193     res = snd3.send(retValue);        

   194     // Check that the correct values were delivered.

   195     QCOMPARE(res, true);        

   196     QCOMPARE(service->mPar1, par1);        

   197     QCOMPARE(service->mPar2, par2);

   198     QCOMPARE(service->mPar3, par3);

   199     QCOMPARE(service->mMessage, msg3);        

   200     QCOMPARE(service->mRetValue, retValue.toString());        

   201 }

   202 

   203 QTEST_MAIN(ut_XQServiceProvider)

   204 

   205 #include "ut_xqserviceprovider.moc"