Merge lp:~carlos-mazieri/ubuntu-filemanager-app/samba-actions-17 into lp:ubuntu-filemanager-app

[Carlos Jose Mazieri]

Created Unit Tests for Samba Similar Qt Objects: SmbLocationItemFile, SmbLocationItemDir and SmbLocationItemDirIterator

Created Unit Tests for Samba Similar Qt Objects in "qsambaclient" module.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:448
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/518/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-utopic/3103
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/3103/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-utopic-amd64-ci/234
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-vivid-amd64-ci/140

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/518/rebuild

review: Approve (continuous-integration)

[Arto Jalkanen (ajalkane)]

review: Approve

=== modified file 'src/plugin/folderlistmodel/smb/qsambaclient/test/testqsambasuite.cpp'
--- src/plugin/folderlistmodel/smb/qsambaclient/test/testqsambasuite.cpp	2015-07-19 16:44:54 +0000
+++ src/plugin/folderlistmodel/smb/qsambaclient/test/testqsambasuite.cpp	2015-07-19 16:44:54 +0000
@@ -26,6 +26,8 @@
 #include "locationurl.h"
 #include "smbutil.h"
 #include "smblocationdiriterator.h"
+#include "smblocationitemfile.h"
+#include "smblocationitemdir.h"
 #include <sys/stat.h>
 #include <errno.h>
 
@@ -726,3 +728,659 @@
     }
     return true;
 }
