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

**

** 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 "../../../src/gui/dialogs/qfilesystemmodel_p.h"

#include <QFileIconProvider>

#include <QTreeView>

#include <QHeaderView>

#include "../../shared/util.h"

#include <QTime>

#include <QStyle>

#include <QtGlobal>

#if defined(Q_OS_SYMBIAN)

# include <f32file.h>

#endif

//TESTED_CLASS=

//TESTED_FILES=

#define WAITTIME 1000

// Will try to wait for the condition while allowing event processing

// for a maximum of 5 seconds.

#define TRY_WAIT(expr) \

    do { \

        const int step = 50; \

        for (int __i = 0; __i < 5000 && !(expr); __i+=step) { \

            QTest::qWait(step); \

        } \

    } while(0)

#if defined(Q_OS_SYMBIAN)

static HBufC* qt_QString2HBufCNewL(const QString& aString)

{

    HBufC *buffer;

#ifdef QT_NO_UNICODE

    TPtrC8 ptr(reinterpret_cast<const TUint8*>(aString.toLocal8Bit().constData()));

    buffer = HBufC8::NewL(ptr.Length());

    buffer->Des().Copy(ptr);

#else

    TPtrC16 ptr(reinterpret_cast<const TUint16*>(aString.utf16()));

    buffer = HBufC16::NewL(ptr.Length());

    buffer->Des().Copy(ptr);

#endif

    return buffer;

}

#endif

class tst_QFileSystemModel : public QObject {

  Q_OBJECT

public:

    tst_QFileSystemModel();

    virtual ~tst_QFileSystemModel();

public Q_SLOTS:

    void init();

    void cleanup();

private slots:

    void indexPath();

    void rootPath();

    void naturalCompare_data();

    void naturalCompare();

    void readOnly();

    void iconProvider();

    void rowCount();

    void rowsInserted_data();

    void rowsInserted();

    void rowsRemoved_data();

    void rowsRemoved();

    void dataChanged_data();

    void dataChanged();

    void filters_data();

    void filters();

    void nameFilters();

    void setData_data();

    void setData();

    void sort_data();

    void sort();

    void mkdir();

    void caseSensitivity();

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

    void Win32LongFileName();

#endif

    void drives_data();

    void drives();

    void dirsBeforeFiles();

protected:

    bool createFiles(const QString &test_path, const QStringList &initial_files, int existingFileCount = 0, const QStringList &intial_dirs = QStringList(), const QString &baseDir = QDir::temp().absolutePath());

private:

    QFileSystemModel *model;

    QString flatDirTestPath;

#if defined(Q_OS_SYMBIAN)

    RFs rfs;

#endif

};

tst_QFileSystemModel::tst_QFileSystemModel() : model(0)

{

    qRegisterMetaType<QModelIndex>("QModelIndex");

    QTime midnight(0, 0, 0);

    qsrand(midnight.secsTo(QTime::currentTime()));

    // generating unique temporary directory name

    flatDirTestPath = QDir::temp().path() + '/' + QString("flatdirtest.") + QString::number(qrand());

#if defined(Q_OS_SYMBIAN)

    rfs.Connect();

#endif

}

tst_QFileSystemModel::~tst_QFileSystemModel()

{

#if defined(Q_OS_SYMBIAN)

    rfs.Close();

#endif

    QString tmp = flatDirTestPath;

    QDir dir(tmp);

    if (dir.exists() && !dir.rmdir(tmp))

        qWarning("failed to remove tmp dir %s", dir.dirName().toAscii().data());

}

void tst_QFileSystemModel::init()

{

    cleanup();

    QCOMPARE(model, (QFileSystemModel*)0);

    model = new QFileSystemModel;

}

void tst_QFileSystemModel::cleanup()

{

    delete model;

    model = 0;

    QString tmp = flatDirTestPath;

    QDir dir(tmp);

    if (dir.exists(tmp)) {

        QStringList list = dir.entryList(QDir::AllEntries | QDir::System | QDir::Hidden | QDir::NoDotAndDotDot);

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

            QFileInfo fi(dir.path() + '/' + list.at(i));

            if (fi.exists() && fi.isFile()) {

		        QFile p(fi.absoluteFilePath());

                p.setPermissions(QFile::ReadUser | QFile::ReadOwner | QFile::ExeOwner | QFile::ExeUser | QFile::WriteUser | QFile::WriteOwner | QFile::WriteOther);

		        QFile dead(dir.path() + '/' + list.at(i));

		        dead.remove();

	        }

	        if (fi.exists() && fi.isDir())

                QVERIFY(dir.rmdir(list.at(i)));

        }

        list = dir.entryList(QDir::AllEntries | QDir::System | QDir::Hidden | QDir::NoDotAndDotDot);

        QVERIFY(list.count() == 0);

    }

}

