Fixes: NB#167467, adding and immediately removing service file

RevBy: Michal Guminiak
Details:
service mapper used a file system watcher to detect when services are added and removed.
it erroneously assumed that there would only be a single file removed/added per watcher signal.
now the service mapper correctly emits a signal for each file that has been removed/added.
refactored to add a test for multiple changes, and general improvement (using the
setPrivate() method seen in Qt unit tests). Removed unnecessary use of QMap

7 files changed, 311 insertions, 251 deletions

diff --git a/mservicemapper/mservicemapper.cpp b/mservicemapper/mservicemapper.cpp
index 83688fa4..0e50e2cd 100644
--- a/mservicemapper/mservicemapper.cpp
+++ b/mservicemapper/mservicemapper.cpp
@@ -24,23 +24,16 @@
 #include "mservicemapper.h"
 #include "mservicemapper_p.h"
 
-namespace
-{
-    enum { LastList, CurrList };
-};
-
 MServiceMapper::MServiceMapper(const QString &serviceFileDir) :
-    d_ptr(new MServiceMapperPrivate())
+    d_ptr(new MServiceMapperPrivate( serviceFileDir ))
 {
-    d_ptr->serviceFileDir = serviceFileDir;
-    d_ptr->serviceFileList.append(QStringList());
-    d_ptr->serviceFileList.append(QStringList());
-
-    d_ptr->serviceFileList[LastList] = d_ptr->fillServiceFileList();
-    fillServiceFileInfo();
+    init();
+}
 
