/****************************************************************************

**

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

** All rights reserved.

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

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <qcoreapplication.h>

#include <qdebug.h>

#include <qdir.h>

#include <qfileinfo.h>

#include <qregexp.h>

#include <qstringlist.h>

#include "../network-settings.h"

#if defined(Q_OS_SYMBIAN)

# define STRINGIFY(x) #x

# define TOSTRING(x) STRINGIFY(x)

# define SRCDIR "C:/Private/" TOSTRING(SYMBIAN_SRCDIR_UID) "/"

#elif defined(Q_OS_UNIX)

# include <unistd.h>

#endif

#if defined(Q_OS_VXWORKS)

#define Q_NO_SYMLINKS

#endif

#if defined(Q_OS_SYMBIAN)

// Open C in Symbian doesn't support symbolic links to directories

#define Q_NO_SYMLINKS_TO_DIRS

#endif

//TESTED_CLASS=

//TESTED_FILES=

class tst_QDir : public QObject

{

Q_OBJECT

public:

    tst_QDir();

    virtual ~tst_QDir();

private slots:

    void getSetCheck();

    void construction();

    void setPath_data();

    void setPath();

    void entryList_data();

    void entryList();

    void entryListSimple_data();

    void entryListSimple();

    void entryListWithSymLinks();

    void mkdir_data();

    void mkdir();

    void rmdir_data();

    void rmdir();

    void exists_data();

    void exists();

    void isRelativePath_data();

    void isRelativePath();

    void canonicalPath_data();

    void canonicalPath();

    void current_data();

    void current();

    void cd_data();

    void cd();

    void setNameFilters_data();

    void setNameFilters();

    void cleanPath_data();

    void cleanPath();

    void compare();

    void QDir_default();

    void filePath_data();

    void filePath();

    void absoluteFilePath_data();

    void absoluteFilePath();

    void absolutePath_data();

    void absolutePath();

    void relativeFilePath_data();

    void relativeFilePath();

    void remove();

    void rename();

    void exists2_data();

    void exists2();

    void dirName_data();

    void dirName();

    void operator_eq();

    void dotAndDotDot();

#ifdef QT3_SUPPORT

    void matchAllDirs();

#endif

    void homePath();

    void tempPath();

    void rootPath();

    void nativeSeparators();

    void searchPaths();

    void searchPaths_data();

    void entryListWithSearchPaths();

    void longFileName_data();

    void longFileName();

};

// Testing get/set functions

void tst_QDir::getSetCheck()

{

    QDir obj1;

    // Filters QDir::filter()

    // void QDir::setFilter(Filters)

    obj1.setFilter(QDir::Filters(QDir::Dirs));

    QCOMPARE(QDir::Filters(QDir::Dirs), obj1.filter());

    obj1.setFilter(QDir::Filters(QDir::Dirs | QDir::Files));

    QCOMPARE(QDir::Filters(QDir::Dirs | QDir::Files), obj1.filter());

    obj1.setFilter(QDir::Filters(QDir::NoFilter));

    QCOMPARE(QDir::Filters(QDir::NoFilter), obj1.filter());

    // SortFlags QDir::sorting()

    // void QDir::setSorting(SortFlags)

    obj1.setSorting(QDir::SortFlags(QDir::Name));

    QCOMPARE(QDir::SortFlags(QDir::Name), obj1.sorting());

    obj1.setSorting(QDir::SortFlags(QDir::Name | QDir::IgnoreCase));

    QCOMPARE(QDir::SortFlags(QDir::Name | QDir::IgnoreCase), obj1.sorting());

    obj1.setSorting(QDir::SortFlags(QDir::NoSort));

    QCOMPARE(QDir::SortFlags(QDir::NoSort), obj1.sorting());

}

tst_QDir::tst_QDir()

{

#ifdef Q_OS_SYMBIAN

    // Can't deploy empty test dir, so create it here

    QDir dir(SRCDIR);

    dir.mkdir("testData");

#endif

}

tst_QDir::~tst_QDir()

{

#ifdef Q_OS_SYMBIAN

    // Remove created test dir

    QDir dir(SRCDIR);

    dir.rmdir("testData");

#endif

}

void tst_QDir::construction()

{

    QFileInfo myFileInfo("/machine/share/dir1/file1");

    QDir myDir(myFileInfo.absoluteDir()); // this asserted

    QCOMPARE(myFileInfo.absoluteDir().absolutePath(), myDir.absolutePath());

}

void tst_QDir::setPath_data()

{

    QTest::addColumn<QString>("dir1");

    QTest::addColumn<QString>("dir2");

    QTest::newRow("data0") << QString(".") << QString("..");

#if (defined(Q_WS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN)

    QTest::newRow("data1") << QString("c:/") << QDir::currentPath();

#endif

}

void tst_QDir::setPath()

{

    QFETCH(QString, dir1);

    QFETCH(QString, dir2);

    QDir shared;

    QDir qDir1(dir1);

    QStringList entries1 = qDir1.entryList();

    shared.setPath(dir1);

    QCOMPARE(shared.entryList(), entries1);

    QDir qDir2(dir2);

    QStringList entries2 = qDir2.entryList();

    shared.setPath(dir2);

    QCOMPARE(shared.entryList(), entries2);

}

void tst_QDir::mkdir_data()

{

    QTest::addColumn<QString>("path");

    QTest::addColumn<bool>("recurse");

    QStringList dirs;

    dirs << QDir::currentPath() + "/testdir/one/two/three"

         << QDir::currentPath() + "/testdir/two"

         << QDir::currentPath() + "/testdir/two/three";

    QTest::newRow("data0") << dirs.at(0) << true;

    QTest::newRow("data1") << dirs.at(1) << false;

    QTest::newRow("data2") << dirs.at(2) << false;

    // Ensure that none of these directories already exist

    QDir dir;

    for (int i = 0; i < dirs.count(); ++i)

        dir.rmpath(dirs.at(i));

}

void tst_QDir::mkdir()

{

    QFETCH(QString, path);

    QFETCH(bool, recurse);

    QDir dir;

    dir.rmdir(path);

    if (recurse)

        QVERIFY(dir.mkpath(path));

    else

        QVERIFY(dir.mkdir(path));

    //make sure it really exists (ie that mkdir returns the right value)

    QFileInfo fi(path);

    QVERIFY(fi.exists() && fi.isDir());

}

void tst_QDir::rmdir_data()

{

    QTest::addColumn<QString>("path");

    QTest::addColumn<bool>("recurse");

    QTest::newRow("data0") << QDir::currentPath() + "/testdir/one/two/three" << true;

    QTest::newRow("data1") << QDir::currentPath() + "/testdir/two/three" << false;

    QTest::newRow("data2") << QDir::currentPath() + "/testdir/two" << false;

}

void tst_QDir::rmdir()

{

    QFETCH(QString, path);

    QFETCH(bool, recurse);

    QDir dir;

    if (recurse)

        QVERIFY(dir.rmpath(path));

    else

        QVERIFY(dir.rmdir(path));

    //make sure it really doesn't exist (ie that rmdir returns the right value)

    QFileInfo fi(path);

    QVERIFY(!fi.exists());

}

void tst_QDir::exists_data()

{

    QTest::addColumn<QString>("path");

    QTest::addColumn<bool>("expected");

    QTest::newRow("data0") << QDir::currentPath() << true;

    QTest::newRow("data0.1") << QDir::currentPath() + "/" << true;

    QTest::newRow("data1") << QString("/I/Do_not_expect_this_path_to_exist/") << false;

    QTest::newRow("resource0") << QString(":/tst_qdir/") << true;

    QTest::newRow("resource1") << QString(":/I/Do_not_expect_this_resource_to_exist/") << false;

    QTest::newRow("simple dir") << SRCDIR "resources" << true;

    QTest::newRow("simple dir with slash") << SRCDIR "resources/" << true;

#if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE))

    QTest::newRow("unc 1") << "//" + QtNetworkSettings::winServerName() << true;

    QTest::newRow("unc 2") << "//"  + QtNetworkSettings::winServerName() + "/" << true;

    QTest::newRow("unc 3") << "//"  + QtNetworkSettings::winServerName() + "/testshare" << true;

    QTest::newRow("unc 4") << "//"  + QtNetworkSettings::winServerName() + "/testshare/" << true;

    QTest::newRow("unc 5") << "//"  + QtNetworkSettings::winServerName() + "/testshare/tmp" << true;

    QTest::newRow("unc 6") << "//"  + QtNetworkSettings::winServerName() + "/testshare/tmp/" << true;

    QTest::newRow("unc 7") << "//"  + QtNetworkSettings::winServerName() + "/testshare/adirthatshouldnotexist" << false;

    QTest::newRow("unc 8") << "//"  + QtNetworkSettings::winServerName() + "/asharethatshouldnotexist" << false;

    QTest::newRow("unc 9") << "//ahostthatshouldnotexist" << false;

#endif

#if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN)

    QTest::newRow("This drive should exist") <<  "C:/" << true;

    // find a non-existing drive and check if it does not exist

    QFileInfoList drives = QFSFileEngine::drives();

    QStringList driveLetters;

    for (int i = 0; i < drives.count(); ++i) {

        driveLetters+=drives.at(i).absoluteFilePath();

    }

    char drive = 'Z';

    QString driv;

    do {

        driv = QString::fromAscii("%1:/").arg(drive);

        if (!driveLetters.contains(driv)) break;

        --drive;

    } while (drive >= 'A');

    if (drive >= 'A') {

        QTest::newRow("This drive should not exist") <<  driv << false;

    }

#endif

}

void tst_QDir::exists()

{

    QFETCH(QString, path);

    QFETCH(bool, expected);

    QDir dir(path);

    QCOMPARE(dir.exists(), expected);

}

void tst_QDir::isRelativePath_data()

{

    QTest::addColumn<QString>("path");

    QTest::addColumn<bool>("relative");

    QTest::newRow("data0") << "../somedir" << true;

#if (defined(Q_WS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN)

    QTest::newRow("data1") << "C:/sOmedir" << false;

#endif

    QTest::newRow("data2") << "somedir" << true;

    QTest::newRow("data3") << "/somedir" << false;

}

void tst_QDir::isRelativePath()

{

    QFETCH(QString, path);

    QFETCH(bool, relative);

    QCOMPARE(QDir::isRelativePath(path),relative);

}

void tst_QDir::QDir_default()

{

    //default constructor QDir();

    QDir dir; // according to documentation should be currentDirPath

    QCOMPARE(dir.absolutePath(), QDir::currentPath());

}

void tst_QDir::compare()

{

    // operator==

    QDir dir;

    dir.makeAbsolute();

    QVERIFY(dir == QDir::currentPath());

}

static QStringList filterLinks(const QStringList &list)

{

#ifndef Q_NO_SYMLINKS

    return list;

#else

    QStringList result;

    foreach (QString str, list) {

        if (!str.endsWith(QLatin1String(".lnk")))

            result.append(str);

    }

    return result;

#endif

}

void tst_QDir::entryList_data()

{

    QTest::addColumn<QString>("dirName"); // relative from current path or abs

    QTest::addColumn<QStringList>("nameFilters");

    QTest::addColumn<int>("filterspec");

    QTest::addColumn<int>("sortspec");

    QTest::addColumn<QStringList>("expected");

    QTest::newRow("spaces1") << SRCDIR "testdir/spaces" << QStringList("*. bar")

              << (int)(QDir::NoFilter) << (int)(QDir::NoSort)

              << QStringList("foo. bar"); // notice how spaces5 works

    QTest::newRow("spaces2") << SRCDIR "testdir/spaces" << QStringList("*.bar")

              << (int)(QDir::NoFilter) << (int)(QDir::NoSort)

              << QStringList("foo.bar");

    QTest::newRow("spaces3") << SRCDIR "testdir/spaces" << QStringList("foo.*")

              << (int)(QDir::NoFilter) << (int)(QDir::NoSort)

              << QString("foo. bar,foo.bar").split(',');

    QTest::newRow("files1")  << SRCDIR "testdir/dir" << QString("*r.cpp *.pro").split(" ")

              << (int)(QDir::NoFilter) << (int)(QDir::NoSort)

              << QString("qdir.pro,qrc_qdir.cpp,tst_qdir.cpp").split(',');

    QTest::newRow("testdir1")  << SRCDIR "testdir" << QStringList()

              << (int)(QDir::AllDirs) << (int)(QDir::NoSort)

              << QString(".,..,dir,spaces").split(',');

// #### this test uses filenames that cannot be represented on all filesystems we test, in

// particular HFS+ on the Mac. When checking out the files with perforce it silently ignores the

// error that it cannot represent the file names stored in the repository and the test fails. That

// is why the test is marked as 'skip' for the mac. When checking out the files with git on the mac

// the error of not being able to represent the files stored in the repository is not silently

// ignored but git reports an error. The test only tried to prevent QDir from _hanging_ when listing

// the directory.

//    QTest::newRow("unprintablenames")  << SRCDIR "unprintablenames" << QStringList("*")

//              << (int)(QDir::NoFilter) << (int)(QDir::NoSort)

//              << QString(".,..").split(",");

    QTest::newRow("resources1") << QString(":/tst_qdir/resources/entryList") << QStringList("*.data")

                             << (int)(QDir::NoFilter) << (int)(QDir::NoSort)

                             << QString("file1.data,file2.data,file3.data").split(',');

    QTest::newRow("resources2") << QString(":/tst_qdir/resources/entryList") << QStringList("*.data")

                             << (int)(QDir::Files) << (int)(QDir::NoSort)

                             << QString("file1.data,file2.data,file3.data").split(',');

    QTest::newRow("nofilter") << SRCDIR "entrylist/" << QStringList("*")

                              << int(QDir::NoFilter) << int(QDir::Name)

                              << filterLinks(QString(".,..,directory,file,linktodirectory.lnk,linktofile.lnk,writable").split(','));

    QTest::newRow("QDir::AllEntries") << SRCDIR "entrylist/" << QStringList("*")

                              << int(QDir::AllEntries) << int(QDir::Name)

                              << filterLinks(QString(".,..,directory,file,linktodirectory.lnk,linktofile.lnk,writable").split(','));

    QTest::newRow("QDir::Files") << SRCDIR "entrylist/" << QStringList("*")

                                 << int(QDir::Files) << int(QDir::Name)

                                 << filterLinks(QString("file,linktofile.lnk,writable").split(','));

    QTest::newRow("QDir::Dirs") << SRCDIR "entrylist/" << QStringList("*")

                                << int(QDir::Dirs) << int(QDir::Name)

                                << filterLinks(QString(".,..,directory,linktodirectory.lnk").split(','));

    QTest::newRow("QDir::Dirs | QDir::NoDotAndDotDot") << SRCDIR "entrylist/" << QStringList("*")

                                                       << int(QDir::Dirs | QDir::NoDotAndDotDot) << int(QDir::Name)

                                << filterLinks(QString("directory,linktodirectory.lnk").split(','));

    QTest::newRow("QDir::AllDirs") << SRCDIR "entrylist/" << QStringList("*")

                                   << int(QDir::AllDirs) << int(QDir::Name)

                                   << filterLinks(QString(".,..,directory,linktodirectory.lnk").split(','));

    QTest::newRow("QDir::AllDirs | QDir::Dirs") << SRCDIR "entrylist/" << QStringList("*")

                                                << int(QDir::AllDirs | QDir::Dirs) << int(QDir::Name)

                                                << filterLinks(QString(".,..,directory,linktodirectory.lnk").split(','));

    QTest::newRow("QDir::AllDirs | QDir::Files") << SRCDIR "entrylist/" << QStringList("*")

                                                 << int(QDir::AllDirs | QDir::Files) << int(QDir::Name)

                                                 << filterLinks(QString(".,..,directory,file,linktodirectory.lnk,linktofile.lnk,writable").split(','));

    QTest::newRow("QDir::AllEntries | QDir::NoSymLinks") << SRCDIR "entrylist/" << QStringList("*")

                                      << int(QDir::AllEntries | QDir::NoSymLinks) << int(QDir::Name)

                                      << filterLinks(QString(".,..,directory,file,writable").split(','));

    QTest::newRow("QDir::AllEntries | QDir::NoSymLinks | QDir::NoDotAndDotDot") << SRCDIR "entrylist/" << QStringList("*")

                                      << int(QDir::AllEntries | QDir::NoSymLinks | QDir::NoDotAndDotDot) << int(QDir::Name)

                                      << filterLinks(QString("directory,file,writable").split(','));

    QTest::newRow("QDir::Files | QDir::NoSymLinks") << SRCDIR "entrylist/" << QStringList("*")

                                                    << int(QDir::Files | QDir::NoSymLinks) << int(QDir::Name)

                                                    << filterLinks(QString("file,writable").split(','));

    QTest::newRow("QDir::Dirs | QDir::NoSymLinks") << SRCDIR "entrylist/" << QStringList("*")

                                                   << int(QDir::Dirs | QDir::NoSymLinks) << int(QDir::Name)

                                                   << filterLinks(QString(".,..,directory").split(','));

    QTest::newRow("QDir::Drives | QDir::Files | QDir::NoDotAndDotDot") << SRCDIR "entrylist/" << QStringList("*")

                                                   << int(QDir::Drives | QDir::Files | QDir::NoDotAndDotDot) << int(QDir::Name)

                                                   << filterLinks(QString("file,linktofile.lnk,writable").split(','));

    QTest::newRow("QDir::System") << SRCDIR "entrylist/" << QStringList("*")

                                  << int(QDir::System) << int(QDir::Name)

                                  << filterLinks(QStringList("brokenlink.lnk"));

    QTest::newRow("QDir::Hidden") << SRCDIR "entrylist/" << QStringList("*")

                                  << int(QDir::Hidden) << int(QDir::Name)

                                  << QStringList();

    QTest::newRow("QDir::System | QDir::Hidden") << SRCDIR "entrylist/" << QStringList("*")

                                  << int(QDir::System | QDir::Hidden) << int(QDir::Name)

                                  << filterLinks(QStringList("brokenlink.lnk"));

    QTest::newRow("QDir::AllDirs | QDir::NoSymLinks") << SRCDIR "entrylist/" << QStringList("*")

                                                      << int(QDir::AllDirs | QDir::NoSymLinks) << int(QDir::Name)

                                                      << filterLinks(QString(".,..,directory").split(','));

#ifdef QT3_SUPPORT

    QTest::newRow("QDir::All | QDir::Hidden | QDir::System") << SRCDIR "entrylist/" << QStringList("*")

                                  << int(QDir::All | QDir::Hidden | QDir::System) << int(QDir::Name)

                                  << filterLinks(QString(".,..,brokenlink.lnk,directory,file,linktodirectory.lnk,linktofile.lnk,writable").split(','));

    QTest::newRow("QDir::All | QDir::Readable") << SRCDIR "entrylist/" << QStringList("*")

                                  << int(QDir::All | QDir::Readable) << int(QDir::Name)

                                                << filterLinks(QString(".,..,directory,file,linktodirectory.lnk,linktofile.lnk,writable").split(','));

    QTest::newRow("QDir::All | QDir::Writable") << SRCDIR "entrylist/" << QStringList("*")

                                  << int(QDir::All | QDir::Writable) << int(QDir::Name)

                                  << filterLinks(QString(".,..,directory,linktodirectory.lnk,writable").split(','));

#else

    QTest::newRow("QDir::AllEntries | QDir::Hidden | QDir::System") << SRCDIR "entrylist/" << QStringList("*")

                                  << int(QDir::AllEntries | QDir::Hidden | QDir::System) << int(QDir::Name)

                                  << filterLinks(QString(".,..,brokenlink.lnk,directory,file,linktodirectory.lnk,linktofile.lnk,writable").split(','));

    QTest::newRow("QDir::AllEntries | QDir::Readable") << SRCDIR "entrylist/" << QStringList("*")

                                  << int(QDir::AllEntries | QDir::Readable) << int(QDir::Name)

                                                << filterLinks(QString(".,..,directory,file,linktodirectory.lnk,linktofile.lnk,writable").split(','));

    QTest::newRow("QDir::AllEntries | QDir::Writable") << SRCDIR "entrylist/" << QStringList("*")

                                  << int(QDir::AllEntries | QDir::Writable) << int(QDir::Name)

                                  << filterLinks(QString(".,..,directory,linktodirectory.lnk,writable").split(','));

#endif

    QTest::newRow("Namefilters b*") << SRCDIR "entrylist/" << QStringList("d*")

                                  << int(QDir::NoFilter) << int(QDir::Name)

                                  << filterLinks(QString("directory").split(','));

    QTest::newRow("Namefilters f*") << SRCDIR "entrylist/" << QStringList("f*")

                                  << int(QDir::NoFilter) << int(QDir::Name)

                                  << filterLinks(QString("file").split(','));