void tst_QFileSystemModel::indexPath()

{

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

    int depth = QDir::currentPath().count('/');

    model->setRootPath(QDir::currentPath());

    QTest::qWait(WAITTIME);

    QString backPath;

    for (int i = 0; i <= depth * 2 + 1; ++i) {

        backPath += "../";

        QModelIndex idx = model->index(backPath);

        QVERIFY(i != depth - 1 ? idx.isValid() : !idx.isValid());

    }

    QTest::qWait(WAITTIME * 3);

    qApp->processEvents();

#endif

}

void tst_QFileSystemModel::rootPath()

{

    QCOMPARE(model->rootPath(), QString(QDir().path()));

    QSignalSpy rootChanged(model, SIGNAL(rootPathChanged(const QString &)));

    QModelIndex root = model->setRootPath(model->rootPath());

    root = model->setRootPath("this directory shouldn't exist");

    QCOMPARE(rootChanged.count(), 0);

    QString oldRootPath = model->rootPath();

    root = model->setRootPath(QDir::homePath());

    QTRY_VERIFY(model->rowCount(root) >= 0);

    QCOMPARE(model->rootPath(), QString(QDir::homePath()));

    QCOMPARE(rootChanged.count(), oldRootPath == model->rootPath() ? 0 : 1);

    QCOMPARE(model->rootDirectory().absolutePath(), QDir::homePath());

}

void tst_QFileSystemModel::naturalCompare_data()

{

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

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

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

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

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

    for (int j = 0; j < 4; ++j) { // <- set a prefix and a postfix string (not numbers)

        QString prefix = (j == 0 || j == 1) ? "b" : "";

        QString postfix = (j == 1 || j == 2) ? "y" : "";

        for (int k = 0; k < 3; ++k) { // <- make 0 not a special case

            QString num = QString("%1").arg(k);

            QString nump = QString("%1").arg(k + 1);

            for (int i = 10; i < 12; ++i) { // <- swap s1 and s2 and reverse the result

                QTest::newRow("basic") << prefix + "0" + postfix << prefix + "0" + postfix << int(Qt::CaseInsensitive) << 0;

                // s1 should always be less then s2

                QTest::newRow("just text")    << prefix + "fred" + postfix     << prefix + "jane" + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("just numbers") << prefix + num + postfix        << prefix + "9" + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("zero")         << prefix + num + postfix        << prefix + "0" + nump + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("space b")      << prefix + num + postfix        << prefix + " " + nump + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("space a")      << prefix + num + postfix        << prefix + nump + " " + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("tab b")        << prefix + num + postfix        << prefix + "    " + nump + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("tab a")        << prefix + num + postfix        << prefix + nump + "   " + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("10 vs 2")      << prefix + num + postfix        << prefix + "10" + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("diff len")     << prefix + num + postfix        << prefix + nump + postfix + "x" << int(Qt::CaseInsensitive) << i;

                QTest::newRow("01 before 1")  << prefix + "0" + num + postfix  << prefix + nump + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("mul nums 2nd") << prefix + "1-" + num + postfix << prefix + "1-" + nump + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("mul nums 2nd") << prefix + "10-" + num + postfix<< prefix + "10-10" + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("mul nums 2nd") << prefix + "10-0"+ num + postfix<< prefix + "10-10" + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("mul nums 2nd") << prefix + "10-" + num + postfix<< prefix + "10-010" + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("mul nums big") << prefix + "10-" + num + postfix<< prefix + "20-0" + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("mul nums big") << prefix + "2-" + num + postfix << prefix + "10-0" + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("mul alphabet") << prefix + num + "-a" + postfix << prefix + num + "-c" + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("mul alphabet2")<< prefix + num + "-a9" + postfix<< prefix + num + "-c0" + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("mul nums w\\0")<< prefix + num + "-"+ num + postfix<< prefix + num+"-0"+nump + postfix << int(Qt::CaseInsensitive) << i;

                QTest::newRow("num first")    << prefix + num + postfix  << prefix + "a" + postfix << int(Qt::CaseInsensitive) << i;

            }

        }

    }

}

void tst_QFileSystemModel::naturalCompare()

{

#ifdef QT_BUILD_INTERNAL

    QFETCH(QString, s1);

    QFETCH(QString, s2);

    QFETCH(int, caseSensitive);

    QFETCH(int, result);

    if (result == 10)

        QCOMPARE(QFileSystemModelPrivate::naturalCompare(s1, s2, Qt::CaseSensitivity(caseSensitive)), -1);

    else

        if (result == 11)

            QCOMPARE(QFileSystemModelPrivate::naturalCompare(s2, s1, Qt::CaseSensitivity(caseSensitive)), 1);

    else

        QCOMPARE(QFileSystemModelPrivate::naturalCompare(s2, s1, Qt::CaseSensitivity(caseSensitive)), result);

#if defined(Q_OS_WINCE)

    // On Windows CE we need to wait after each test, otherwise no new threads can be

    // created. The scheduler takes its time to recognize ended threads.

    QTest::qWait(300);

#endif

#endif

}

