1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include <QtTest/QtTest>

    42 #include <QtCore>

    43 #include <qservicefilter.h>

    44 

    45 QTM_USE_NAMESPACE

    46 class tst_QServiceFilter: public QObject

    47 {

    48     Q_OBJECT

    49     

    50 private slots:

    51     void initTestCase();

    52     void cleanupTestCase();

    53     void versionMatching();

    54     void versionMatching_data();

    55     void setInterface();

    56     void testAssignmentOperator();

    57     void testConstructor();

    58 #ifndef QT_NO_DATASTREAM

    59     void streamTest();

    60 #endif 

    61     void testCustomAttribute();

    62     void testCapabilities();

    63     

    64 };

    65 

    66 void tst_QServiceFilter::initTestCase()

    67 {

    68 }

    69 

    70 void tst_QServiceFilter::versionMatching_data()

    71 {

    72     QTest::addColumn<QString>("version");

    73     QTest::addColumn<int>("majorV");

    74     QTest::addColumn<int>("minorV");

    75     QTest::addColumn<int>("rule");

    76 

    77     //invalid cases

    78     QTest::newRow("versionMatching_data():Invalid 1") << "" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    79     QTest::newRow("versionMatching_data():Invalid 3") << "01.3" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    80     QTest::newRow("versionMatching_data():Invalid 4") << "1.03" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    81     QTest::newRow("versionMatching_data():Invalid 5") << "x.y" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    82     QTest::newRow("versionMatching_data():Invalid 6") << "23" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    83     QTest::newRow("versionMatching_data():Invalid 7") << "sdfsfs" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    84     QTest::newRow("versionMatching_data():Invalid 8") << "%#5346" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    85     QTest::newRow("versionMatching_data():Invalid 9") << ".66" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    86     QTest::newRow("versionMatching_data():Invalid 10") << "1.3.4" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    87     QTest::newRow("versionMatching_data():Invalid 11") << "1.a" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    88     QTest::newRow("versionMatching_data():Invalid 12") << "b.1" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    89     QTest::newRow("versionMatching_data():Invalid 13") << "3." << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    90     QTest::newRow("versionMatching_data():Invalid 14") << "-1" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    91     QTest::newRow("versionMatching_data():Invalid 16") << ".x" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    92     QTest::newRow("versionMatching_data():Invalid 17") << "x." << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    93     QTest::newRow("versionMatching_data():Invalid 18") << "1.  0" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    94     QTest::newRow("versionMatching_data():Invalid 19") << "1  .0" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    95     QTest::newRow("versionMatching_data():Invalid 20") << "1  0" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    96     QTest::newRow("versionMatching_data():Invalid 21") << "1 . 0" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    97     QTest::newRow("versionMatching_data():Invalid 22") << " 1.5" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    98     QTest::newRow("versionMatching_data():Invalid 23") << "1.5 " << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

    99     QTest::newRow("versionMatching_data():Invalid 24") << " 1.5 " << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

   100     QTest::newRow("versionMatching_data():Invalid 25") << "1.5 1.6" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

   101     QTest::newRow("versionMatching_data():Invalid 26") << "-1.0" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

   102     QTest::newRow("versionMatching_data():Invalid 27") << "1.-1" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

   103     QTest::newRow("versionMatching_data():Invalid 28") << "-5.-1" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

   104     QTest::newRow("versionMatching_data():Invalid 29") << "4,8" << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

   105     QTest::newRow("versionMatching_data():Invalid 30") << "   " << -1 << -1 << (int)QServiceFilter::MinimumVersionMatch;

   106 

   107    

   108     //valid cases 

   109     QTest::newRow("versionMatching_data():ValidMin 1") << "1.0" << 1 << 0 << (int)QServiceFilter::MinimumVersionMatch;

   110     QTest::newRow("versionMatching_data():ValidMin 2") << "1.00" << 1 << 0 << (int)QServiceFilter::MinimumVersionMatch;

   111     QTest::newRow("versionMatching_data():ValidMin 3") << "99.99" << 99 << 99 << (int)QServiceFilter::MinimumVersionMatch;

   112     QTest::newRow("versionMatching_data():ValidMin 4") << "2.3" << 2 << 3 << (int)QServiceFilter::MinimumVersionMatch;

   113     QTest::newRow("versionMatching_data():ValidMin 5") << "10.3" << 10 << 3 << (int)QServiceFilter::MinimumVersionMatch;

   114     QTest::newRow("versionMatching_data():ValidMin 6") << "5.10" << 5 << 10 << (int)QServiceFilter::MinimumVersionMatch;

   115     QTest::newRow("versionMatching_data():ValidMin 7") << "10.10" << 10 << 10 << (int)QServiceFilter::MinimumVersionMatch;

   116 

   117     QTest::newRow("versionMatching_data():ValidMin 8") << "0.3" << 0 << 3 << (int)QServiceFilter::MinimumVersionMatch;

   118     QTest::newRow("versionMatching_data():ValidMin 10") << "0.0" << 0 << 0 << (int)QServiceFilter::MinimumVersionMatch;

   119     QTest::newRow("versionMatching_data():ValidMin 11") << "00.00" << 0 << 0 << (int)QServiceFilter::MinimumVersionMatch;

   120 

   121     QTest::newRow("versionMatching_data():ValidExact 1") << "1.0" << 1 << 0 << (int)QServiceFilter::ExactVersionMatch;

   122     QTest::newRow("versionMatching_data():ValidExact 2") << "1.00" << 1 << 0 << (int)QServiceFilter::ExactVersionMatch;

   123     QTest::newRow("versionMatching_data():ValidExact 3") << "99.99" << 99 << 99 << (int)QServiceFilter::ExactVersionMatch;

   124     QTest::newRow("versionMatching_data():ValidExact 4") << "2.3" << 2 << 3 << (int)QServiceFilter::ExactVersionMatch;

   125     QTest::newRow("versionMatching_data():ValidExact 5") << "10.3" << 10 << 3 << (int)QServiceFilter::ExactVersionMatch;

   126     QTest::newRow("versionMatching_data():ValidExact 6") << "5.10" << 5 << 10 << (int)QServiceFilter::ExactVersionMatch;

   127     QTest::newRow("versionMatching_data():ValidExact 7") << "10.10" << 10 << 10 << (int)QServiceFilter::ExactVersionMatch;

   128 

   129     QTest::newRow("versionMatching_data():ValidExact 8") << "0.3" << 0 << 3 << (int)QServiceFilter::ExactVersionMatch;

   130     QTest::newRow("versionMatching_data():ValidExact 10") << "0.0" << 0 << 0 << (int)QServiceFilter::ExactVersionMatch;

   131     QTest::newRow("versionMatching_data():ValidExact 11") << "00.00" << 0 << 0 << (int)QServiceFilter::ExactVersionMatch;

   132 }

   133 

   134 void tst_QServiceFilter::versionMatching()

   135 {

   136     QFETCH(QString, version);

   137     QFETCH(int, majorV);

   138     QFETCH(int, minorV);

   139     QFETCH(int, rule);

   140 

   141     QServiceFilter filter;

   142     QCOMPARE(filter.majorVersion(), -1);

   143     QCOMPARE(filter.minorVersion(), -1);

   144     QCOMPARE(filter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   145 

   146     filter.setInterface("com.nokia.qt.test",version, (QServiceFilter::VersionMatchRule)rule);

   147     QCOMPARE(filter.majorVersion(), majorV);

   148     QCOMPARE(filter.minorVersion(), minorV);

   149     QCOMPARE(filter.versionMatchRule(), (QServiceFilter::VersionMatchRule)rule);

   150 }

   151 

   152 

   153 void tst_QServiceFilter::setInterface()

   154 {

   155     //don't separate this out into test_data() function as we test the behavior

   156     //on the same filter object

   157     QServiceFilter filter;

   158     QCOMPARE(filter.majorVersion(), -1);

   159     QCOMPARE(filter.minorVersion(), -1);

   160     QCOMPARE(filter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   161     QCOMPARE(filter.serviceName(), QString());

   162     QCOMPARE(filter.interfaceName(), QString());

   163 

   164     filter.setInterface("com.nokia.qt.text", "1.0", QServiceFilter::ExactVersionMatch);

   165 

   166     QCOMPARE(filter.majorVersion(), 1);

   167     QCOMPARE(filter.minorVersion(), 0);

   168     QCOMPARE(filter.versionMatchRule(), QServiceFilter::ExactVersionMatch);

   169     QCOMPARE(filter.serviceName(), QString());

   170     QCOMPARE(filter.interfaceName(), QString("com.nokia.qt.text"));

   171 

   172     filter.setInterface("com.nokia.qt.text", "1.5", QServiceFilter::MinimumVersionMatch);

   173 

   174     QCOMPARE(filter.majorVersion(), 1);

   175     QCOMPARE(filter.minorVersion(), 5);

   176     QCOMPARE(filter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   177     QCOMPARE(filter.serviceName(), QString());

   178     QCOMPARE(filter.interfaceName(), QString("com.nokia.qt.text"));

   179 

   180     //invalid version tag -> ignore the call

   181     filter.setInterface("com.nokia.qt.label", "f.0", QServiceFilter::ExactVersionMatch);

   182 

   183     QCOMPARE(filter.majorVersion(), 1);

   184     QCOMPARE(filter.minorVersion(), 5);

   185     QCOMPARE(filter.versionMatchRule(), QServiceFilter::MinimumVersionMatch); //default

   186     QCOMPARE(filter.serviceName(), QString());

   187     QCOMPARE(filter.interfaceName(), QString("com.nokia.qt.text"));

   188 

   189     //empty version tag -> reset version

   190     filter.setInterface("com.nokia.qt.label", "", QServiceFilter::ExactVersionMatch);

   191 

   192     QCOMPARE(filter.majorVersion(), -1);

   193     QCOMPARE(filter.minorVersion(), -1);

   194     QCOMPARE(filter.versionMatchRule(), QServiceFilter::ExactVersionMatch); //default

   195     QCOMPARE(filter.serviceName(), QString());

   196     QCOMPARE(filter.interfaceName(), QString("com.nokia.qt.label"));

   197 

   198     //empty.interfaceName() tag -> ignore the call

   199     filter.setInterface("", "4.5", QServiceFilter::MinimumVersionMatch);

   200 

   201     QCOMPARE(filter.majorVersion(), -1);

   202     QCOMPARE(filter.minorVersion(), -1);

   203     QCOMPARE(filter.versionMatchRule(), QServiceFilter::ExactVersionMatch); //default

   204     QCOMPARE(filter.serviceName(), QString());

   205     QCOMPARE(filter.interfaceName(), QString("com.nokia.qt.label"));

   206     

   207     //set a valid 

   208     filter.setInterface("com.nokia.qt.valid", "4.77", QServiceFilter::ExactVersionMatch);

   209 

   210     QCOMPARE(filter.majorVersion(), 4);

   211     QCOMPARE(filter.minorVersion(), 77);

   212     QCOMPARE(filter.versionMatchRule(), QServiceFilter::ExactVersionMatch);

   213     QCOMPARE(filter.serviceName(), QString());

   214     QCOMPARE(filter.interfaceName(), QString("com.nokia.qt.valid"));

   215 

   216     filter.setServiceName("myService");

   217     QCOMPARE(filter.majorVersion(), 4);

   218     QCOMPARE(filter.minorVersion(), 77);

   219     QCOMPARE(filter.versionMatchRule(), QServiceFilter::ExactVersionMatch);

   220     QCOMPARE(filter.serviceName(), QString("myService"));

   221     QCOMPARE(filter.interfaceName(), QString("com.nokia.qt.valid"));

   222 

   223     //test default constructed version and matching rule

   224     filter.setInterface("com.nokia.qt.valid2");

   225     QCOMPARE(filter.majorVersion(), -1);

   226     QCOMPARE(filter.minorVersion(), -1);

   227     QCOMPARE(filter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   228     QCOMPARE(filter.serviceName(), QString("myService"));

   229     QCOMPARE(filter.interfaceName(), QString("com.nokia.qt.valid2"));

   230 }

   231 

   232 void tst_QServiceFilter::testAssignmentOperator()

   233 {

   234     QServiceFilter emptyFilter;

   235     QServiceFilter tempFilter(emptyFilter);

   236    

   237     //assign empty filter to empty filter 

   238     QCOMPARE(emptyFilter.majorVersion(), -1);

   239     QCOMPARE(emptyFilter.minorVersion(), -1);

   240     QCOMPARE(emptyFilter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   241     QCOMPARE(emptyFilter.serviceName(), QString(""));

   242     QCOMPARE(emptyFilter.interfaceName(), QString(""));

   243     QCOMPARE(emptyFilter.customAttribute("key1"), QString());

   244     QCOMPARE(emptyFilter.capabilities(), QStringList());

   245     QCOMPARE(emptyFilter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   246 

   247     QCOMPARE(tempFilter.majorVersion(), -1);

   248     QCOMPARE(tempFilter.minorVersion(), -1);

   249     QCOMPARE(tempFilter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   250     QCOMPARE(tempFilter.serviceName(), QString(""));

   251     QCOMPARE(tempFilter.interfaceName(), QString(""));

   252     QCOMPARE(tempFilter.customAttribute("key1"), QString());

   253     QCOMPARE(tempFilter.capabilities(), QStringList());

   254     QCOMPARE(tempFilter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   255 

   256     tempFilter = emptyFilter;

   257     

   258     QCOMPARE(tempFilter.majorVersion(), -1);

   259     QCOMPARE(tempFilter.minorVersion(), -1);

   260     QCOMPARE(tempFilter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   261     QCOMPARE(tempFilter.serviceName(), QString(""));

   262     QCOMPARE(tempFilter.interfaceName(), QString(""));

   263     QCOMPARE(tempFilter.customAttribute("key1"), QString());

   264     QCOMPARE(tempFilter.capabilities(), QStringList());

   265     QCOMPARE(tempFilter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   266    

   267     //assign filter to new filter via constructor

   268     tempFilter.setInterface("com.nokia.qt.valid", "4.77", QServiceFilter::ExactVersionMatch);

   269     tempFilter.setServiceName("ServiceName");

   270     tempFilter.setCustomAttribute("key1", "value1");

   271     tempFilter.setCapabilities(QServiceFilter::MatchLoadable, QStringList() << "read" << "write");

   272     QCOMPARE(tempFilter.majorVersion(), 4);

   273     QCOMPARE(tempFilter.minorVersion(), 77);

   274     QCOMPARE(tempFilter.versionMatchRule(), QServiceFilter::ExactVersionMatch);

   275     QCOMPARE(tempFilter.serviceName(), QString("ServiceName"));

   276     QCOMPARE(tempFilter.interfaceName(), QString("com.nokia.qt.valid"));

   277     QCOMPARE(tempFilter.customAttribute("key1"), QString("value1"));

   278     QCOMPARE(tempFilter.capabilities(), (QStringList() << "read" << "write"));

   279     QCOMPARE(tempFilter.capabilityMatchRule(), QServiceFilter::MatchLoadable);

   280 

   281     QServiceFilter constructFilter(tempFilter);

   282     QCOMPARE(constructFilter.majorVersion(), 4);

   283     QCOMPARE(constructFilter.minorVersion(), 77);

   284     QCOMPARE(constructFilter.versionMatchRule(), QServiceFilter::ExactVersionMatch);

   285     QCOMPARE(constructFilter.serviceName(), QString("ServiceName"));

   286     QCOMPARE(constructFilter.interfaceName(), QString("com.nokia.qt.valid"));

   287     QCOMPARE(constructFilter.customAttribute("key1"), QString("value1"));

   288     QCOMPARE(constructFilter.capabilities(), (QStringList() << "read" << "write"));

   289     QCOMPARE(constructFilter.capabilityMatchRule(), QServiceFilter::MatchLoadable);

   290 

   291     //ensure that we don't have any potential references between tempFilter and 

   292     //constructedFilter

   293     tempFilter.setServiceName("NewServiceName");

   294     tempFilter.setInterface("com.nokia.qt.valid2", "5.88", QServiceFilter::MinimumVersionMatch);

   295     tempFilter.setCustomAttribute("key2", "value2");

   296     tempFilter.setCapabilities(QServiceFilter::MatchMinimum,QStringList() << "execute");

   297     QCOMPARE(tempFilter.majorVersion(), 5);

   298     QCOMPARE(tempFilter.minorVersion(), 88);

   299     QCOMPARE(tempFilter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   300     QCOMPARE(tempFilter.serviceName(), QString("NewServiceName"));

   301     QCOMPARE(tempFilter.interfaceName(), QString("com.nokia.qt.valid2"));

   302     QCOMPARE(tempFilter.customAttribute("key1"), QString("value1"));

   303     QCOMPARE(tempFilter.customAttribute("key2"), QString("value2"));

   304     QCOMPARE(tempFilter.capabilities(), (QStringList() << "execute"));

   305     QCOMPARE(tempFilter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   306     QCOMPARE(constructFilter.majorVersion(), 4);

   307     QCOMPARE(constructFilter.minorVersion(), 77);

   308     QCOMPARE(constructFilter.versionMatchRule(), QServiceFilter::ExactVersionMatch);

   309     QCOMPARE(constructFilter.serviceName(), QString("ServiceName"));

   310     QCOMPARE(constructFilter.interfaceName(), QString("com.nokia.qt.valid"));

   311     QCOMPARE(constructFilter.customAttribute("key1"), QString("value1"));

   312     QCOMPARE(constructFilter.customAttribute("key2"), QString());

   313     QCOMPARE(constructFilter.capabilities(), (QStringList() << "read" << "write"));

   314     QCOMPARE(constructFilter.capabilityMatchRule(), QServiceFilter::MatchLoadable);

   315 

   316     //assign empty filter to filter with values

   317     constructFilter = emptyFilter;

   318     QCOMPARE(constructFilter.majorVersion(), -1);

   319     QCOMPARE(constructFilter.minorVersion(), -1);

   320     QCOMPARE(constructFilter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   321     QCOMPARE(constructFilter.serviceName(), QString(""));

   322     QCOMPARE(constructFilter.interfaceName(), QString(""));

   323     QCOMPARE(constructFilter.customAttribute("key1"), QString());

   324     QCOMPARE(constructFilter.customAttribute("key2"), QString());

   325     QCOMPARE(constructFilter.capabilities(), QStringList());

   326     QCOMPARE(constructFilter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   327 }

   328 

   329 void tst_QServiceFilter::testConstructor()

   330 {

   331     QServiceFilter tempFilter1("");

   332     QCOMPARE(tempFilter1.majorVersion(), -1);

   333     QCOMPARE(tempFilter1.minorVersion(), -1);

   334     QCOMPARE(tempFilter1.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   335     QCOMPARE(tempFilter1.serviceName(), QString());

   336     QCOMPARE(tempFilter1.interfaceName(), QString(""));

   337     QCOMPARE(tempFilter1.customAttribute("key1"), QString());

   338 

   339     QServiceFilter tempFilter2("com.nokia.qt.test");

   340     QCOMPARE(tempFilter2.majorVersion(), -1);

   341     QCOMPARE(tempFilter2.minorVersion(), -1);

   342     QCOMPARE(tempFilter2.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   343     QCOMPARE(tempFilter2.serviceName(), QString());

   344     QCOMPARE(tempFilter2.interfaceName(), QString("com.nokia.qt.test"));

   345     QCOMPARE(tempFilter2.customAttribute("key1"), QString());

   346 

   347     QServiceFilter tempFilter3("com.nokia.qt.test", "10.5");

   348     QCOMPARE(tempFilter3.majorVersion(), 10);

   349     QCOMPARE(tempFilter3.minorVersion(), 5);

   350     QCOMPARE(tempFilter3.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   351     QCOMPARE(tempFilter3.serviceName(), QString());

   352     QCOMPARE(tempFilter3.interfaceName(), QString("com.nokia.qt.test"));

   353     QCOMPARE(tempFilter3.customAttribute("key1"), QString());

   354 

   355     QServiceFilter tempFilter4("com.nokia.qt.test", "11.7", QServiceFilter::ExactVersionMatch);

   356     QCOMPARE(tempFilter4.majorVersion(), 11);

   357     QCOMPARE(tempFilter4.minorVersion(), 7);

   358     QCOMPARE(tempFilter4.versionMatchRule(), QServiceFilter::ExactVersionMatch);

   359     QCOMPARE(tempFilter4.serviceName(), QString());

   360     QCOMPARE(tempFilter4.interfaceName(), QString("com.nokia.qt.test"));

   361     QCOMPARE(tempFilter4.customAttribute("key1"), QString());

   362     

   363 }

   364 

   365 #ifndef QT_NO_DATASTREAM

   366 void tst_QServiceFilter::streamTest()

   367 {

   368     QByteArray byteArray;

   369     QBuffer buffer(&byteArray);

   370     buffer.open(QIODevice::ReadWrite);

   371     QDataStream stream(&buffer);

   372 

   373     QServiceFilter emptyFilter;

   374     QCOMPARE(emptyFilter.majorVersion(), -1);

   375     QCOMPARE(emptyFilter.minorVersion(), -1);

   376     QCOMPARE(emptyFilter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   377     QCOMPARE(emptyFilter.serviceName(), QString(""));

   378     QCOMPARE(emptyFilter.interfaceName(), QString(""));

   379     QCOMPARE(emptyFilter.customAttribute("key1"), QString());

   380     QCOMPARE(emptyFilter.capabilities(), QStringList());

   381     QCOMPARE(emptyFilter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   382 

   383     buffer.seek(0);

   384     stream << emptyFilter;

   385     

   386     QServiceFilter tempFilter;

   387     QCOMPARE(tempFilter.majorVersion(), -1);

   388     QCOMPARE(tempFilter.minorVersion(), -1);

   389     QCOMPARE(tempFilter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   390     QCOMPARE(tempFilter.serviceName(), QString(""));

   391     QCOMPARE(tempFilter.interfaceName(), QString(""));

   392     QCOMPARE(tempFilter.customAttribute("key1"), QString());

   393     QCOMPARE(tempFilter.capabilities(), QStringList());

   394     QCOMPARE(tempFilter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   395 

   396     buffer.seek(0);

   397     stream >> tempFilter;

   398     

   399     QCOMPARE(tempFilter.majorVersion(), -1);

   400     QCOMPARE(tempFilter.minorVersion(), -1);

   401     QCOMPARE(tempFilter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   402     QCOMPARE(tempFilter.serviceName(), QString(""));

   403     QCOMPARE(tempFilter.interfaceName(), QString(""));

   404     QCOMPARE(tempFilter.customAttribute("key1"), QString());

   405     QCOMPARE(tempFilter.capabilities(), QStringList());

   406     QCOMPARE(tempFilter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   407    

   408     //assign filter to new filter via constructor

   409     tempFilter.setInterface("com.nokia.qt.valid", "4.77", QServiceFilter::ExactVersionMatch);

   410     tempFilter.setServiceName("ServiceName");

   411     tempFilter.setCustomAttribute("key1", "value1");

   412     tempFilter.setCapabilities(QServiceFilter::MatchLoadable, QStringList() << "execute" << "delete");

   413     QCOMPARE(tempFilter.majorVersion(), 4);

   414     QCOMPARE(tempFilter.minorVersion(), 77);

   415     QCOMPARE(tempFilter.versionMatchRule(), QServiceFilter::ExactVersionMatch);

   416     QCOMPARE(tempFilter.serviceName(), QString("ServiceName"));

   417     QCOMPARE(tempFilter.interfaceName(), QString("com.nokia.qt.valid"));

   418     QCOMPARE(tempFilter.customAttribute("key1"), QString("value1"));

   419     QCOMPARE(tempFilter.capabilities(), (QStringList()<<"execute" << "delete"));

   420     QCOMPARE(tempFilter.capabilityMatchRule(), QServiceFilter::MatchLoadable);

   421     buffer.seek(0);

   422     stream << tempFilter;

   423 

   424     QServiceFilter constructFilter;

   425     buffer.seek(0);

   426     stream >> constructFilter;

   427     QCOMPARE(constructFilter.majorVersion(), 4);

   428     QCOMPARE(constructFilter.minorVersion(), 77);

   429     QCOMPARE(constructFilter.versionMatchRule(), QServiceFilter::ExactVersionMatch);

   430     QCOMPARE(constructFilter.serviceName(), QString("ServiceName"));

   431     QCOMPARE(constructFilter.interfaceName(), QString("com.nokia.qt.valid"));

   432     QCOMPARE(constructFilter.customAttribute("key1"), QString("value1"));

   433     QCOMPARE(constructFilter.capabilities(), (QStringList()<<"execute" << "delete"));

   434     QCOMPARE(constructFilter.capabilityMatchRule(), QServiceFilter::MatchLoadable);

   435 

   436     //assign empty filter to filter with values

   437 

   438     buffer.seek(0);

   439     stream << emptyFilter;

   440     buffer.seek(0);

   441     stream >> constructFilter;

   442     QCOMPARE(constructFilter.majorVersion(), -1);

   443     QCOMPARE(constructFilter.minorVersion(), -1);

   444     QCOMPARE(constructFilter.versionMatchRule(), QServiceFilter::MinimumVersionMatch);

   445     QCOMPARE(constructFilter.serviceName(), QString(""));

   446     QCOMPARE(constructFilter.interfaceName(), QString(""));

   447     QCOMPARE(constructFilter.customAttribute("key1"), QString());

   448     QCOMPARE(constructFilter.capabilities(), QStringList());

   449     QCOMPARE(constructFilter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   450 }

   451 #endif 

   452 

   453 void tst_QServiceFilter::testCustomAttribute()

   454 {

   455     //default constructor

   456     QServiceFilter emptyFilter;

   457     QCOMPARE(emptyFilter.customAttribute("key1"), QString());

   458 

   459     QServiceFilter filter("com.nokia.qt.testinterface", "4.5");

   460     QCOMPARE(filter.customAttribute("key1"), QString());

   461     filter.setCustomAttribute("key1", "newValue");

   462     QCOMPARE(filter.customAttribute("key1"), QString("newValue"));

   463     filter.setCustomAttribute("key1", "revisedValue");

   464     QCOMPARE(filter.customAttribute("key1"), QString("revisedValue"));

   465     filter.setCustomAttribute("key2", "Value");

   466     QCOMPARE(filter.customAttribute("key1"), QString("revisedValue"));

   467     QCOMPARE(filter.customAttribute("key2"), QString("Value"));

   468     filter.setCustomAttribute("key1", QString());

   469     QCOMPARE(filter.customAttribute("key1"), QString());

   470     QCOMPARE(filter.customAttribute("key2"), QString("Value"));

   471 }

   472 

   473 void tst_QServiceFilter::testCapabilities()

   474 {

   475     QServiceFilter filter;

   476     QCOMPARE(filter.capabilities(), QStringList());

   477     QCOMPARE(filter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   478     

   479     filter.setCapabilities(QServiceFilter::MatchMinimum, QStringList() << "execute");

   480     QCOMPARE(filter.capabilities(), (QStringList() << "execute"));

   481     QCOMPARE(filter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   482     

   483     filter.setCapabilities(QServiceFilter::MatchMinimum, QStringList() << "execute" << "read");

   484     QCOMPARE(filter.capabilities(), (QStringList() << "execute" << "read"));

   485     QCOMPARE(filter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   486     

   487     filter.setCapabilities(QServiceFilter::MatchMinimum);

   488     QCOMPARE(filter.capabilities(), QStringList());

   489     QCOMPARE(filter.capabilityMatchRule(), QServiceFilter::MatchMinimum);

   490     

   491     filter.setCapabilities(QServiceFilter::MatchLoadable, QStringList() << "execute" << "read");

   492     QCOMPARE(filter.capabilities(), (QStringList() << "execute" << "read"));

   493     QCOMPARE(filter.capabilityMatchRule(), QServiceFilter::MatchLoadable);

   494     

   495     filter.setCapabilities(QServiceFilter::MatchLoadable);

   496     QCOMPARE(filter.capabilities(), QStringList());

   497     QCOMPARE(filter.capabilityMatchRule(), QServiceFilter::MatchLoadable);

   498 }

   499 

   500 void tst_QServiceFilter::cleanupTestCase()

   501 {

   502 }

   503 

   504 QTEST_MAIN(tst_QServiceFilter)

   505 #include "tst_qservicefilter.moc"