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 

    23 #include <QtTest/QtTest>

    24 #include <QObject>

    25 #include <QUrl>

    26 #include <QFile>

    27 #include <QVariantList>

    28 

    29 #include <xqaiwrequest.h>

    30 #include <xqsharablefile.h>

    31 

    32 #include "at_xqapplicationmanager.h"

    33 #include "../inc/testdata.h"

    34 

    35 namespace

    36 {

    37     const QString endOfLine("\n");

    38     const QString testString("TestString");

    39     const QString operation("request(QString)");

    40     const QString operation_async("asyncRequest(QString)");

    41     const QString testFileStr(drive + ":\\data\\Others\\test.txt");

    42 

    43     const QUrl testUrl("testto://address");

    44     

    45     const QFile testFile(testFileStr);

    46 }

    47 

    48 

    49 void Test_XQApplicationManager::init()

    50 {

    51     testSharableFile = new XQSharableFile();

    52     QVERIFY2(testSharableFile->open(testFileStr), mLog.join(endOfLine).toAscii());

    53     mAppManager = new XQApplicationManager();

    54     QVERIFY2(mAppManager != NULL, mLog.join(endOfLine).toAscii()); 

    55     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii()); 

    56 }

    57 

    58 void Test_XQApplicationManager::drm_file()

    59 {

    60     mLog << "[QTH] [Test_XQApplicationManager] drm_file";

    61 

    62 #ifdef __WINS__

    63     QSKIP("Checking drm attributes does not work correctly on emulator", SkipAll);

    64 #endif

    65     

    66     QStringList logmem = mLog;

    67     

    68     foreach (QString fileStr, testData.files.keys()) {

    69         QFile file(fileStr);

    70         QVariantList drmValues;

    71         mAppManager->getDrmAttributes(file, listDrmAttr(), drmValues);

    72         

    73         mLog << "[QTH] [Test_XQApplicationManager] drm_file:" + fileStr;

    74         

    75         foreach (QVariant value, testData.files[fileStr].values()) {

    76             if (!value.isValid())

    77                 mLog << "[QTH] [Test_XQApplicationManager] test attribute: not valid";

    78             else if (value.type() == QVariant::Int)

    79                 mLog << "[QTH] [Test_XQApplicationManager] test attribute:" + QString::number(value.toInt());

    80             else if (value.type() == QVariant::String)

    81                 mLog << "[QTH] [Test_XQApplicationManager] test attribute:" + value.toString();

    82         }

    83         

    84         foreach (QVariant value, drmValues) {

    85             if (!value.isValid())

    86                 mLog << "[QTH] [Test_XQApplicationManager] getDrmAttributes: not valid";

    87             else if (value.type() == QVariant::Int)

    88                 mLog << "[QTH] [Test_XQApplicationManager] getDrmAttributes:" + QString::number(value.toInt());

    89             else if (value.type() == QVariant::String)

    90                 mLog << "[QTH] [Test_XQApplicationManager] getDrmAttributes:" + value.toString();

    91         }

    92         

    93         QVERIFY2(testData.files[fileStr].values() == drmValues, mLog.join(endOfLine).toAscii());

    94         mLog = logmem;

    95     }

    96             

    97     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

    98     

    99     mLog << "[QTH] [Test_XQApplicationManager] drm_file end";

   100 }

   101 

   102 void Test_XQApplicationManager::drm_sharablefile()

   103 {

   104     mLog << "[QTH] [Test_XQApplicationManager] drm_sharablefile";

   105     

   106 #ifdef __WINS__

   107     QSKIP("Checking drm attributes does not work correctly on emulator", SkipAll);

   108 #endif

   109     

   110     QStringList logmem = mLog;

   111 

   112     foreach (QString fileStr, testData.files.keys()) {

   113         XQSharableFile sharableFile;

   114         QVariantList drmValues;

   115         

   116         sharableFile.open(fileStr);

   117         mAppManager->getDrmAttributes(sharableFile, listDrmAttr(), drmValues);

   118         sharableFile.close();

   119         

   120         mLog << "[QTH] [Test_XQApplicationManager] drm_sharablefile:" + fileStr;

   121         foreach (QVariant value, testData.files[fileStr].values()) {

   122             if (!value.isValid())

   123                 mLog << "[QTH] [Test_XQApplicationManager] test attribute: not valid";

   124             else if (value.type() == QVariant::Int)

   125                 mLog << "[QTH] [Test_XQApplicationManager] test attribute:" + QString::number(value.toInt());

   126             else if (value.type() == QVariant::String)

   127                 mLog << "[QTH] [Test_XQApplicationManager] test attribute:" + value.toString();

   128         }

   129         

   130         foreach (QVariant value, drmValues) {

   131             if (!value.isValid())

   132                 mLog << "[QTH] [Test_XQApplicationManager] getDrmAttributes: not valid";

   133             else if (value.type() == QVariant::Int)

   134                 mLog << "[QTH] [Test_XQApplicationManager] getDrmAttributes:" + QString::number(value.toInt());

   135             else if (value.type() == QVariant::String)

   136                 mLog << "[QTH] [Test_XQApplicationManager] getDrmAttributes:" + value.toString();

   137         }

   138         

   139         QVERIFY2(testData.files[fileStr].values() == drmValues, mLog.join(endOfLine).toAscii());

   140         mLog = logmem;

   141     }

   142             

   143     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   144     

   145     mLog << "[QTH] [Test_XQApplicationManager] drm_sharablefile end";

   146 }

   147 

   148 void Test_XQApplicationManager::list_interface()

   149 {

   150     mLog << "[QTH] [Test_XQApplicationManager] list_interface";

   151     

   152     foreach (QString interface, testData.interfaces.keys()) {

   153         if (interface == IUriView || interface == IFileView)

   154             continue;

   155     

   156         QList<XQAiwInterfaceDescriptor> list = mAppManager->list(interface, operation);

   157         

   158         mLog << "[QTH] [Test_XQApplicationManager] list_interface interfaces defined:" 

   159                  + QString::number(testData.interfaces.values(interface).count());

   160         mLog << "[QTH] [Test_XQApplicationManager] list_interface system interfaces:" 

   161                  + QString::number(list.count());

   162         QVERIFY2(list.count() == testData.interfaces.values(interface).count(), mLog.join(endOfLine).toAscii());

   163         

   164         foreach (XQAiwInterfaceDescriptor interfaceDesc, list) {

   165             bool equal = false;

   166             foreach (InterfaceData* interfaceData, testData.interfaces.values(interface)) {

   167                 if (interfaceData->compare(interfaceDesc, mLog)) {

   168                     equal = true;

   169                     break;

   170                 }

   171             }

   172             

   173             mLog << "[QTH] [Test_XQApplicationManager] list_interface service name:" + interfaceDesc.serviceName();

   174             mLog << "[QTH] [Test_XQApplicationManager] list_interface interface name:" + interfaceDesc.interfaceName();

   175             mLog << "[QTH] [Test_XQApplicationManager] list_interface interface OK?:" + QString::number((int)equal) << QString::number((int)interfaceDesc.isValid());

   176             

   177             QVERIFY2(equal, mLog.join(endOfLine).toAscii());

   178             QVERIFY2(interfaceDesc.isValid(), mLog.join(endOfLine).toAscii());

   179         }

   180     }

   181     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   182     

   183     mLog << "[QTH] [Test_XQApplicationManager] list_interface end";

   184 }

   185 

   186 void Test_XQApplicationManager::list_service_interface()

   187 {

   188     mLog << "[QTH] [Test_XQApplicationManager] list_service_interface";

   189     

   190     foreach (InterfaceData* interfaceData1, testData.interfaces.values()) {

   191         if (interfaceData1->mInterfaceName == IUriView || interfaceData1->mInterfaceName == IFileView)

   192             continue;

   193         

   194         QList<XQAiwInterfaceDescriptor> list = mAppManager->list(interfaceData1->mServiceName, interfaceData1->mInterfaceName, operation);

   195         

   196         int countInterfaces = 0;

   197         foreach (XQAiwInterfaceDescriptor interfaceDesc, list) {

   198             bool equal = false;

   199             foreach (InterfaceData* interfaceData2, testData.interfaces.values(interfaceData1->mInterfaceName))

   200             {

   201                 if (interfaceData2->compare(interfaceDesc, mLog))

   202                     equal = true;

   203                 if (interfaceData2->mServiceName == interfaceData1->mServiceName)

   204                     countInterfaces++;

   205             }

   206             

   207             mLog << "[QTH] [Test_XQApplicationManager] list_service_interface service name:" + interfaceDesc.serviceName();

   208             mLog << "[QTH] [Test_XQApplicationManager] list_service_interface interface name:" + interfaceDesc.interfaceName();

   209             mLog << "[QTH] [Test_XQApplicationManager] list_service_interface interface OK?:" + QString::number((int)equal)

   210                                                                                               + QString::number((int)interfaceDesc.isValid());

   211             

   212             QVERIFY2(equal, mLog.join(endOfLine).toAscii());

   213             QVERIFY2(interfaceDesc.isValid(), mLog.join(endOfLine).toAscii());

   214         }

   215         

   216         mLog << "[QTH] [Test_XQApplicationManager] list_service_interface interfaces defined:" 

   217                  + QString::number(countInterfaces);

   218         mLog << "[QTH] [Test_XQApplicationManager] list_service_interface system interfaces:" 

   219                  + QString::number(list.count());

   220         QVERIFY2(list.count() == countInterfaces, mLog.join(endOfLine).toAscii());

   221     }

   222     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   223     

   224     mLog << "[QTH] [Test_XQApplicationManager] list_service_interface end";

   225 }

   226 

   227 void Test_XQApplicationManager::list_uri()

   228 {

   229     mLog << "[QTH] [Test_XQApplicationManager] list_uri";

   230     

   231     QList<XQAiwInterfaceDescriptor> list = mAppManager->list(testUrl);

   232     

   233     mLog << "[QTH] [Test_XQApplicationManager] list_uri interfaces defined:" 

   234              + QString::number(testData.interfaces.values(IUriView).count());

   235     mLog << "[QTH] [Test_XQApplicationManager] list_uri system interfaces:" 

   236              + QString::number(list.count());    

   237     QVERIFY2(list.count() == testData.interfaces.values(IUriView).count(), mLog.join(endOfLine).toAscii());

   238     

   239     foreach (XQAiwInterfaceDescriptor interfaceDesc, list) {

   240         bool equal = false;

   241         foreach (InterfaceData* interfaceData, testData.interfaces.values(IUriView))

   242             if (interfaceData->compare(interfaceDesc, mLog))

   243             {

   244                 equal = true;

   245                 break;

   246             }

   247         

   248         mLog << "[QTH] [Test_XQApplicationManager] list_uri service name:" + interfaceDesc.serviceName();

   249         mLog << "[QTH] [Test_XQApplicationManager] list_uri interface name:" + interfaceDesc.interfaceName();

   250         mLog << "[QTH] [Test_XQApplicationManager] list_uri interface OK?:" + QString::number((int)equal) 

   251                                                                             + QString::number((int)interfaceDesc.isValid());

   252                     

   253         QVERIFY2(equal, mLog.join(endOfLine).toAscii());

   254         QVERIFY2(interfaceDesc.isValid(), mLog.join(endOfLine).toAscii());

   255     }

   256     

   257     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   258     

   259     mLog << "[QTH] [Test_XQApplicationManager] list_uri end";

   260 }

   261 

   262 void Test_XQApplicationManager::list_file()

   263 {

   264     mLog << "[QTH] [Test_XQApplicationManager] list_file";

   265     

   266     QSKIP("Currently function list(const QFile& file) returns maximum one interface", SkipAll);

   267     

   268     QList<XQAiwInterfaceDescriptor> list = mAppManager->list(testFile);

   269     

   270     foreach (InterfaceData* interfaceData, testData.interfaces.values(IFileView)) {

   271         bool equal = false;

   272         foreach (XQAiwInterfaceDescriptor interfaceDesc, list)

   273             if (interfaceData->compare(interfaceDesc, mLog)) {

   274                 equal = true;

   275                 break;

   276             }

   277         

   278         mLog << "[QTH] [Test_XQApplicationManager] list_file service name:" + interfaceData->mServiceName;

   279         mLog << "[QTH] [Test_XQApplicationManager] list_file interface name:" + interfaceData->mInterfaceName;

   280         mLog << "[QTH] [Test_XQApplicationManager] list_file interface OK?:" + QString::number((int)equal);

   281         

   282         QVERIFY2(equal, mLog.join(endOfLine).toAscii());

   283     }

   284     

   285     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   286     

   287     mLog << "[QTH] [Test_XQApplicationManager] list_file end";

   288 }

   289 

   290 void Test_XQApplicationManager::list_sharablefile()

   291 {

   292     mLog << "[QTH] [Test_XQApplicationManager] list_sharablefile";

   293 

   294     QSKIP("Currently function list(const XQSharableFile& file) returns maximum one interface", SkipAll);

   295     

   296     QList<XQAiwInterfaceDescriptor> list = mAppManager->list(*testSharableFile);

   297     

   298     foreach (InterfaceData* interfaceData, testData.interfaces.values(IFileView)) {

   299         bool equal = false;

   300         foreach (XQAiwInterfaceDescriptor interfaceDesc, list) {

   301             if (interfaceData->compare(interfaceDesc, mLog)) {

   302                 equal = true;

   303                 break;

   304             }

   305         }

   306         

   307         mLog << "[QTH] [Test_XQApplicationManager] list_sharablefile service name:" + interfaceData->mServiceName;

   308         mLog << "[QTH] [Test_XQApplicationManager] list_sharablefile interface name:" + interfaceData->mInterfaceName;

   309         mLog << "[QTH] [Test_XQApplicationManager] list_sharablefile interface OK?:" + QString::number((int)equal);

   310         

   311         QVERIFY2(equal, mLog.join(endOfLine).toAscii());

   312     }

   313     

   314     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   315     

   316     mLog << "[QTH] [Test_XQApplicationManager] list_sharablefile end";

   317 }

   318 

   319 void Test_XQApplicationManager::create_interface()

   320 {

   321     mLog << "[QTH] [Test_XQApplicationManager] create_interface";

   322     

   323     foreach (QString interface, testData.interfaces.keys()) {

   324         if (interface == IUriView || interface == IFileView)

   325             continue;

   326         

   327         mLog << "[QTH] [Test_XQApplicationManager] create_interface:" + interface;

   328         

   329         {

   330             XQAiwRequest* request = mAppManager->create(interface, operation, true);

   331             testRequest(request, operation, testString, true, true);

   332             delete request;

   333         }

   334         

   335         {

   336             XQAiwRequest* request = mAppManager->create(interface, operation_async, true);

   337             testRequest(request, operation_async, testString, true, false);

   338             delete request;

   339         }

   340         

   341         {

   342             XQAiwRequest* request = mAppManager->create(interface, operation, false);

   343             testRequest(request, operation, testString, false, true);

   344             delete request;

   345         }

   346         

   347         {

   348             XQAiwRequest* request = mAppManager->create(interface, operation_async, false);

   349             testRequest(request, operation_async, testString, false, false);

   350             delete request;

   351         }

   352     }

   353     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   354     

   355     mLog << "[QTH] [Test_XQApplicationManager] create_interface end";

   356 }

   357 

   358 void Test_XQApplicationManager::create_service_interface()

   359 {

   360     mLog << "[QTH] [Test_XQApplicationManager] create_service_interface";

   361 

   362     foreach (InterfaceData* interfaceData, testData.interfaces.values()) {

   363         if (interfaceData->mInterfaceName == IUriView || interfaceData->mInterfaceName == IFileView)

   364            continue;

   365     

   366         mLog << "[QTH] [Test_XQApplicationManager] create_service_interface service:" + interfaceData->mServiceName;

   367         mLog << "[QTH] [Test_XQApplicationManager] create_service_interface interface:" + interfaceData->mInterfaceName;

   368         

   369         {

   370             XQAiwRequest* request = mAppManager->create(interfaceData->mServiceName, interfaceData->mInterfaceName, operation, true);

   371             testRequest(request, operation, testString, true, true);

   372             delete request;

   373         }

   374             

   375         {

   376             XQAiwRequest* request = mAppManager->create(interfaceData->mServiceName, interfaceData->mInterfaceName, operation_async, true);

   377             testRequest(request, operation_async, testString, true, false);

   378             delete request;

   379         }

   380             

   381         {

   382             XQAiwRequest* request = mAppManager->create(interfaceData->mServiceName, interfaceData->mInterfaceName, operation, false);

   383             testRequest(request, operation, testString, false, true);

   384             delete request;

   385         }

   386             

   387         {

   388             XQAiwRequest* request = mAppManager->create(interfaceData->mServiceName, interfaceData->mInterfaceName, operation_async, false);

   389             testRequest(request, operation_async, testString, false, false);

   390             delete request;

   391         }

   392     }

   393     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   394     

   395     mLog << "[QTH] [Test_XQApplicationManager] create_service_interface end";

   396 }

   397 

   398 void Test_XQApplicationManager::create_implementation()

   399 {

   400     mLog << "[QTH] [Test_XQApplicationManager] create_implementation";

   401 

   402     foreach (InterfaceData* interfaceData, testData.interfaces.values()) {

   403         if (interfaceData->mInterfaceName == IUriView || interfaceData->mInterfaceName == IFileView)

   404             continue;

   405         foreach (XQAiwInterfaceDescriptor interfaceDesc, mAppManager->list(interfaceData->mServiceName, interfaceData->mInterfaceName, operation)) {

   406             mLog << "[QTH] [Test_XQApplicationManager] create_implementation service:" + interfaceDesc.interfaceName();

   407             mLog << "[QTH] [Test_XQApplicationManager] create_implementation interface:" + interfaceDesc.serviceName();

   408             mLog << "[QTH] [Test_XQApplicationManager] create_implementation version:" 

   409                      + QString::number(interfaceDesc.majorVersion()) + "." + QString::number(interfaceDesc.minorVersion());

   410             

   411             {

   412                 XQAiwRequest* request = mAppManager->create(interfaceDesc, operation, true);

   413                 testRequest(request, operation, testString, true, true);

   414                 delete request;

   415             }

   416                 

   417             {

   418                 XQAiwRequest* request = mAppManager->create(interfaceDesc, operation_async, true);

   419                 testRequest(request, operation_async, testString, true, false);

   420                 delete request;

   421             }

   422                 

   423             {

   424                 XQAiwRequest* request = mAppManager->create(interfaceDesc, operation, false);

   425                 testRequest(request, operation, testString, false, true);

   426                 delete request;

   427             }

   428                 

   429             {

   430                 XQAiwRequest* request = mAppManager->create(interfaceDesc, operation_async, false);

   431                 testRequest(request, operation_async, testString, false, false);

   432                 delete request;

   433             }

   434         }

   435     }

   436     

   437     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   438     

   439     mLog << "[QTH] [Test_XQApplicationManager] create_implementation end";

   440 }

   441 

   442 void Test_XQApplicationManager::create_uri()

   443 {

   444     mLog << "[QTH] [Test_XQApplicationManager] create_uri";

   445 

   446     {

   447         XQAiwRequest* request = mAppManager->create(testUrl, true);

   448         testRequest(request, QString(), testUrl.toString(), true, true);

   449         delete request;

   450     }

   451         

   452     {

   453         XQAiwRequest* request = mAppManager->create(testUrl, false);

   454         testRequest(request, QString(), testUrl.toString(), false, true);

   455         delete request;

   456     }

   457             

   458     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   459     

   460     mLog << "[QTH] [Test_XQApplicationManager] create_uri end";

   461 }

   462 

   463 void Test_XQApplicationManager::create_uri_implementation()

   464 {

   465     mLog << "[QTH] [Test_XQApplicationManager] create_uri_implementation";

   466 

   467     QList<XQAiwInterfaceDescriptor> list = mAppManager->list(testUrl);

   468     

   469     foreach (XQAiwInterfaceDescriptor interfaceDesc, list)

   470         foreach (InterfaceData* interfaceData, testData.interfaces.values(IUriView))

   471         {

   472             if (interfaceData->compare(interfaceDesc, mLog)) {

   473                 {

   474                     XQAiwRequest* request = mAppManager->create(testUrl, interfaceDesc, true);

   475                     testRequest(request, QString(), testUrl.toString(), true, true);

   476                     delete request;

   477                 }

   478                     

   479                 {

   480                     XQAiwRequest* request = mAppManager->create(testUrl, interfaceDesc, false);

   481                     testRequest(request, QString(), testUrl.toString(), false, true);

   482                     delete request;

   483                 }

   484             }

   485         

   486         mLog << "[QTH] [Test_XQApplicationManager] create_uri_implementation service:" + interfaceDesc.interfaceName();

   487         mLog << "[QTH] [Test_XQApplicationManager] create_uri_implementation interface:" + interfaceDesc.serviceName();

   488         mLog << "[QTH] [Test_XQApplicationManager] create_uri_implementation version:" 

   489                  + QString::number(interfaceDesc.majorVersion()) + "." + QString::number(interfaceDesc.minorVersion());

   490         

   491         QVERIFY2(interfaceDesc.isValid(), mLog.join(endOfLine).toAscii());

   492     }

   493             

   494     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   495     

   496     mLog << "[QTH] [Test_XQApplicationManager] create_uri_implementation end";

   497 }

   498 

   499 void Test_XQApplicationManager::create_file()

   500 {

   501     mLog << "[QTH] [Test_XQApplicationManager] create_file";

   502 

   503     {

   504         XQAiwRequest* request = mAppManager->create(testFile, true);

   505         testRequest(request, QString(), testFileStr, true, true);

   506         delete request;

   507     }

   508         

   509     {

   510         XQAiwRequest* request = mAppManager->create(testFile, false);

   511         testRequest(request, QString(), testFileStr, false, true);

   512         delete request;

   513     }

   514             

   515     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   516     

   517     mLog << "[QTH] [Test_XQApplicationManager] create_file end";

   518 }

   519 

   520 void Test_XQApplicationManager::create_file_implementation()

   521 {

   522     mLog << "[QTH] [Test_XQApplicationManager] create_file_implementation";

   523 

   524     QList<XQAiwInterfaceDescriptor> list = mAppManager->list(testFile);

   525     QVERIFY2(list.count() > 0, mLog.join(endOfLine).toAscii());

   526     

   527     foreach (XQAiwInterfaceDescriptor interfaceDesc, list)

   528         foreach (InterfaceData* interfaceData, testData.interfaces.values(IFileView)) {

   529             if (interfaceData->compare(interfaceDesc, mLog)) {

   530                 {

   531                     XQAiwRequest* request = mAppManager->create(testFile, interfaceDesc, true);

   532                     testRequest(request, QString(), testFileStr, true, true);

   533                     delete request;

   534                 }

   535                     

   536                 {

   537                     XQAiwRequest* request = mAppManager->create(testFile, interfaceDesc, false);

   538                     testRequest(request, QString(), testFileStr, false, true);

   539                     delete request;

   540                 }

   541             }

   542         

   543         mLog << "[QTH] [Test_XQApplicationManager] create_file_implementation service:" + interfaceDesc.interfaceName();

   544         mLog << "[QTH] [Test_XQApplicationManager] create_file_implementation interface:" + interfaceDesc.serviceName();

   545         mLog << "[QTH] [Test_XQApplicationManager] create_file_implementation version:" 

   546                  + QString::number(interfaceDesc.majorVersion()) + "." + QString::number(interfaceDesc.minorVersion());

   547         

   548         QVERIFY2(interfaceDesc.isValid(), mLog.join(endOfLine).toAscii());

   549     }

   550             

   551     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   552     

   553     mLog << "[QTH] [Test_XQApplicationManager] create_file_implementation end";

   554 }

   555 

   556 void Test_XQApplicationManager::create_sharablefile()

   557 {

   558     mLog << "[QTH] [Test_XQApplicationManager] create_sharablefile";

   559     

   560     {

   561         XQAiwRequest* request = mAppManager->create(*testSharableFile, true);

   562         testRequest(request, QString(), QString(), true, true, testSharableFile);

   563         delete request;

   564     }

   565         

   566     {

   567         XQAiwRequest* request = mAppManager->create(*testSharableFile, false);

   568         testRequest(request, QString(), testFileStr, false, true, testSharableFile);

   569         delete request;

   570     }

   571             

   572     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   573     

   574     mLog << "[QTH] [Test_XQApplicationManager] create_sharablefile end";

   575 }

   576 

   577 void Test_XQApplicationManager::create_sharablefile_implementation()

   578 {

   579     mLog << "[QTH] [Test_XQApplicationManager] create_sharablefile_implementation";

   580     

   581     QList<XQAiwInterfaceDescriptor> list = mAppManager->list(*testSharableFile);

   582     QVERIFY2(list.count() > 0, mLog.join(endOfLine).toAscii());

   583     

   584     foreach (XQAiwInterfaceDescriptor interfaceDesc, list) {

   585         foreach (InterfaceData* interfaceData, testData.interfaces.values(IFileView)) {

   586             if (interfaceData->compare(interfaceDesc, mLog)) {

   587                 {

   588                     XQAiwRequest* request = mAppManager->create(*testSharableFile, interfaceDesc, true);

   589                     testRequest(request, QString(), testFileStr, true, true, testSharableFile);

   590                     delete request;

   591                 }

   592                     

   593                 {

   594                     XQAiwRequest* request = mAppManager->create(*testSharableFile, interfaceDesc, false);

   595                     testRequest(request, QString(), testFileStr, false, true, testSharableFile);

   596                     delete request;

   597                 }

   598             }

   599         }

   600         

   601         mLog << "[QTH] [Test_XQApplicationManager] create_sharablefile_implementation service:" + interfaceDesc.interfaceName();

   602         mLog << "[QTH] [Test_XQApplicationManager] create_sharablefile_implementation interface:" + interfaceDesc.serviceName();

   603         mLog << "[QTH] [Test_XQApplicationManager] create_sharablefile_implementation version:" 

   604                  + QString::number(interfaceDesc.majorVersion()) + "." + QString::number(interfaceDesc.minorVersion());

   605         

   606         QVERIFY2(interfaceDesc.isValid(), mLog.join(endOfLine).toAscii());

   607     }

   608             

   609     QVERIFY2(mAppManager->lastError() == XQService::ENoError, mLog.join(endOfLine).toAscii());

   610     

   611     mLog << "[QTH] [Test_XQApplicationManager] create_sharablefile_implementation end";

   612 }

   613 

   614 const QList<int> Test_XQApplicationManager::listDrmAttr()

   615 {

   616     QList<int> attr;

   617     

   618     attr.append(XQApplicationManager::IsProtected);

   619     attr.append(XQApplicationManager::IsForwardable);

   620     attr.append(XQApplicationManager::Description);

   621     attr.append(XQApplicationManager::MimeType);

   622     

   623     return attr;

   624 }

   625 

   626 

   627 void Test_XQApplicationManager::cleanup()

   628 {

   629     delete mAppManager;

   630     mAppManager = NULL;

   631     mLog.clear();

   632     testSharableFile->close();

   633     delete testSharableFile;

   634     testSharableFile = NULL;

   635 }

   636 

   637 void Test_XQApplicationManager::testRequest(XQAiwRequest* request, const QString &operation, 

   638         const QString &arguments, bool embedded, bool synchronous, XQSharableFile *sharablefile)

   639 {

   640     QVERIFY2(request != NULL, mLog.join(endOfLine).toAscii());

   641     

   642     QVERIFY2(request->isEmbedded() == embedded, mLog.join(endOfLine).toAscii());

   643     

   644     request->setSynchronous(synchronous);

   645     QVERIFY2(request->isSynchronous() == synchronous, mLog.join(endOfLine).toAscii());

   646     

   647     if (!operation.isEmpty())

   648         QVERIFY2(request->operation() == operation, mLog.join(endOfLine).toAscii());

   649     

   650     QList<QVariant> args;

   651     if (sharablefile) {

   652         args << qVariantFromValue(*sharablefile);

   653     } else {

   654         args << arguments;

   655     }

   656     

   657     request->setArguments(args);

   658     

   659     connect(request, SIGNAL(requestOk(const QVariant&)), this, SLOT(handleOk(const QVariant&)));

   660     connect(request, SIGNAL(requestError(int,const QString&)), this, SLOT(handleError(int,const QString&)));

   661     

   662     mLog << "[QTH] [Test_XQApplicationManager] send " + operation;

   663     mServiceAnswered = false;

   664     QVERIFY2(request->send(), mLog.join(endOfLine).toAscii());

   665    

   666     if (!operation.isEmpty()) {

   667         while (!mServiceAnswered)

   668             QTest::qWait(20);

   669         

   670         QStringList retList = returnValue.toStringList();

   671         

   672         QVERIFY2(retList.value(0) == request->descriptor().serviceName(), mLog.join(endOfLine).toAscii());

   673         QVERIFY2(retList.value(1) == request->descriptor().interfaceName(), mLog.join(endOfLine).toAscii());

   674         QVERIFY2(retList.value(2) == testString, mLog.join(endOfLine).toAscii());

   675     }

   676     else

   677         QTest::qWait(100);

   678 }

   679 

   680 void Test_XQApplicationManager::handleOk(const QVariant& ret)

   681 {

   682     mLog << "[QTH] [Test_XQApplicationManager] request results:" + ret.toStringList().join(", ");

   683     returnValue = ret;

   684     mServiceAnswered = true;

   685 }

   686 

   687 void Test_XQApplicationManager::handleError(int err ,const QString& errString)

   688 {

   689     mLog << "[QTH] [Test_XQApplicationManager] handleError: " + errString; 

   690     mLog << "[QTH] [Test_XQApplicationManager] err: " + QString::number(err);

   691     mServiceAnswered = true;

   692 }

   693 

   694 int main (int argc, char* argv[]) 

   695 {

   696     QApplication app(argc, argv);

   697     QTEST_DISABLE_KEYPAD_NAVIGATION

   698     Test_XQApplicationManager tc;

   699     int ret = 0;

   700     if (argc == 1) {

   701         int c = 5;

   702         char* v[] = {argv[0], "-o", "c:/at_am.txt", "-maxwarnings", "0"};

   703         ret = QTest::qExec(&tc, c, v);

   704     }

   705     else {

   706         ret = QTest::qExec(&tc, argc, argv);

   707     }

   708     return ret;

   709 }

   710