void tst_QFileSystemModel::readOnly()

{

    QCOMPARE(model->isReadOnly(), true);

    QTemporaryFile file;

    file.open();

    QModelIndex root = model->setRootPath(QDir::tempPath());

    QTRY_VERIFY(model->rowCount(root) > 0);

    QVERIFY(!(model->flags(model->index(file.fileName())) & Qt::ItemIsEditable));

    model->setReadOnly(false);

    QCOMPARE(model->isReadOnly(), false);

    QVERIFY(model->flags(model->index(file.fileName())) & Qt::ItemIsEditable);

}

class CustomFileIconProvider : public QFileIconProvider

{

public:

    CustomFileIconProvider() : QFileIconProvider() {

        mb = qApp->style()->standardIcon(QStyle::SP_MessageBoxCritical);

        dvd = qApp->style()->standardIcon(QStyle::SP_DriveDVDIcon);

    }

    virtual QIcon icon(const QFileInfo &info) const

    {

        if (info.isDir())

            return mb;

        return QFileIconProvider::icon(info);

    }

    virtual QIcon icon(IconType type) const

    {

        if (type == QFileIconProvider::Folder)

            return dvd;

        return QFileIconProvider::icon(type);

    }

private:

    QIcon mb;

    QIcon dvd;

};

void tst_QFileSystemModel::iconProvider()

{

    QVERIFY(model->iconProvider());

    QFileIconProvider *p = new QFileIconProvider();

    model->setIconProvider(p);

    QCOMPARE(model->iconProvider(), p);

    model->setIconProvider(0);

    delete p;

    QFileSystemModel *myModel = new QFileSystemModel();

    myModel->setRootPath(QDir::homePath());

    //Let's wait to populate the model

    QTest::qWait(250);

    //We change the provider, icons must me updated

    CustomFileIconProvider *custom = new CustomFileIconProvider();

    myModel->setIconProvider(custom);

    QPixmap mb = qApp->style()->standardIcon(QStyle::SP_MessageBoxCritical).pixmap(50, 50);

    QCOMPARE(myModel->fileIcon(myModel->index(QDir::homePath())).pixmap(50, 50), mb);

    delete myModel;

    delete custom;

}

bool tst_QFileSystemModel::createFiles(const QString &test_path, const QStringList &initial_files, int existingFileCount, const QStringList &initial_dirs, const QString &dir)

{

    QDir baseDir(dir);

    if (!baseDir.exists(test_path)) {

        if (!baseDir.mkdir(test_path) && false) {

            qDebug() << "failed to create dir" << test_path;

            return false;

        }

    }

    //qDebug() << (model->rowCount(model->index(test_path))) << existingFileCount << initial_files;

    TRY_WAIT((model->rowCount(model->index(test_path)) == existingFileCount));

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

        QDir dir(test_path);

        if (!dir.exists()) {

            qWarning() << "error" << test_path << "doesn't exists";

            return false;

        }

        if(!dir.mkdir(initial_dirs.at(i))) {

            qWarning() << "error" << "failed to make" << initial_dirs.at(i);

            return false;

        }

        //qDebug() << test_path + '/' + initial_dirs.at(i) << (QFile::exists(test_path + '/' + initial_dirs.at(i)));

    }

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

        QFile file(test_path + '/' + initial_files.at(i));

        if (!file.open(QIODevice::WriteOnly | QIODevice::Append)) {

            qDebug() << "failed to open file" << initial_files.at(i);

            return false;

        }

        if (!file.resize(1024 + file.size())) {

            qDebug() << "failed to resize file" << initial_files.at(i);

            return false;

        }

        if (!file.flush()) {

            qDebug() << "failed to flush file" << initial_files.at(i);

            return false;

        }

        file.close();

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

        if (initial_files.at(i)[0] == '.')

            QProcess::execute(QString("attrib +h %1").arg(file.fileName()));

#elif defined(Q_OS_SYMBIAN)

        if (initial_files.at(i)[0] == '.') {

            HBufC* buffer = qt_QString2HBufCNewL(QDir::toNativeSeparators(file.fileName()));

            rfs.SetAtt(*buffer, KEntryAttHidden, 0);

            delete buffer;

            }