-    d_ptr->watcher.addPath(d_ptr->serviceFileDir);
-    connect(&d_ptr->watcher, SIGNAL(directoryChanged(QString)),
+void MServiceMapper::init()
+{
+    d_ptr->init();
+    connect(&d_ptr->m_watcher, SIGNAL(directoryChanged(QString)),
             this, SLOT(handleServiceChanged(QString)));
 }
 
@@ -54,7 +47,7 @@ QString MServiceMapper::serviceName(const QString &interfaceName)
 
     QString serviceName;
     if (!serviceNameList.isEmpty()) {
-        serviceName = preferredService(serviceNameList);
+        serviceName = d_ptr->preferredService(serviceNameList);
     }
 
     bool serviceNameInvalid = serviceName.contains(" ");   // "not provided" - when the service wouldn't run
@@ -67,128 +60,60 @@ QString MServiceMapper::serviceName(const QString &interfaceName)
 
 QStringList MServiceMapper::serviceNames(const QString &interfaceName)
 {
-    d_ptr->serviceFileList[LastList] = d_ptr->fillServiceFileList();
-    int serviceFileNum = d_ptr->serviceFileList[LastList].size();
+    d_ptr->m_serviceFileList[CurrList] = d_ptr->fillServiceFileList();
+    int serviceFileNum = d_ptr->m_serviceFileList[CurrList].size();
 
     QStringList serviceNameList;
 
     for (int i = 0; i < serviceFileNum; ++i) {
-        QMap <QString, QString> thisServiceInterfacePair = serviceInterfacePair(d_ptr->serviceFileList[LastList][i]);
+        MServiceMapperPrivate::ServiceInfo serviceInfo = d_ptr->serviceInterfacePair(d_ptr->m_serviceFileList[CurrList][i]);
 
-        if (interfaceName.isEmpty() || thisServiceInterfacePair.value("Interface") == interfaceName) {
-            MServiceMapperPrivate::ServiceInfo serviceInfo;
-            serviceInfo.interface = interfaceName;
-            serviceInfo.service = thisServiceInterfacePair.value("Name");
+        if (interfaceName.isEmpty() || serviceInfo.interface == interfaceName) {
             serviceNameList << serviceInfo.service;
-            d_ptr->serviceFileInfo.insert(d_ptr->serviceFileList[LastList][i], serviceInfo);
+            d_ptr->m_serviceFileInfo.insert(d_ptr->m_serviceFileList[CurrList][i], serviceInfo);
         }
     }
 
     return serviceNameList;
 }
 
-QString MServiceMapper::preferredService(const QStringList &serviceList) const
-{
-    // policy needed, e.g. define policy in repository
-    QSettings policy("services.policy", QSettings::IniFormat);
-    //policy.setValue("provider", "nokia");
-    QString provider = policy.value("provider").toString();
-    int serviceIndex = 0;
-
-    if (!provider.isEmpty()) {
-        //iterate list to find the 1st service of the provider
-        const int size = serviceList.size();
-        for (int i = 0; i < size; ++i) {
-            if (serviceList[i].contains(provider)) {
-                serviceIndex = i;
-                break;
-            }
-        }
-    }
-
-    return serviceList[serviceIndex];
-}
-
 void MServiceMapper::handleServiceChanged(const QString &path)
 {
     Q_UNUSED(path);   // we do not support changing of the service dir
     // on the fly for now.
 
-    d_ptr->serviceFileList[CurrList] = d_ptr->fillServiceFileList();
-
-    bool isServiceAdded;
-    int currListSize = d_ptr->serviceFileList[CurrList].size();
-    int lastListSize = d_ptr->serviceFileList[LastList].size();
-
-    int list0, list1;
-    if (currListSize > lastListSize) {
-        list0 = LastList;
-        list1 = CurrList;
-        isServiceAdded = true;
-    } else {
-        list0 = CurrList;
-        list1 = LastList;
-        isServiceAdded = false;
-    }
+    d_ptr->m_serviceFileList[LastList] = d_ptr->m_serviceFileList[CurrList];
 
-    // difference between the lists
-    int i = 0;
-    const int size = d_ptr->serviceFileList[list0].size();
-    for (; i < size; ++i) {
-        if (d_ptr->serviceFileList[list0][i] != d_ptr->serviceFileList[list1][i]) {
-            break;
-        }
-    }
+    d_ptr->m_serviceFileList[CurrList] = d_ptr->fillServiceFileList();
 
-    QMap <QString, QString> thisServiceInterfacePair = serviceInterfacePair(d_ptr->serviceFileList[list1][i]);
-
-    if (!thisServiceInterfacePair.isEmpty()) {
-        if (isServiceAdded) {
-            emit serviceAvailable(thisServiceInterfacePair.value("Name"), thisServiceInterfacePair.value("Interface"));
-        } else {
-            emit serviceUnavailable(thisServiceInterfacePair.value("Name"));
+    // find removed files - those in LastList that aren't in CurrList
+    int lastListSize = d_ptr->m_serviceFileList[LastList].size();
+    for ( int index=0; index<lastListSize; ++index ) {
+        QString thisFile = d_ptr->m_serviceFileList[LastList][index];
+        bool fileRemoved = !d_ptr->m_serviceFileList[CurrList].contains( thisFile );
+        if ( fileRemoved ) {
+            QString thisServiceName = d_ptr->m_serviceFileInfo.take(thisFile).service;
+            emit serviceUnavailable( thisServiceName );
         }
-    } else {
-        // serviceInterfacePair is empty
     }
 
-    d_ptr->serviceFileList[LastList] = d_ptr->serviceFileList[CurrList];
-}
-
-QMap <QString, QString> MServiceMapper::serviceInterfacePair(const QString &fileName) const
-{
-    QMap <QString, QString> serviceInterfacePair;
-    QString absoluteFileName = QDir(d_ptr->serviceFileDir).absoluteFilePath(fileName);
-
-    if (d_ptr->fileExistsAndReadable(absoluteFileName)) {
-        QIODevice *file = d_ptr->accessFile(absoluteFileName);
-        if (file->open(QIODevice::ReadOnly)) {
-            QTextStream in(file);
-
-            while (!in.atEnd()) {
-                QString line = in.readLine();
-
-                QStringList fields = line.split('=');
-
-                if (fields[0] == "Name" ||
-                        fields[0] == "Interface") {
-                    serviceInterfacePair.insert(fields[0], fields[1]);
-                }
-            }
-        }
-
-        delete file;
-    } else {
-        // file removed
-        if (d_ptr->serviceFileInfo.contains(fileName)) {
-            serviceInterfacePair.insert("Name", d_ptr->serviceFileInfo.value(fileName).service);
-            serviceInterfacePair.insert("Interface", d_ptr->serviceFileInfo.value(fileName).interface);
-        } else {
-            // serviceFileInfo doesn't contain fileName
+    // get info for new services
+    d_ptr->fillServiceFileInfo();
+
+    // find added files - those in CurrList that aren't in LastList
+    int currListSize = d_ptr->m_serviceFileList[CurrList].size();
+    for ( int index=0; index<currListSize; ++index ) {
+        QString thisFile = d_ptr->m_serviceFileList[CurrList][index];
+        bool fileAdded = !d_ptr->m_serviceFileList[LastList].contains( thisFile );
+        if ( fileAdded ) {
+            MServiceMapperPrivate::ServiceInfo thisServiceInterfacePair =
+                d_ptr->serviceInterfacePair( thisFile );
+            emit serviceAvailable(
+                thisServiceInterfacePair.service,
+                thisServiceInterfacePair.interface);
         }
     }
 
-    return serviceInterfacePair;
 }
 
 QString MServiceMapper::servicePath(const QString &interfaceName) const
@@ -199,29 +124,14 @@ QString MServiceMapper::servicePath(const QString &interfaceName) const
     return QString("/");
 }
 
-void MServiceMapper::fillServiceFileInfo()
-{
-    d_ptr->serviceFileList[LastList] = d_ptr->fillServiceFileList();
-    int serviceFileNum = d_ptr->serviceFileList[LastList].size();
-
-    for (int i = 0; i < serviceFileNum; ++i) {
-        QMap <QString, QString> thisServiceInterfacePair = serviceInterfacePair(d_ptr->serviceFileList[LastList][i]);
-
-        MServiceMapperPrivate::ServiceInfo serviceInfo;
-        serviceInfo.service =  thisServiceInterfacePair.value("Name");
-        serviceInfo.interface =  thisServiceInterfacePair.value("Interface");
-        d_ptr->serviceFileInfo.insert(d_ptr->serviceFileList[LastList][i], serviceInfo);
-    }
-}
-
 QString MServiceMapper::interfaceName(const QString &serviceName) const
 {
     if (serviceName.isEmpty())
         return QString();
 
     QString retVal;
-    d_ptr->serviceFileList[LastList] = d_ptr->fillServiceFileList();
-    int serviceFileNum = d_ptr->serviceFileList[LastList].size();
+    d_ptr->m_serviceFileList[CurrList] = d_ptr->fillServiceFileList();
+    int serviceFileNum = d_ptr->m_serviceFileList[CurrList].size();
 
     QStringList serviceNameList;
 
@@ -229,10 +139,10 @@ QString MServiceMapper::interfaceName(const QString &serviceName) const
     bool atEndOfList = false;
     int i = 0;
     while (!serviceFound && !atEndOfList) {
-        QMap <QString, QString> thisServiceInterfacePair = serviceInterfacePair(d_ptr->serviceFileList[LastList][i]);
+        MServiceMapperPrivate::ServiceInfo thisServiceInterfacePair = d_ptr->serviceInterfacePair(d_ptr->m_serviceFileList[CurrList][i]);
 
-        if (thisServiceInterfacePair.value("Name") == serviceName) {
-            retVal = thisServiceInterfacePair.value("Interface");
+        if (thisServiceInterfacePair.service == serviceName) {
+            retVal = thisServiceInterfacePair.interface;
             serviceFound = true;
         }
 
@@ -245,3 +155,11 @@ QString MServiceMapper::interfaceName(const QString &serviceName) const
 
     return retVal;
 }
+
+#ifdef UNIT_TEST
+MServiceMapper::MServiceMapper(MServiceMapperPrivate *priv) :
+    d_ptr(priv)
+{
+    init();
+}
+#endif // UNIT_TEST
diff --git a/mservicemapper/mservicemapper.h b/mservicemapper/mservicemapper.h
index 7f43c05c..316c14a6 100644
--- a/mservicemapper/mservicemapper.h
+++ b/mservicemapper/mservicemapper.h
@@ -27,7 +27,7 @@
 #include <QMap>
 #include <QFileSystemWatcher>
 
-class MServiceMapperPrivate;
+#include "mservicemapper_p.h"
 
 class MServiceMapper : public QObject
 {
@@ -96,18 +96,14 @@ private Q_SLOTS:
     void handleServiceChanged(const QString &path);
 
 private:
-    QString preferredService(const QStringList &serviceList) const;
-    QStringList serviceFileList() const;
-    QMap<QString, QString> serviceInterfacePair(const QString &filePath) const;
-    void fillServiceFileInfo();
-
-private:
-
     enum { LAST_LIST, CURR_LIST };
+    void init();
 
     MServiceMapperPrivate *d_ptr;
 
 #ifdef UNIT_TEST
+public:
+    MServiceMapper(MServiceMapperPrivate *priv);
     friend class Ut_MServiceMapper;
 #endif // UNIT_TEST
 };
diff --git a/mservicemapper/mservicemapper_p.cpp b/mservicemapper/mservicemapper_p.cpp
index 7413dbb9..37c22164 100644
--- a/mservicemapper/mservicemapper_p.cpp
+++ b/mservicemapper/mservicemapper_p.cpp
@@ -24,12 +24,31 @@
 #include <QIODevice>
 #include <QString>
 #include <QStringList>
+#include <QSettings>
 
 #include "mservicemapper_p.h"
 
+MServiceMapperPrivate::MServiceMapperPrivate( const QString &serviceFileDir ):
+    m_serviceFileDir( serviceFileDir )
+{
+}
+
+void MServiceMapperPrivate::init()
+{
+    m_serviceFileList.append(QStringList());
+    m_serviceFileList.append(QStringList());
+
+    m_serviceFileList[LastList] = fillServiceFileList();
+    fillServiceFileInfo();
+
+    if ( !m_serviceFileDir.isEmpty() ) {
+        m_watcher.addPath(m_serviceFileDir);
+    }
+}
+
 QStringList MServiceMapperPrivate::fillServiceFileList() const
 {
-    QDir dir = QDir(serviceFileDir);
+    QDir dir = QDir(m_serviceFileDir);
     dir.setNameFilters(QStringList("*.service"));
     return dir.entryList(QDir::Files | QDir::NoSymLinks, QDir::Name);
 }
@@ -46,3 +65,72 @@ QIODevice *MServiceMapperPrivate::accessFile(const QString &fileName) const
 {
     return new QFile(fileName);
 }
+
+QString MServiceMapperPrivate::preferredService(const QStringList &serviceList) const
+{
+    // policy needed, e.g. define policy in repository
+    QSettings policy("services.policy", QSettings::IniFormat);
+    //policy.setValue("provider", "nokia");
+    QString provider = policy.value("provider").toString();
+    int serviceIndex = 0;
+
+    if (!provider.isEmpty()) {
+        //iterate list to find the 1st service of the provider
+        const int size = serviceList.size();
+        for (int i = 0; i < size; ++i) {
+            if (serviceList[i].contains(provider)) {
+                serviceIndex = i;
+                break;
+            }
+        }
+    }
+
+    return serviceList[serviceIndex];
+}
+
+MServiceMapperPrivate::ServiceInfo MServiceMapperPrivate::serviceInterfacePair(const QString &fileName) const
+{
+    MServiceMapperPrivate::ServiceInfo serviceInterfacePair;
+
+    if ( m_serviceFileInfo.contains( fileName ) ) {
+        serviceInterfacePair = m_serviceFileInfo.value( fileName );
+    } else {
+        QString absoluteFileName = QDir(m_serviceFileDir).absoluteFilePath(fileName);
+
+        if (fileExistsAndReadable(absoluteFileName)) {
+            QIODevice *file = accessFile(absoluteFileName);
+            if (file->open(QIODevice::ReadOnly)) {
+                QTextStream in(file);
+
+                while (!in.atEnd()) {
+                    QString line = in.readLine();
+
+                    QStringList fields = line.split('=');
+
+                    if (fields[0] == "Name") {
+                        serviceInterfacePair.service=fields[1];
+                    } else
+                        if (fields[0] == "Interface") {
+                            serviceInterfacePair.interface=fields[1];
+                        }
+                }
+            }
+
+            delete file;
+        }
+    }
+
+    return serviceInterfacePair;
+}
+
+void MServiceMapperPrivate::fillServiceFileInfo()
+{
+    m_serviceFileList[CurrList] = fillServiceFileList();
+    int serviceFileNum = m_serviceFileList[CurrList].size();
+
+    for (int i = 0; i < serviceFileNum; ++i) {
+        MServiceMapperPrivate::ServiceInfo serviceInfo = serviceInterfacePair(m_serviceFileList[CurrList][i]);
+
+        m_serviceFileInfo.insert(m_serviceFileList[CurrList][i], serviceInfo);
+    }
+}
diff --git a/mservicemapper/mservicemapper_p.h b/mservicemapper/mservicemapper_p.h
index 6b629bc7..c4fb4590 100644
--- a/mservicemapper/mservicemapper_p.h
+++ b/mservicemapper/mservicemapper_p.h
@@ -26,21 +26,36 @@
 #include <QList>
 #include <QFileSystemWatcher>
 
+class MServiceMapper;
+
+namespace
+{
+    enum { LastList, CurrList };
+};
+
 class MServiceMapperPrivate
 {
 public:
+    MServiceMapperPrivate( const QString &serviceFiledir );
+
     struct ServiceInfo {
         QString service;
         QString interface;
     };
-    QMap<QString, ServiceInfo> serviceFileInfo;
-    QList<QStringList>         serviceFileList;
-    QFileSystemWatcher         watcher;
-    QString                    serviceFileDir;
+    QMap<QString, ServiceInfo> m_serviceFileInfo;
+    QList<QStringList>         m_serviceFileList;
+    QFileSystemWatcher         m_watcher;
+    QString                    m_serviceFileDir;
+
 public:
-    QStringList fillServiceFileList() const;
-    bool fileExistsAndReadable(const QString &fileName) const;
-    QIODevice *accessFile(const QString &fileName) const;
+    virtual QStringList fillServiceFileList() const;
+    virtual bool fileExistsAndReadable(const QString &fileName) const;
+    virtual QIODevice *accessFile(const QString &fileName) const;
+    virtual void init();
+
+    QString preferredService(const QStringList &serviceList) const;
+    ServiceInfo serviceInterfacePair(const QString &filePath) const;
+    void fillServiceFileInfo();
 };
 
 #endif
diff --git a/tests/ut_mservicemapper/ut_mservicemapper.cpp b/tests/ut_mservicemapper/ut_mservicemapper.cpp
index f9dc0f10..d9032a13 100644
--- a/tests/ut_mservicemapper/ut_mservicemapper.cpp
+++ b/tests/ut_mservicemapper/ut_mservicemapper.cpp
@@ -24,45 +24,57 @@
 
 #include "mservicemapper_p.h"
 
-const int Ut_MServiceMapper::noAllFiles;
-QTextStream Ut_MServiceMapper::globalDummy;
-int Ut_MServiceMapper::noFiles;
-int Ut_MServiceMapper::lineNo;
-int Ut_MServiceMapper::fileNo;
-QString Ut_MServiceMapper::lines[4][2];
-QString Ut_MServiceMapper::services[3];
-QString Ut_MServiceMapper::interfaces[3];
-
-QStringList MServiceMapperPrivate::fillServiceFileList() const
-{
-    QStringList retVal;
-    for (int thisFileNo = 0; thisFileNo < Ut_MServiceMapper::noFiles; ++thisFileNo) {
-        QString filename = QString("services/%1.service").arg(thisFileNo);
-        retVal << filename;
-    }
+QTextStream Ut_MServiceMapper::m_globalDummy;
+int Ut_MServiceMapper::m_noFiles;
+int Ut_MServiceMapper::m_lineNo;
+int Ut_MServiceMapper::m_fileNo;
+QString Ut_MServiceMapper::m_lines[4][2];
+QString Ut_MServiceMapper::m_services[3];
+QString Ut_MServiceMapper::m_interfaces[3];
+QStringList Ut_MServiceMapper::m_currentServiceFileList;
+
+class MyMServiceMapperPrivate: public MServiceMapperPrivate
+{
+public:
+    MyMServiceMapperPrivate( const QString &serviceFileDir );
+    ~MyMServiceMapperPrivate();
+
+    QStringList fillServiceFileList() const;
+    bool fileExistsAndReadable( const QString &filename ) const;
+    QIODevice *accessFile( const QString &fileName ) const;
+};
+
+MyMServiceMapperPrivate::MyMServiceMapperPrivate( const QString &serviceFileDir ) :
+    MServiceMapperPrivate( serviceFileDir )
+{
+}
+
+QStringList MyMServiceMapperPrivate::fillServiceFileList() const
+{
+    QStringList retVal( Ut_MServiceMapper::m_currentServiceFileList );
 
     return retVal;
 }
 
-bool MServiceMapperPrivate::fileExistsAndReadable(const QString &fileName) const
+bool MyMServiceMapperPrivate::fileExistsAndReadable(const QString &fileName) const
 {
     Q_UNUSED(fileName);
     bool retVal;
 
     QString baseName = QFileInfo(fileName).baseName();
     int thisFileNo = baseName.toInt();
-    retVal = thisFileNo < Ut_MServiceMapper::noFiles;
+    retVal = thisFileNo < Ut_MServiceMapper::m_noFiles;
 
     return retVal;
 }
 
-QIODevice *MServiceMapperPrivate::accessFile(const QString &fileName) const
+QIODevice *MyMServiceMapperPrivate::accessFile(const QString &fileName) const
 {
     Q_UNUSED(fileName);
     QBuffer *thisFile = new QBuffer();
     thisFile->open(QIODevice::ReadWrite);
 
-    int lastFileNo = Ut_MServiceMapper::noFiles - 1;
+    int lastFileNo = Ut_MServiceMapper::m_noFiles - 1;
 
     QString baseName = QFileInfo(fileName).baseName();
     int thisFileNo = baseName.toInt();
@@ -71,7 +83,7 @@ QIODevice *MServiceMapperPrivate::accessFile(const QString &fileName) const
     if (thisFileShouldExist) {
         for (int thisLineNo = 0; thisLineNo < 2; ++thisLineNo) {
             QTextStream output(thisFile);
-            output << Ut_MServiceMapper::lines[ thisFileNo ][ thisLineNo ] << endl;
+            output << Ut_MServiceMapper::m_lines[ thisFileNo ][ thisLineNo ] << endl;
         }
     }
     thisFile->seek(0);
@@ -82,15 +94,16 @@ QIODevice *MServiceMapperPrivate::accessFile(const QString &fileName) const
 void Ut_MServiceMapper::init()
 {
     // always start with two files
-    //mkFiles( 2 );
-    noFiles = 2;
+    fillServiceFileList( 2 );
 
     // reset to beginning of first file for each test
     // difficult to keep track otherwise
-    lineNo = 0;
-    fileNo = 0;
+    m_lineNo = 0;
+    m_fileNo = 0;
 
-    m_subject = new MServiceMapper("/");
+    QString serviceFileDir;
+
+    m_subject = new MServiceMapper( new MyMServiceMapperPrivate( serviceFileDir ) );
 }
 
 void Ut_MServiceMapper::cleanup()
@@ -101,61 +114,26 @@ void Ut_MServiceMapper::cleanup()
 
 void Ut_MServiceMapper::initTestCase()
 {
-    services[0] = "com.nokia.EmailService";
-    interfaces[0] = "com.nokia.EmailServiceIf";
-    services[1] = "org.maemo.EmailService";
-    interfaces[1] = "org.maemo.EmailServiceIf";
-    services[2] = "com.google.EmailService";
-    interfaces[2] = "com.google.EmailServiceIf";
-
-    lines[0][0] = "Interface=" + interfaces[0];
-    lines[0][1] = "Name=" + services[0];
-    lines[1][0] = "Interface=" + interfaces[1];
-    lines[1][1] = "Name=" + services[1];
-    lines[2][0] = "Interface=" + interfaces[2];
-    lines[2][1] = "Name=" + services[2];
-    lines[3][0] = "Interface=not provided";
-    lines[3][1] = "Name=not provided";
-
-    //QDir(".").mkdir( "services" );
+    m_services[0] = "com.nokia.EmailService";
+    m_interfaces[0] = "com.nokia.EmailServiceIf";
+    m_services[1] = "org.maemo.EmailService";
+    m_interfaces[1] = "org.maemo.EmailServiceIf";
+    m_services[2] = "com.google.EmailService";
+    m_interfaces[2] = "com.google.EmailServiceIf";
+
+    m_lines[0][0] = "Interface=" + m_interfaces[0];
+    m_lines[0][1] = "Name=" + m_services[0];
+    m_lines[1][0] = "Interface=" + m_interfaces[1];
+    m_lines[1][1] = "Name=" + m_services[1];
+    m_lines[2][0] = "Interface=" + m_interfaces[2];
+    m_lines[2][1] = "Name=" + m_services[2];
+    m_lines[3][0] = "Interface=not provided";
+    m_lines[3][1] = "Name=not provided";
 }
 
 void Ut_MServiceMapper::cleanupTestCase()
 {
-    //mkFiles(0);
-    noFiles = 0;
-    QDir(".").rmdir("services");
-}
-
-void Ut_MServiceMapper::mkFiles(int noFiles)
-{
-    int lastFileNo = noFiles - 1;
-
-    for (int thisFileNo = 0; thisFileNo < noAllFiles; ++thisFileNo) {
-        QString filename = QString("services/%1.service").arg(thisFileNo);
-
-        QFile thisFile(filename);
-        bool thisFileShouldExist = thisFileNo <= lastFileNo;
-        if (thisFile.exists()) {
-            if (!thisFileShouldExist) {
-                thisFile.remove();
-            }
-        } else {
-            if (thisFileShouldExist) {
-                bool openFailed = !thisFile.open(QIODevice::WriteOnly | QIODevice::Text);
-                if (openFailed) {
-                    qCritical() << "Could not open file for writing";
-                }
-
-                for (int thisLineNo = 0; thisLineNo < 2; ++thisLineNo) {
-                    QTextStream output(&thisFile);
-                    output << lines[ thisFileNo ][ thisLineNo ] << endl;
-                }
-            }
-        }
-
-        thisFile.close();
-    }
+    m_currentServiceFileList.clear();
 }
 
 void Ut_MServiceMapper::checkServiceNamesNoIf()
@@ -164,8 +142,8 @@ void Ut_MServiceMapper::checkServiceNamesNoIf()
     QStringList myServices = m_subject->serviceNames();
 
     QCOMPARE(myServices.size(), 2);
-    QCOMPARE(myServices[0], services[0]);
-    QCOMPARE(myServices[1], services[1]);
+    QCOMPARE(myServices[0], m_services[0]);
+    QCOMPARE(myServices[1], m_services[1]);
 }
 
 void Ut_MServiceMapper::checkServiceNamesIf()
@@ -174,18 +152,18 @@ void Ut_MServiceMapper::checkServiceNamesIf()
     QStringList myServices = m_subject->serviceNames("com.nokia.EmailServiceIf");
 
     QCOMPARE(myServices.size(), 1);
-    QCOMPARE(myServices[0], services[0]);
+    QCOMPARE(myServices[0], m_services[0]);
 }
 
 void Ut_MServiceMapper::checkServiceName()
 {
-    QString myService = m_subject->serviceName(interfaces[0]);
-    QCOMPARE(myService, services[0]);
+    QString myService = m_subject->serviceName(m_interfaces[0]);
+    QCOMPARE(myService, m_services[0]);
 }
 
 void Ut_MServiceMapper::checkServicePath()
 {
-    QString myPath = m_subject->servicePath(interfaces[0]);
+    QString myPath = m_subject->servicePath(m_interfaces[0]);
     QCOMPARE(myPath, QString("/"));
 }
 
@@ -194,9 +172,7 @@ void Ut_MServiceMapper::checkHandleServiceChangedAddLastFile()
     QSignalSpy serviceAvailableSpy(m_subject,
                                    SIGNAL(serviceAvailable(QString, QString)));
 
-    // add a file - constructed with 2 files
-    //mkFiles( 3 );
-    noFiles = 3;
+    fillServiceFileList( 3 );
     m_subject->handleServiceChanged("/");
 
     QCOMPARE(serviceAvailableSpy.count(), 1);
@@ -207,9 +183,7 @@ void Ut_MServiceMapper::checkHandleServiceChangedRmLastFile()
     QSignalSpy serviceUnavailableSpy(m_subject,
                                      SIGNAL(serviceUnavailable(QString)));
 
-    // remove a file - constructed with 2 files
-    //mkFiles( 1 );
-    noFiles = 1;
+    fillServiceFileList( 1 );
     m_subject->handleServiceChanged("/");
 
     QCOMPARE(serviceUnavailableSpy.count(), 1);
@@ -217,11 +191,76 @@ void Ut_MServiceMapper::checkHandleServiceChangedRmLastFile()
 
 void Ut_MServiceMapper::checkServiceNameBadIf()
 {
-    //mkFiles( 4 );
-    noFiles = 4;
-    lineNo = 3;
+    fillServiceFileList( 4 );
+    m_lineNo = 3;
     QString myService = m_subject->serviceName("not provided");
     QVERIFY(myService.isEmpty());
 }
 
+void Ut_MServiceMapper::checkHandleServiceChangedAddAndRemoveFiles()
+{
+    //
+    // set up
+    //
+
+    m_currentServiceFileList.clear();
+    m_noFiles = 5; // bit of a hack really - has to be >= the last file
+
+    // set the 'last' list of files
+    {
+        m_currentServiceFileList
+            << "0.service"
+            // 1 will be added
+            << "2.service" // will be removed
+            << "3.service"
+            << "4.service";
+
+        m_subject->handleServiceChanged("/");
+    }
+
+    //
+    // now for the test....
+    //
+
+    // listen for signals
+    QSignalSpy serviceAvailableSpy(m_subject,
+                                   SIGNAL(serviceAvailable(QString, QString)));
+    QSignalSpy serviceUnavailableSpy(m_subject,
+                                     SIGNAL(serviceUnavailable(QString)));
+
+    m_currentServiceFileList.clear();
+    m_currentServiceFileList
+        << "0.service"
+        << "1.service" // added
+        // 2 has been removed
+        << "3.service"
+        << "4.service";
+
+    m_subject->handleServiceChanged("/");
+
+    {
+        QCOMPARE(serviceAvailableSpy.count(), 1);
+        QList<QVariant> arguments = serviceAvailableSpy.takeFirst();
+        QCOMPARE( arguments.at(0).toString(), m_services[1] );
+        QCOMPARE( arguments.at(1).toString(), m_interfaces[1] );
+    }
+
+    {
+        QCOMPARE(serviceUnavailableSpy.count(), 1);
+        QList<QVariant> arguments = serviceUnavailableSpy.takeFirst();
+        QCOMPARE( arguments.at(0).toString(), m_services[2] );
+    }
+}
+
+void Ut_MServiceMapper::fillServiceFileList( int noFiles )
+{
+    m_currentServiceFileList.clear();
+
+    m_noFiles = noFiles;
+    for (int thisFileNo = 0; thisFileNo < noFiles; ++thisFileNo) {
+        QString filename = QString("services/%1.service").arg(thisFileNo);
+        m_currentServiceFileList << filename;
+    }
+}
+
 QTEST_MAIN(Ut_MServiceMapper)
diff --git a/tests/ut_mservicemapper/ut_mservicemapper.h b/tests/ut_mservicemapper/ut_mservicemapper.h
index 833e7b8e..e34d883a 100644
--- a/tests/ut_mservicemapper/ut_mservicemapper.h
+++ b/tests/ut_mservicemapper/ut_mservicemapper.h
@@ -32,31 +32,32 @@ class Ut_MServiceMapper : public QObject
     Q_OBJECT
 
 public:
-    static const int noAllFiles = 3;
-    static int noFiles;
-    static QTextStream globalDummy;
-    static int lineNo;
-    static int fileNo;
-    static QString lines[4][2];
-    static QString services[3];
-    static QString interfaces[3];
+    static int m_noFiles;
+    static QTextStream m_globalDummy;
+    static int m_lineNo;
+    static int m_fileNo;
+    static QString m_lines[4][2];
+    static QString m_services[3];
+    static QString m_interfaces[3];
+    static QStringList m_currentServiceFileList;
 
 private slots:
     void init();
     void cleanup();
     void initTestCase();
     void cleanupTestCase();
-    void checkHandleServiceChangedRmLastFile();
     void checkServiceNamesNoIf();
     void checkServiceNamesIf();
     void checkServiceName();
     void checkServicePath();
-    void checkHandleServiceChangedAddLastFile();
     void checkServiceNameBadIf();
+    void checkHandleServiceChangedAddLastFile();
+    void checkHandleServiceChangedRmLastFile();
+    void checkHandleServiceChangedAddAndRemoveFiles();
 
 private:
     MServiceMapper *m_subject;
-    void mkFiles(int noFiles);
+    void fillServiceFileList( int noFiles );
 
 };
 #endif
diff --git a/tests/ut_mservicemapper/ut_mservicemapper.pro b/tests/ut_mservicemapper/ut_mservicemapper.pro
index 62402b8b..f48f673f 100644
--- a/tests/ut_mservicemapper/ut_mservicemapper.pro
+++ b/tests/ut_mservicemapper/ut_mservicemapper.pro
@@ -1,5 +1,6 @@
 include(../common_top.pri)
 
+LIBS -= -lmeegotouchcore -lmeegotouchviews
 SFWDIR = ../../mservicemapper
 INCLUDEPATH += $$SFWDIR
 DEPENDPATH += $$INCLUDEPATH
@@ -10,6 +11,7 @@ TARGET = ut_mservicemapper
 # unit
 TEST_SOURCES =  \
     $$SFWDIR/mservicemapper.cpp \
+    $$SFWDIR/mservicemapper_p.cpp \
 
 # unit test and unit
 SOURCES += \
@@ -20,5 +22,6 @@ SOURCES += \
 HEADERS += \
     ut_mservicemapper.h \
     $$SFWDIR/mservicemapper.h \
+    $$SFWDIR/mservicemapper_p.h \
 
 include(../common_bot.pri)