+
+
+void TestQSambaSuite::unit_QFile_rename()
+{
+    ShareCreationStatus share(createTempShare("unit_QFile_rename"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    //empty object
+    SmbLocationItemFile fileNameEmptyDoesNotExist;
+    QString newName("this_was_renamed.txt");
+    QCOMPARE(fileNameEmptyDoesNotExist.rename(newName), false);
+    QCOMPARE(fileNameEmptyDoesNotExist.rename(QLatin1String(0), newName), false);
+    //orig file does not exist
+    QString nameDoesNotExist("_it_must_not_exist");
+    SmbSharedPathAccess item = share.createPathForItem(nameDoesNotExist);
+    QFileInfo diskFileContent(item.diskPathname);
+    QCOMPARE(diskFileContent.exists(), false);
+    SmbLocationItemFile fileNameDoesNotExist(item.smbUrl);
+    QCOMPARE(fileNameDoesNotExist.rename(newName), false);
+    QCOMPARE(fileNameDoesNotExist.rename(nameDoesNotExist, newName), false);
+
+    //positive tests
+    SmbSharedPathAccess newItem = share.createPathForItem(newName);
+    QFileInfo newFileInfo(newItem.diskPathname);
+    //make sure target does not exist
+    QCOMPARE(newFileInfo.exists(), false);
+    //now rename
+    SmbLocationItemFile fileNameExists(share.fileContent.smbUrl);
+    QCOMPARE(fileNameExists.rename(newItem.smbUrl), true);
+    //now target must exist in local file system
+    QCOMPARE(newFileInfo.exists(), true);
+    diskFileContent.setFile(share.fileContent.diskPathname);
+    //make sure orignal file no longer exist
+    QCOMPARE(diskFileContent.exists(), false);
+    //now back to original name using an empty object
+    SmbLocationItemFile empty;
+    QCOMPARE(empty.rename(newItem.smbUrl, share.fileContent.smbUrl), true);
+    //make sure orignal exists again
+    QCOMPARE(diskFileContent.exists(), true);
+}
+
+
+void TestQSambaSuite::unit_QFile_remove()
+{
+    ShareCreationStatus share(createTempShare("unit_QFile_remove"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    //empty object
+    SmbLocationItemFile fileNameEmptyDoesNotExist;
+    QCOMPARE(fileNameEmptyDoesNotExist.remove(), false);
+    //file name does not exist
+    SmbSharedPathAccess item = share.createPathForItem("_it_must_not_exist");
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemFile fileNameDoesNotExist(item.smbUrl);
+    QCOMPARE(fileNameDoesNotExist.remove(), false);
+    QFileInfo diskFileInfo(share.fileContent.diskPathname);
+//    //now try to remove a file which does not have write permission
+//    QCOMPARE(diskFileInfo.exists(), true);
+//    QFile::Permissions originalPermissions = diskFileInfo.permissions();
+//    QCOMPARE(QFile::setPermissions(share.fileContent.diskPathname, QFile::ReadOwner | QFile::ReadGroup | QFile::ReadOther), true);
+//    SmbLocationItemFile existentFileButNoWritePermission(share.fileContent.smbUrl);
+//    //remove must fail
+//    QCOMPARE(existentFileButNoWritePermission.remove(), false);
+//    QCOMPARE(errno, EPERM);
+//    QCOMPARE(QFile::setPermissions(share.fileContent.diskPathname, originalPermissions), true);
+
+    //positive test, remove fileContent
+    SmbLocationItemFile existentFile(share.fileContent.smbUrl);
+    SmbItemInfo smbExistentItem(share.fileContent.smbUrl);
+    QCOMPARE(smbExistentItem.exists(), true);
+    QCOMPARE(existentFile.remove(), true);
+    SmbItemInfo smbItem(share.fileContent.smbUrl);
+    //samba url for this file must not exist
+    QCOMPARE(smbItem.exists(),  false);
+    //now origin file in file system must no longer exist
+    QCOMPARE(diskFileInfo.exists(), false);
+}
+
+
+void TestQSambaSuite::unit_QFile_open()
+{
+    ShareCreationStatus share(createTempShare("unit_QFile_open"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    SmbLocationItemFile fileNameEmptyDoesNotExist;
+    QCOMPARE(fileNameEmptyDoesNotExist.open(QFile::WriteOnly), false);
+    SmbSharedPathAccess item = share.createPathForItem("_it_must_not_exist");
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemFile fileNameDoesNotExist(item.smbUrl);
+    QCOMPARE(fileNameDoesNotExist.open(QFile::ReadOnly), false);
+
+    // ---- positive tests
+    //create a smb file using open
+    item = share.createPathForItem("now_it_must_be_created");
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemFile fileCreated(item.smbUrl);
+    QCOMPARE(fileCreated.open(QFile::WriteOnly), true);
+    if (QFileInfo(item.diskPathname).exists() == false)
+    {
+        fileCreated.close(); // force to close if necessary
+    }
+    QCOMPARE(fileCreated.isOpen(), true);
+    //now check in the local disk to see if it was really created
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), true);
+    //as QFile it closes itself in the destructor
+}
+
+
+void TestQSambaSuite::unit_QFile_read()
+{
+    ShareCreationStatus share(createTempShare("unit_QFile_read"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    SmbLocationItemFile fileNameEmptyDoesNotExist;
+    char buffer[100];
+
+    //get Qt read return when there is no file
+    qint64 qt_read_no_file = QFile().read(buffer, sizeof(buffer));
+
+    QCOMPARE(fileNameEmptyDoesNotExist.read(buffer, sizeof(buffer)), qt_read_no_file);
+    SmbSharedPathAccess item = share.createPathForItem("_it_must_not_exist");
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemFile fileMustNotExist(item.smbUrl);
+    QCOMPARE(fileMustNotExist.read(buffer, sizeof(buffer)), qt_read_no_file);
+
+    //positive test
+    //create a file in the local folder which is shared by Samba
+    item = share.createPathForItem("created_in_the_disk.txt");
+    QFile inDisk(item.diskPathname);
+    QCOMPARE(inDisk.open(QFile::WriteOnly),  true);
+    QByteArray diskContent("This a simple content used to test reading files from samba: ");
+    QByteArray initialDiskContent(diskContent);
+    QByteArray moreDiskContent(100, 'a');
+    diskContent += moreDiskContent;
+    QCOMPARE(inDisk.write(diskContent),  (qint64)diskContent.size());
+    inDisk.close();
+    //now read from Samba
+    SmbLocationItemFile existentFile(item.smbUrl);
+    QCOMPARE(existentFile.open(QFile::ReadOnly),  true);
+    char smbBuffer [diskContent.size() + 100];
+    //before first read
+    QCOMPARE(existentFile.atEnd(),  false);
+    qint64 bytesRead    = existentFile.read(smbBuffer, (qint64)initialDiskContent.size());
+    qint64 expectedRead = (qint64)initialDiskContent.size();
+    QCOMPARE(bytesRead, expectedRead);
+    QByteArray  smbContent(smbBuffer,initialDiskContent.size());
+    //compare the intial content
+    QCOMPARE(smbContent, initialDiskContent);
+    //before second read
+    QCOMPARE(existentFile.atEnd(),  false);
+    expectedRead = (qint64) (diskContent.size() - initialDiskContent.size());
+    //read remaining data in the file
+    bytesRead    = existentFile.read(smbBuffer, expectedRead);
+    QCOMPARE(bytesRead, expectedRead);
+    QByteArray   moreSmbContent(smbBuffer, expectedRead);
+    smbContent += moreSmbContent;
+    //now compare the whole content
+    QCOMPARE(smbContent, diskContent);
+    //now atEnd() must be true
+    QCOMPARE(existentFile.atEnd(),  true);
+}
+
+
+void TestQSambaSuite::unit_QFile_write()
+{
+    ShareCreationStatus share(createTempShare("unit_QFile_write"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    SmbLocationItemFile fileNameEmptyDoesNotExist;
+    QByteArray someContent("This is a simple content\n");
+    //get Qt write return when there is no file
+    qint64 qt_write_no_file = QFile().write(someContent.constData(), (qint64)someContent.size());
+    QCOMPARE(fileNameEmptyDoesNotExist.write(someContent.constData(), (qint64)someContent.size()), qt_write_no_file);
+    SmbSharedPathAccess item = share.createPathForItem("_it_must_not_exist");
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemFile fileMustNotExist(item.smbUrl);
+    QCOMPARE(fileMustNotExist.write(someContent.constData(), (qint64)someContent.size()), qt_write_no_file);
+
+    //positive tests
+    //work with 2 items saving in Samba and saving in local file system
+    SmbSharedPathAccess items[2];
+    items[0]  = share.createPathForItem("first_item.txt");
+    items[1]  = share.createPathForItem("second_item.txt");
+    QByteArray       content;     // starts empty
+    QFile::OpenMode  openMode = QFile::WriteOnly; //after first write it receives Append mode
+    const int diskIndex = 0;
+    const int smbindex  = 1;
+    QByteArray  savedContent;
+    for(int counter = 0;  counter < 4;  ++counter, content += someContent)
+    {
+        QFile                 diskFile(items[diskIndex].diskPathname);
+        SmbLocationItemFile   smbFile(items[smbindex].smbUrl);
+        //open both files
+        QCOMPARE(diskFile.open(openMode), true);
+        QCOMPARE(smbFile.open(openMode),  true);
+        //first write should return 0 as content is empty
+        qint64 toSave = content.size();
+        qint64 wrote  = diskFile.write(content.constData(), toSave);
+        QCOMPARE(wrote, toSave);
+        wrote  = smbFile.write(content.constData(), toSave);
+        QCOMPARE(wrote, toSave);
+        savedContent += content;
+        diskFile.close();
+        smbFile.close();
+        if (counter > 0)
+        {
+            openMode = QFile::Append;
+        }
+    }
+   //now check size and content
+   QFile                  diskFile(items[diskIndex].diskPathname);
+   SmbLocationItemFile    smbFile(items[smbindex].smbUrl);
+   QCOMPARE(smbFile.size(),  diskFile.size());
+   QCOMPARE(diskFile.open(QFile::ReadOnly), true);
+   QCOMPARE(smbFile.open(QFile::ReadOnly), true);
+   //read file from disk, check the content
+   char buffer [1024];
+   qint64 gotBytes = diskFile.read(buffer, sizeof(buffer));
+   QCOMPARE((qint64)savedContent.size(),  gotBytes);
+   QByteArray otherContent(buffer,  (int)gotBytes);
+   QCOMPARE(otherContent, savedContent);
+   //read SMB file from disk, check the content
+   gotBytes = smbFile.read(buffer, sizeof(buffer));
+   QCOMPARE((qint64)savedContent.size(),  gotBytes);
+   otherContent.setRawData(buffer, (int)gotBytes);
+   QCOMPARE(otherContent, savedContent);
+}
+
+
+void TestQSambaSuite::unit_QFile_atEnd()
+{
+    ShareCreationStatus share(createTempShare("unit_QFile_atEnd"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    SmbLocationItemFile fileNameEmptyDoesNotExist;
+    QCOMPARE(fileNameEmptyDoesNotExist.atEnd(), true);
+    SmbSharedPathAccess item = share.createPathForItem("_it_must_not_exist");
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemFile fileMustNotExist(item.smbUrl);
+    QCOMPARE(fileMustNotExist.atEnd(), true);
+    QFileInfo fileContentInfo(share.fileContent.diskPathname);
+    QCOMPARE(fileContentInfo.exists(), true);
+    SmbLocationItemFile existentFile(share.fileContent.smbUrl);
+    //first at end when file is still closed
+    QCOMPARE(existentFile.atEnd(),  true);
+    QCOMPARE(existentFile.open(QFile::ReadOnly),  true);
+    char buffer [fileContentInfo.size()];
+    QCOMPARE(existentFile.read(buffer, (qint64)10), (qint64)10);
+    //file is opened and not at end
+    QCOMPARE(existentFile.atEnd(),  false);
+    QVERIFY(existentFile.read(buffer, fileContentInfo.size()) > 0);
+    QCOMPARE(existentFile.atEnd(),  true);
+}
+
+
+void TestQSambaSuite::unit_QFile_size()
+{
+    ShareCreationStatus share(createTempShare("unit_QFile_size"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    //empty objects
+    qint64 qFile_size_for_disk = QFileInfo().size();
+    SmbLocationItemFile fileNameEmptyDoesNotExist;
+    QCOMPARE(fileNameEmptyDoesNotExist.size(), qFile_size_for_disk);
+    //file does not exist
+    SmbSharedPathAccess item = share.createPathForItem("it_must_not_exist.txt");
+    QFileInfo diskFileInfo(item.diskPathname);
+    QCOMPARE(diskFileInfo.exists(), false);
+    qFile_size_for_disk = diskFileInfo.size();
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemFile fileMustNotExist(item.smbUrl);
+    QCOMPARE(fileMustNotExist.size(), qFile_size_for_disk);
+
+    //positive tests
+    diskFileInfo.setFile(share.fileContent.diskPathname);
+    QCOMPARE(diskFileInfo.exists(), true);
+    qFile_size_for_disk = diskFileInfo.size();
+    QVERIFY(qFile_size_for_disk > 0);
+    SmbLocationItemFile existentFile(share.fileContent.smbUrl);
+    //first time the file is closed
+    QCOMPARE(existentFile.size(), qFile_size_for_disk);
+    QCOMPARE(existentFile.open(QFile::ReadOnly),  true);
+    //second time the file is opened
+    QCOMPARE(existentFile.size(), qFile_size_for_disk);
+    //now append data using local file system
+    QFile moreDataFile(share.fileContent.diskPathname);
+    QCOMPARE(moreDataFile.open(QFile::Append),  true);
+    QByteArray moreData("just a more bytes");
+    QCOMPARE(moreDataFile.write(moreData),  (qint64)moreData.size());
+    moreDataFile.close();
+    //other QFileInfo object to get new information
+    QFileInfo newDiskFileInfo(share.fileContent.diskPathname);
+    QVERIFY(newDiskFileInfo.size() > qFile_size_for_disk); // has more data now
+    QCOMPARE(existentFile.size(), newDiskFileInfo.size());
+}
+
+
+void TestQSambaSuite::unit_QFile_isOpen()
+{
+    ShareCreationStatus share(createTempShare("unit_QFile_isOpen"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    SmbLocationItemFile fileNameEmptyDoesNotExist;
+    QCOMPARE(fileNameEmptyDoesNotExist.isOpen(), false);
+    SmbSharedPathAccess item = share.createPathForItem("_it_must_not_exist");
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemFile fileMustNotExist(item.smbUrl);
+    QCOMPARE(fileMustNotExist.isOpen(), false);
+
+    //positive tests
+    SmbLocationDirIterator fileContentIterator(share.url, QDir::Files);
+    QCOMPARE(fileContentIterator.hasNext(),  true);
+    fileContentIterator.next();
+    DirItemInfo iteminfo = fileContentIterator.fileInfo();
+    QCOMPARE(iteminfo.exists(),  true);
+    SmbLocationItemFile  smbFile(iteminfo.urlPath());
+    QCOMPARE(smbFile.isOpen(), false);
+    QCOMPARE(smbFile.open(QFile::ReadOnly), true);
+    QCOMPARE(smbFile.isOpen(), true);
+}
+
+
+void TestQSambaSuite::unit_QFile_permissions()
+{
+    ShareCreationStatus share(createTempShare("unit_QFile_permissions"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    //empty objects
+    QFile::Permissions qt_empty_permissions = QFileInfo().permissions();
+    SmbLocationItemFile fileNameEmptyDoesNotExist;
+    QCOMPARE(fileNameEmptyDoesNotExist.permissions(), qt_empty_permissions);
+    //file does not exist
+    SmbSharedPathAccess item = share.createPathForItem("it_must_not_exist.txt");
+    QFileInfo diskFileInfo(item.diskPathname);
+    QCOMPARE(diskFileInfo.exists()  ,false);
+    SmbLocationItemFile fileNameDoesNotExist(item.smbUrl);
+    QCOMPARE(fileNameDoesNotExist.permissions(), qt_empty_permissions);
+
+    //positive test, change in the local disk , check for permission in Samba
+    QFile::Permissions perm_readOnly = QFile::ReadOwner | QFile::ReadGroup | QFile::ReadOther  | QFile::ReadUser;
+
+    QFileInfo diskExistentFile(share.fileContent.diskPathname);
+    QCOMPARE(diskExistentFile.exists(), true);
+    //first make sure permissions are different
+    QVERIFY(diskExistentFile.permissions() != perm_readOnly);
+    //set permission using file in the local file system
+    QCOMPARE(QFile::setPermissions(share.fileContent.diskPathname, perm_readOnly), true);
+    //check the permission in the local file system
+    QTest::qWait(100);
+    QFile::Permissions curr_permissions = QFile(share.fileContent.diskPathname).permissions();
+    QCOMPARE(curr_permissions, perm_readOnly);
+    //now the same permission must come using Samba
+    SmbLocationItemFile smbExistentFile(share.fileContent.smbUrl);
+    QFile::Permissions curr_smb_ermissions = smbExistentFile.permissions();
+    QCOMPARE(curr_smb_ermissions, perm_readOnly);
+}
+
+
+void TestQSambaSuite::unit_QFile_setPermissions()
+{    
+    ShareCreationStatus share(createTempShare("unit_QFile_setPermissions"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    //empty objects
+    QFile::Permissions qt_permissions = QFile::ReadOwner | QFile::ReadUser | QFile::WriteOwner | QFile::WriteUser;
+    SmbLocationItemFile fileNameEmptyDoesNotExist;
+    QCOMPARE(fileNameEmptyDoesNotExist.setPermissions(qt_permissions), false);
+    //file does not exist
+    SmbSharedPathAccess item = share.createPathForItem("it_must_not_exist.txt");
+    QFileInfo diskFileInfo(item.diskPathname);
+    QCOMPARE(diskFileInfo.exists()  ,false);
+    SmbLocationItemFile fileNameDoesNotExist(item.smbUrl);
+    QCOMPARE(fileNameDoesNotExist.setPermissions(qt_permissions), false);
+
+    QCOMPARE(fileNameDoesNotExist.setPermissions(share.fileContent.smbUrl, qt_permissions), true);
+    SmbLocationItemFile smbFile(share.fileContent.smbUrl);
+    QCOMPARE(smbFile.setPermissions(qt_permissions), true);
+}
+
+
+void TestQSambaSuite::unit_QDir_exists()
+{
+    ShareCreationStatus share(createTempShare("unit_QDir_mkdir"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    SmbLocationItemDir directoryEmptyName;
+    QCOMPARE(directoryEmptyName.exists(),  false);
+    SmbSharedPathAccess item =  share.createPathForItem("dirName");
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemDir directoryDoesNotExist(item.smbUrl);
+    QCOMPARE(directoryDoesNotExist.exists(),  false);
+
+    //positve test
+    //item.smbUrl does not exist, check above
+    //create it in the disk
+    QCOMPARE(QDir().mkpath(item.diskPathname), true);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), true);
+    SmbLocationItemDir  directoyExists(item.smbUrl);
+    QCOMPARE(directoyExists.exists(),  true);
+}
+
+
+
+
+void TestQSambaSuite::unit_QDir_mkdir()
+{
+    ShareCreationStatus share(createTempShare("unit_QDir_mkdir"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    SmbLocationItemDir directoryDoesNotExist;
+    QCOMPARE(directoryDoesNotExist.mkdir("relativeDir"), false);
+    QCOMPARE(directoryDoesNotExist.mkdir("smb://localhost/share_does_not_exist"), false);
+    QCOMPARE(directoryDoesNotExist.mkdir("smb://localhost/share_does_not_exist/invalid_share"), false);
+
+    //positive tests
+
+    //create relative directory
+    QString relativeName("relativeDir");
+    SmbSharedPathAccess item =  share.createPathForItem(relativeName);
+    SmbLocationItemDir testRelative(share.url);
+    SmbItemInfo smbDirBeforeCreation(item.smbUrl);
+    //make sure directory does not exist
+    QCOMPARE(smbDirBeforeCreation.exists(), false);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    //create directory using Samba
+    QCOMPARE(testRelative.mkdir(relativeName), true);
+    //make sure it exists now
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), true);
+    SmbItemInfo smbDirAfterCreation(item.smbUrl);
+    QCOMPARE(smbDirAfterCreation.exists(), true);
+
+    //directory already exists, should return true
+    QCOMPARE(testRelative.mkdir(relativeName), true);
+
+    //mkdir using absolute path
+    item = share.createPathForItem("using_absolute_path");
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemDir testAbsoluteDir;
+    QCOMPARE(testAbsoluteDir.mkdir(item.smbUrl), true);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), true);
+}
+
+
+
+void TestQSambaSuite::unit_QDir_mkpath()
+{
+     ShareCreationStatus share(createTempShare("unit_QDir_mkpath"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //create multiple paths
+    QStringList paths("path1");
+    paths.append("path2");
+    paths.append("path3");
+    //item will have smbUrl=smb://localhost/shareName/path1/path2/path3 and diskPathname=/tmp/tmpdir/path1/path2/path3
+    //using absolute path
+    SmbSharedPathAccess item =  share.createPathForItems(paths);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemDir testAbsoluteDir;
+    QCOMPARE(testAbsoluteDir.mkpath(item.smbUrl),  true);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), true);
+    //test when it already exists
+    QCOMPARE(testAbsoluteDir.mkpath(item.smbUrl),  true);
+
+    //relative paths
+    paths.clear();
+    paths.append("relative1");
+    paths.append("relative2");
+    item =  share.createPathForItems(paths);
+    SmbLocationItemDir  relativeDir(share.url);
+    QString multiplePaths = paths.join(QDir::separator());
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    QCOMPARE(relativeDir.mkpath(multiplePaths), true);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), true);
+}
+
+
+
+void TestQSambaSuite::unit_QDir_rmdir()
+{
+    ShareCreationStatus share(createTempShare("unit_QDir_rmdir"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    //negative tests
+    SmbLocationItemDir directoryEmptyName;
+    QCOMPARE(directoryEmptyName.rmdir("none"),  false);
+    QString dirName("dirName");
+    SmbSharedPathAccess item =  share.createPathForItem(dirName);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    SmbLocationItemDir directoryDoesNotExist(share.url);
+    QCOMPARE(directoryDoesNotExist.rmdir(dirName),  false);
+
+    //create a directory
+    SmbLocationItemDir   directory(share.url);
+    //create using relative
+    QCOMPARE(directory.mkdir(dirName),  true);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), true);
+    //remove the relative directory
+    QCOMPARE(directory.rmdir(dirName), true);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+    //create it again and now remove using absolute url
+    QCOMPARE(directory.mkdir(dirName),  true);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), true);
+    SmbLocationItemDir emptyObject;
+    QCOMPARE(emptyObject.rmdir(item.smbUrl), true);
+    QCOMPARE(QFileInfo(item.diskPathname).exists(), false);
+}
+
+
+void TestQSambaSuite::unit_QDirIterator_path()
+{
+    ShareCreationStatus share(createTempShare("unit_QDirIterator_path"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+    QStringList paths = QStringList() << "path1"    << "anotherPath" << "testdir"      << "passThru"   << "haha";
+    QStringList files = QStringList() << "text.txt" << "hiper.html"  << "document.odf" << "spread.odx" << "tx.list";
+
+    QStringList curPath;
+    for (int counter=0; counter < paths.count() && counter < files.count(); ++counter)
+    {
+        curPath.append(paths.at(counter));
+        SmbSharedPathAccess item =  share.createPathForItems(curPath);
+        QCOMPARE(QDir().mkpath(item.diskPathname), true);
+        QString fileFullPath = item.diskPathname + QDir::separator() + files.at(counter);
+        QFile file(fileFullPath);
+        QCOMPARE(file.open(QFile::WriteOnly),  true);
+        file.close();
+    }
+
+    QDir::Filters dirFilter = QDir::NoDotAndDotDot;
+    QDir::Filters moreFilter[] = { QDir::AllEntries,  QDir::Hidden,  QDir::System };
+
+    for (uint counter=0; counter < sizeof(moreFilter)/sizeof(moreFilter[0]); ++counter)
+    {
+        dirFilter |= moreFilter[counter];
+        QDirIterator dirIterator(share.sharedDirPath, dirFilter, QDirIterator::Subdirectories);
+        SmbLocationDirIterator smbIterator(share.url, dirFilter, QDirIterator::Subdirectories);
+        QStringList listDir;
+        QStringList listSmb;
+        qDebug() << "\n=================";
+        while (dirIterator.hasNext() && smbIterator.hasNext())
+        {
+            qDebug() << dirIterator.next()  << smbIterator.next();
+            listDir.append(dirIterator.fileName());
+            listSmb.append(smbIterator.fileName());
+        }
+        QCOMPARE(listDir, listSmb);
+    }
+}
+
+
+void TestQSambaSuite::positive_statvfs()
+{
+    ShareCreationStatus share(createTempShare("positive_statvfs"));
+    if (share.tempDir)
+    {
+        share.tempDir->setAutoRemove(true);
+    }
+    QCOMPARE(share.status, true);
+
+    struct statvfs diskVfs;
+    struct statvfs smbVfs;
+    ::memset(&diskVfs, 0, sizeof(struct statvfs));
+    ::memset(&smbVfs, 0, sizeof(struct statvfs));
+
+    //using a file that exists
+    SmbUtil smb;
+    QCOMPARE((int)smb.getStatvfsInfo(share.fileContent.smbUrl, &smbVfs), 0);
+    QCOMPARE(::statvfs(share.fileContent.diskPathname.toLocal8Bit().constData(), &diskVfs), 0);
+    QCOMPARE(smbVfs.f_blocks, diskVfs.f_blocks);
+    QCOMPARE(smbVfs.f_ffree,  diskVfs.f_ffree);
+    QCOMPARE(smbVfs.f_files,  diskVfs.f_files);
+    QCOMPARE(smbVfs.f_bsize,  diskVfs.f_bsize);
+    QVERIFY( qAbs(smbVfs.f_bfree - diskVfs.f_bfree) < 10 );
+
+    //using a directory
+    ::memset(&diskVfs, 0, sizeof(struct statvfs));
+    ::memset(&smbVfs, 0, sizeof(struct statvfs));
+    QCOMPARE((int)smb.getStatvfsInfo(share.url, &smbVfs), 0);
+    QCOMPARE(::statvfs(share.sharedDirPath.toLocal8Bit().constData(), &diskVfs), 0);
+    QCOMPARE(smbVfs.f_blocks, diskVfs.f_blocks);
+    QCOMPARE(smbVfs.f_ffree,  diskVfs.f_ffree);
+    QCOMPARE(smbVfs.f_files,  diskVfs.f_files);
+    QCOMPARE(smbVfs.f_bsize,  diskVfs.f_bsize);
+    QVERIFY( qAbs(smbVfs.f_bfree - diskVfs.f_bfree) < 10 );
+}

=== modified file 'src/plugin/folderlistmodel/smb/qsambaclient/test/testqsambasuite.h'
--- src/plugin/folderlistmodel/smb/qsambaclient/test/testqsambasuite.h	2015-07-19 16:44:54 +0000
+++ src/plugin/folderlistmodel/smb/qsambaclient/test/testqsambasuite.h	2015-07-19 16:44:54 +0000
@@ -90,6 +90,29 @@
     void negative_emptyItemInfo();
     void negative_dirIterator();
 
+private Q_SLOTS:   //unit test for SmbLocationItemFile class
+    void unit_QFile_rename();
+    void unit_QFile_remove();
+    void unit_QFile_open();
+    void unit_QFile_read();
+    void unit_QFile_write();  
+    void unit_QFile_atEnd();
+    void unit_QFile_size();
+    void unit_QFile_isOpen();
+    void unit_QFile_setPermissions();
+    void unit_QFile_permissions();
+
+private Q_SLOTS:  //unit test for SmbLocationItemDir class
+    void unit_QDir_exists();
+    void unit_QDir_mkdir();
+    void unit_QDir_mkpath();
+    void unit_QDir_rmdir();
+
+private Q_SLOTS: //unit test for SmbLocationItemDirIterator class
+    void unit_QDirIterator_path();
+
+private Q_SLOTS:
+    void positive_statvfs();
 
 protected:   
     QString createTempFile(const QString& path,