#endif

        //qDebug() << test_path + '/' + initial_files.at(i) << (QFile::exists(test_path + '/' + initial_files.at(i)));

    }

    return true;

}

void tst_QFileSystemModel::rowCount()

{

    QString tmp = flatDirTestPath;

    QVERIFY(createFiles(tmp, QStringList()));

    QSignalSpy spy2(model, SIGNAL(rowsInserted(const QModelIndex &, int, int)));

    QSignalSpy spy3(model, SIGNAL(rowsAboutToBeInserted(const QModelIndex &, int, int)));

#if !defined(Q_OS_WINCE)

    QStringList files = QStringList() <<  "b" << "d" << "f" << "h" << "j" << ".a" << ".c" << ".e" << ".g";

    QString l = "b,d,f,h,j,.a,.c,.e,.g";

#else

    // Cannot hide them on CE

    QStringList files = QStringList() <<  "b" << "d" << "f" << "h" << "j";

    QString l = "b,d,f,h,j";

#endif

    QVERIFY(createFiles(tmp, files));

    QModelIndex root = model->setRootPath(tmp);

    QTRY_COMPARE(model->rowCount(root), 5);

    QVERIFY(spy2.count() > 0);

    QVERIFY(spy3.count() > 0);

}

void tst_QFileSystemModel::rowsInserted_data()

{

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

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

    for (int i = 0; i < 4; ++i) {

        QTest::newRow(QString("Qt::AscendingOrder %1").arg(i).toLocal8Bit().constData())  << i << (int)Qt::AscendingOrder;

        QTest::newRow(QString("Qt::DescendingOrder %1").arg(i).toLocal8Bit().constData()) << i << (int)Qt::DescendingOrder;

    }

}

void tst_QFileSystemModel::rowsInserted()

{

#if defined(Q_OS_WINCE)

    QSKIP("Watching directories does not work on CE(see #137910)", SkipAll);

#endif

    QString tmp = flatDirTestPath;

    rowCount();

    QModelIndex root = model->index(model->rootPath());

    QFETCH(int, assending);

    QFETCH(int, count);

    model->sort(0, (Qt::SortOrder)assending);

    QSignalSpy spy0(model, SIGNAL(rowsInserted(const QModelIndex &, int, int)));

    QSignalSpy spy1(model, SIGNAL(rowsAboutToBeInserted(const QModelIndex &, int, int)));

    int oldCount = model->rowCount(root);

    QStringList files;

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

        files.append(QString("c%1").arg(i));

    QVERIFY(createFiles(tmp, files, 5));

    TRY_WAIT(model->rowCount(root) == oldCount + count);

    QTRY_COMPARE(model->rowCount(root), oldCount + count);

    QTest::qWait(100); // Let the sort settle.

    int totalRowsInserted = 0;

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

        int start = spy0[i].value(1).toInt();

        int end = spy0[i].value(2).toInt();

        totalRowsInserted += end - start + 1;

    }

    QCOMPARE(totalRowsInserted, count);

    if (assending == (Qt::SortOrder)Qt::AscendingOrder) {

        QString letter = model->index(model->rowCount(root) - 1, 0, root).data().toString();

        QCOMPARE(letter, QString("j"));

    } else {

        QCOMPARE(model->index(model->rowCount(root) - 1, 0, root).data().toString(), QString("b"));

    }

    if (spy0.count() > 0) {

        if (count == 0)

            QCOMPARE(spy0.count(), 0);

        else

            QVERIFY(spy0.count() >= 1);

    }

    if (count == 0) QCOMPARE(spy1.count(), 0); else QVERIFY(spy1.count() >= 1);

    QVERIFY(createFiles(tmp, QStringList(".hidden_file"), 5 + count));

    if (count != 0) QTRY_VERIFY(spy0.count() >= 1); else QTRY_VERIFY(spy0.count() == 0);

    if (count != 0) QTRY_VERIFY(spy1.count() >= 1); else QTRY_VERIFY(spy1.count() == 0);

}

void tst_QFileSystemModel::rowsRemoved_data()

{

    rowsInserted_data();

}

void tst_QFileSystemModel::rowsRemoved()

{

#if defined(Q_OS_WINCE)

    QSKIP("Watching directories does not work on CE(see #137910)", SkipAll);

#endif

    QString tmp = flatDirTestPath;

    rowCount();

    QModelIndex root = model->index(model->rootPath());

    QFETCH(int, count);

    QFETCH(int, assending);

    model->sort(0, (Qt::SortOrder)assending);

    QTest::qWait(WAITTIME);

    QSignalSpy spy0(model, SIGNAL(rowsRemoved(const QModelIndex &, int, int)));

    QSignalSpy spy1(model, SIGNAL(rowsAboutToBeRemoved(const QModelIndex &, int, int)));