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 #ifndef TESTDATA_H_

    23 #define TESTDATA_H_

    24 

    25 #include <xqaiwinterfacedescriptor.h>

    26 #include <QString>

    27 #include <QStringList>

    28 #include <QHash>

    29 #include <QMultiHash>

    30 #include <xqappmgr.h>

    31 #include <QDebug>

    32 

    33 const QString IUriView = "com.nokia.symbian.IUriView"; 

    34 const QString IFileView = "com.nokia.symbian.IFileView";

    35 

    36 #ifdef __WINS__

    37     const QString drive = "c";

    38 #else

    39     const QString drive = "z";

    40 #endif

    41 

    42 typedef QHash<int, QVariant> FileDrm; 

    43 

    44 class InterfaceData

    45 {

    46 public:

    47     InterfaceData(QString serviceName, QString interfaceName,int major, int minor):

    48         mServiceName(serviceName), mInterfaceName(interfaceName), mMajor(major), mMinor(minor){}

    49     

    50     void addProperty(XQAiwInterfaceDescriptor::PropertyKey key, QVariant value)

    51     {

    52         mProperties[key] = value;

    53     }

    54     

    55     void addCustomProperty(QString key, QString value)

    56     {

    57         mCustomProperties[key] = value;

    58     }

    59     

    60     bool compare(const XQAiwInterfaceDescriptor& interface, QStringList& log)

    61     {

    62         if(mServiceName != interface.serviceName())

    63         {

    64             return false;

    65         }

    66         

    67         if(mInterfaceName != interface.interfaceName())

    68         {

    69             return false;

    70         }

    71                

    72         if(mMajor != interface.majorVersion())

    73         {

    74             return false;

    75         }

    76                

    77         if(mMinor != interface.minorVersion())

    78         {

    79             return false;

    80         }

    81                

    82         if(mProperties[XQAiwInterfaceDescriptor::Capabilities] != interface.property(XQAiwInterfaceDescriptor::Capabilities))

    83         {

    84             log << "[QTH] [Test_XQApplicationManager] different capabilities";

    85             return false;

    86         }

    87                

    88         if(mProperties[XQAiwInterfaceDescriptor::Location] != interface.property(XQAiwInterfaceDescriptor::Location))

    89         {

    90             log << "[QTH] [Test_XQApplicationManager] different location";

    91             return false;

    92         }

    93                

    94         if(mProperties[XQAiwInterfaceDescriptor::ServiceDescription] != interface.property(XQAiwInterfaceDescriptor::ServiceDescription))

    95         {

    96             log << "[QTH] [Test_XQApplicationManager] different service description";

    97             return false;

    98         }

    99                

   100         if(mProperties[XQAiwInterfaceDescriptor::InterfaceDescription] != interface.property(XQAiwInterfaceDescriptor::InterfaceDescription))

   101         {

   102             log << "[QTH] [Test_XQApplicationManager] different interface description";

   103             return false;

   104         }

   105                

   106         if(mProperties[XQAiwInterfaceDescriptor::ImplementationId] != interface.property(XQAiwInterfaceDescriptor::ImplementationId))

   107         {

   108             log << "[QTH] [Test_XQApplicationManager] different implementation ID";

   109             return false;

   110         }

   111         

   112         QStringList customPropKeys = interface.customPropertyKeys();

   113         foreach(QString key, customPropKeys)

   114         {

   115             if(mCustomProperties[key] != interface.customProperty(key))

   116             {

   117                 log << "[QTH] [Test_XQApplicationManager] different custom property:" 

   118                          << key << " test value:" << mCustomProperties[key] << " system value:" << interface.customProperty(key);

   119                 return false;

   120             }

   121         }

   122         

   123         return true;

   124     }

   125            

   126 public:

   127     QString mServiceName;

   128     QString mInterfaceName;

   129     QHash<XQAiwInterfaceDescriptor::PropertyKey, QVariant> mProperties;

   130     QHash<QString, QString> mCustomProperties;

   131     int mMajor;

   132     int mMinor;

   133 };

   134 

   135 class TestData

   136 {

   137 public:

   138     TestData()

   139     {

   140         // interfaces

   141         {

   142             QString serviceName("com.nokia.services.qthighway.test.service_1");

   143             QString interfaceName("interface_1");

   144             InterfaceData* interface = new InterfaceData(serviceName, interfaceName, 1, 0);

   145             interface->addProperty(XQAiwInterfaceDescriptor::ServiceDescription, QVariant(QString("QtHighway automatic tests server 1")));

   146             interface->addProperty(XQAiwInterfaceDescriptor::InterfaceDescription, QVariant(QString("Interface 1")));

   147             interface->addProperty(XQAiwInterfaceDescriptor::Location, QVariant(QString("No path")));

   148             interface->addProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(int(0xE42DF0E6)));

   149             services.insert(serviceName, interface);

   150             interfaces.insert(interfaceName, interface);

   151         }

   152            

   153         {

   154             QString serviceName("com.nokia.services.qthighway.test.service_1");

   155             QString interfaceName("interface_2");

   156             InterfaceData* interface = new InterfaceData(serviceName, interfaceName, 1, 0);

   157             interface->addProperty(XQAiwInterfaceDescriptor::ServiceDescription, QVariant(QString("QtHighway automatic tests server 1")));

   158             interface->addProperty(XQAiwInterfaceDescriptor::InterfaceDescription, QVariant(QString("Interface 2")));

   159             interface->addProperty(XQAiwInterfaceDescriptor::Location, QVariant(QString("No path")));

   160             interface->addProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(int(0xE42DF0E6)));

   161             services.insert(serviceName, interface);

   162             interfaces.insert(interfaceName, interface);

   163         }

   164         

   165         {

   166             QString serviceName("com.nokia.services.qthighway.test.service_1");

   167             QString interfaceName("interface_3");

   168             InterfaceData* interface = new InterfaceData(serviceName, interfaceName, 1, 0);

   169             interface->addProperty(XQAiwInterfaceDescriptor::ServiceDescription, QVariant(QString("QtHighway automatic tests server 1")));

   170             interface->addProperty(XQAiwInterfaceDescriptor::InterfaceDescription, QVariant(QString("Interface 3")));

   171             interface->addProperty(XQAiwInterfaceDescriptor::Location, QVariant(QString("No path")));

   172             interface->addProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(int(0xE42DF0E6)));

   173             services.insert(serviceName, interface);

   174             interfaces.insert(interfaceName, interface);

   175         }

   176         

   177         {

   178             QString serviceName("com.nokia.services.qthighway.test.service_1");

   179             QString interfaceName(IUriView);

   180             InterfaceData* interface = new InterfaceData(serviceName, interfaceName, 1, 0);

   181             interface->addProperty(XQAiwInterfaceDescriptor::InterfaceDescription, QVariant(QString("Interface for showing URIs")));

   182             interface->addProperty(XQAiwInterfaceDescriptor::ServiceDescription, QVariant(QString("QtHighway automatic tests server 1")));

   183             interface->addProperty(XQAiwInterfaceDescriptor::Location, QVariant(QString("No path")));

   184             interface->addProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(int(0xE42DF0E6)));

   185             interface->addCustomProperty("schemes","qhattestto");

   186             services.insert(serviceName, interface);

   187             interfaces.insert(interfaceName, interface);

   188         }

   189         

   190         {

   191             QString serviceName("com.nokia.services.qthighway.test.service_1");

   192             QString interfaceName(IFileView);

   193             InterfaceData* interface = new InterfaceData(serviceName, interfaceName, 1, 0);

   194             interface->addProperty(XQAiwInterfaceDescriptor::InterfaceDescription, QVariant(QString("Interface for showing Files")));

   195             interface->addProperty(XQAiwInterfaceDescriptor::ServiceDescription, QVariant(QString("QtHighway automatic tests server 1")));

   196             interface->addProperty(XQAiwInterfaceDescriptor::Location, QVariant(QString("No path")));

   197             interface->addProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(int(0xE42DF0E6)));

   198             services.insert(serviceName, interface);

   199             interfaces.insert(interfaceName, interface);

   200         }

   201     

   202         {

   203             QString serviceName("com.nokia.services.qthighway.test.service_2");

   204             QString interfaceName("interface_1");

   205             InterfaceData* interface = new InterfaceData(serviceName, interfaceName, 1, 0);

   206             interface->addProperty(XQAiwInterfaceDescriptor::InterfaceDescription, QVariant(QString("Interface 1")));

   207             interface->addProperty(XQAiwInterfaceDescriptor::ServiceDescription, QVariant(QString("QtHighway automatic tests server 2")));

   208             interface->addProperty(XQAiwInterfaceDescriptor::Location, QVariant(QString("No path")));

   209             interface->addProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(int(0xED698FE0)));

   210             services.insert(serviceName, interface);

   211             interfaces.insert(interfaceName, interface);

   212         }

   213         

   214         {

   215             QString serviceName("com.nokia.services.qthighway.test.service_2");

   216             QString interfaceName("interface_2");

   217             InterfaceData* interface = new InterfaceData(serviceName, interfaceName, 1, 0);

   218             interface->addProperty(XQAiwInterfaceDescriptor::InterfaceDescription, QVariant(QString("Interface 2")));

   219             interface->addProperty(XQAiwInterfaceDescriptor::ServiceDescription, QVariant(QString("QtHighway automatic tests server 2")));

   220             interface->addProperty(XQAiwInterfaceDescriptor::Location, QVariant(QString("No path")));

   221             interface->addProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(int(0xED698FE0)));

   222             services.insert(serviceName, interface);

   223             interfaces.insert(interfaceName, interface);

   224         }

   225         

   226         {

   227             QString serviceName("com.nokia.services.qthighway.test.service_2");

   228             QString interfaceName(IUriView);

   229             InterfaceData* interface = new InterfaceData(serviceName, interfaceName, 1, 0);

   230             interface->addProperty(XQAiwInterfaceDescriptor::InterfaceDescription, QVariant(QString("Interface for showing URIs")));

   231             interface->addProperty(XQAiwInterfaceDescriptor::ServiceDescription, QVariant(QString("QtHighway automatic tests server 2")));

   232             interface->addProperty(XQAiwInterfaceDescriptor::Location, QVariant(QString("No path")));

   233             interface->addProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(int(0xED698FE0)));

   234             interface->addCustomProperty("schemes","qhattestto");

   235             services.insert(serviceName, interface);

   236             interfaces.insert(interfaceName, interface);

   237         }

   238         

   239         {

   240             QString serviceName("com.nokia.services.qthighway.test.service_2");

   241             QString interfaceName(IFileView);

   242             InterfaceData* interface = new InterfaceData(serviceName, interfaceName, 1, 0);

   243             interface->addProperty(XQAiwInterfaceDescriptor::InterfaceDescription, QVariant(QString("Interface for showing Files")));

   244             interface->addProperty(XQAiwInterfaceDescriptor::ServiceDescription, QVariant(QString("QtHighway automatic tests server 2")));

   245             interface->addProperty(XQAiwInterfaceDescriptor::Location, QVariant(QString("No path")));

   246             interface->addProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(int(0xED698FE0)));

   247             services.insert(serviceName, interface);

   248             interfaces.insert(interfaceName, interface);

   249         }

   250         

   251         // DRM files

   252         

   253         {

   254             FileDrm drm;

   255             drm[XQApplicationManager::IsProtected] = QVariant(0);

   256             drm[XQApplicationManager::IsForwardable] = QVariant(1);

   257             drm[XQApplicationManager::Description] = QVariant();

   258             drm[XQApplicationManager::MimeType] = QVariant(QString("text/plain"));

   259             

   260             files[QString(drive + ":\\data\\Others\\test.txt")] = drm;

   261             

   262         }

   263         

   264         {

   265             FileDrm drm;

   266             drm[XQApplicationManager::IsProtected] = QVariant(1);

   267             drm[XQApplicationManager::IsForwardable] = QVariant(1);

   268             drm[XQApplicationManager::Description] = QVariant();

   269             drm[XQApplicationManager::MimeType] = QVariant(QString("audio/aac"));

   270             

   271             files[QString(drive + ":\\data\\Others\\111-test1.odf")] = drm;

   272         }

   273         

   274         {

   275             FileDrm drm;

   276             drm[XQApplicationManager::IsProtected] = QVariant(0);

   277             drm[XQApplicationManager::IsForwardable] = QVariant(1);

   278             drm[XQApplicationManager::Description] = QVariant();

   279             drm[XQApplicationManager::MimeType] = QVariant(QString("image/jpeg"));

   280             

   281             files[QString(drive + ":\\data\\Others\\one.jpg")] = drm;

   282         }

   283         

   284         {

   285             FileDrm drm;

   286             drm[XQApplicationManager::IsProtected] = QVariant(0);

   287             drm[XQApplicationManager::IsForwardable] = QVariant(1);

   288             drm[XQApplicationManager::Description] = QVariant();

   289             drm[XQApplicationManager::MimeType] = QVariant(QString("application/vnd.oma.drm.roap-trigger+xml"));

   290             

   291             files[QString(drive + ":\\data\\Others\\RoAcqoffer-111-aac-i15m.ort")] = drm;

   292         }

   293         

   294         {

   295             FileDrm drm;

   296             drm[XQApplicationManager::IsProtected] = QVariant(1);

   297             drm[XQApplicationManager::IsForwardable] = QVariant(1);

   298             drm[XQApplicationManager::Description] = QVariant();

   299             drm[XQApplicationManager::MimeType] = QVariant(QString("audio/sp-midi"));

   300             

   301             files[QString(drive + ":\\data\\Others\\SD_Celebration_SP.dcf")] = drm;

   302         }

   303         

   304         {

   305             FileDrm drm;

   306             drm[XQApplicationManager::IsProtected] = QVariant(1);

   307             drm[XQApplicationManager::IsForwardable] = QVariant(1);

   308             drm[XQApplicationManager::Description] = QVariant();

   309             drm[XQApplicationManager::MimeType] = QVariant(QString("image/jpeg"));

   310             

   311             files[QString(drive + ":\\data\\Others\\SD_jpg_sun.dcf")] = drm;

   312         }

   313         

   314         {

   315             FileDrm drm;

   316             drm[XQApplicationManager::IsProtected] = QVariant(1);

   317             drm[XQApplicationManager::IsForwardable] = QVariant(1);

   318             drm[XQApplicationManager::Description] = QVariant(QString(""));

   319             drm[XQApplicationManager::MimeType] = QVariant(QString("audio/x-ms-wma"));

   320             

   321             files[QString(drive + ":\\data\\Others\\STC1_128_44_16_2_CBR.wma")] = drm;

   322         }

   323             

   324 

   325     }

   326     

   327     ~TestData()

   328     {

   329         foreach(InterfaceData* interface , interfaces.values())

   330             delete interface;

   331     }

   332     

   333 public:

   334     QMultiHash<QString, InterfaceData*> services;

   335     QMultiHash<QString, InterfaceData*> interfaces;

   336     QHash<QString, FileDrm> files;

   337 };

   338 

   339 TestData testData;

   340 

   341 #endif /* TESTDATA_H_ */