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

**

** 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 <qplatformdefs.h>

#include <QAbstractFileEngine>

#include <QFSFileEngine>

#include <QCoreApplication>

#include <QDebug>

#include <QDir>

#include <QFile>

#include <QFileInfo>

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

#include <QHostInfo>

#endif

#include <QProcess>

#ifndef Q_OS_WIN

# include <sys/types.h>

# include <unistd.h>

#endif

#ifdef Q_OS_MAC

# include <sys/mount.h>

#elif defined(Q_OS_LINUX)

# include <sys/vfs.h>

#elif defined(Q_OS_FREEBSD)

# include <sys/param.h>

# include <sys/mount.h>

#elif defined(Q_OS_IRIX)

# include <sys/statfs.h>

#elif defined(Q_OS_WINCE)

# include <qplatformdefs.h>

# include <private/qfsfileengine_p.h>

#endif

#include <stdio.h>

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

#if defined(Q_OS_SYMBIAN)

# define SRCDIR ""

#endif

#ifndef STDIN_FILENO

#define STDIN_FILENO 0

#endif

#ifndef STDOUT_FILENO

#define STDOUT_FILENO 1

#endif

#ifndef STDERR_FILENO

#define STDERR_FILENO 2

#endif

#ifndef QT_OPEN_BINARY

#define QT_OPEN_BINARY 0

#endif

Q_DECLARE_METATYPE(QFile::FileError)

//TESTED_CLASS=

//TESTED_FILES=

class tst_QFile : public QObject

{

    Q_OBJECT

public:

    tst_QFile();

    virtual ~tst_QFile();

public slots:

    void init();

    void cleanup();

private slots:

    void initTestCase();

    void cleanupTestCase();

    void exists();

    void open_data();

    void open();

    void openUnbuffered();

    void size_data();

    void size();

    void sizeNoExist();

    void seek();

    void setSize();

    void setSizeSeek();

    void atEnd();

    void readLine();

    void readLine2();

    void readLineNullInLine();

    void readAll_data();

    void readAll();

    void readAllBuffer();

    void readAllStdin();

    void readLineStdin();

    void readLineStdin_lineByLine();

    void text();

    void missingEndOfLine();

    void readBlock();

    void getch();

    void ungetChar();

    void createFile();

    void append();

    void permissions_data();

    void permissions();

    void setPermissions();

    void copy();

    void copyAfterFail();

    void copyRemovesTemporaryFile() const;

    void copyShouldntOverwrite();

    void copyFallback();

    void link();

    void linkToDir();

    void absolutePathLinkToRelativePath();

    void readBrokenLink();

    void readTextFile_data();

    void readTextFile();

    void readTextFile2();

    void writeTextFile_data();

    void writeTextFile();

    /* void largeFileSupport(); */

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

    void largeUncFileSupport();

#endif

    void tailFile();

    void flush();

    void bufferedRead();

    void isSequential();

    void encodeName();

    void truncate();

    void seekToPos();

    void FILEReadWrite();

    void i18nFileName_data();

    void i18nFileName();

    void longFileName_data();

    void longFileName();

    void fileEngineHandler();

    void useQFileInAFileHandler();

    void getCharFF();

    void remove_and_exists();

    void removeOpenFile();

    void fullDisk();

    void writeLargeDataBlock_data();

    void writeLargeDataBlock();

    void readFromWriteOnlyFile();

    void writeToReadOnlyFile();

    void virtualFile();

    void textFile();

    void rename_data();

    void rename();

    void renameWithAtEndSpecialFile() const;

    void renameFallback();

    void renameMultiple();

    void appendAndRead();

    void miscWithUncPathAsCurrentDir();

    void standarderror();

    void handle();

    void readEof_data();

    void readEof();

    void map_data();

    void map();

    void mapResource_data();

    void mapResource();

    void mapOpenMode_data();

    void mapOpenMode();

    void openStandardStreams();

    // --- Task related tests below this line

    void task167217();

    void openDirectory();

    void writeNothing();

public:

// disabled this test for the moment... it hangs

    void invalidFile_data();

    void invalidFile();

private:

    enum FileType { OpenQFile, OpenFd, OpenStream };

    void openStandardStreamsFileDescriptors();

    void openStandardStreamsBufferedStreams();

    bool openFd(QFile &file, QIODevice::OpenMode mode)

    {

        int fdMode = QT_OPEN_LARGEFILE | QT_OPEN_BINARY;

        // File will be truncated if in Write mode.

        if (mode & QIODevice::WriteOnly)

            fdMode |= QT_OPEN_WRONLY | QT_OPEN_TRUNC;

        if (mode & QIODevice::ReadOnly)

            fdMode |= QT_OPEN_RDONLY;

        fd_ = QT_OPEN(qPrintable(file.fileName()), fdMode);

        return (-1 != fd_) && file.open(fd_, mode);

    }

    bool openStream(QFile &file, QIODevice::OpenMode mode)

    {

        char const *streamMode = "";

        // File will be truncated if in Write mode.

        if (mode & QIODevice::WriteOnly)

            streamMode = "wb+";

        else if (mode & QIODevice::ReadOnly)

            streamMode = "rb";

        stream_ = QT_FOPEN(qPrintable(file.fileName()), streamMode);

        return stream_ && file.open(stream_, mode);

    }

    bool openFile(QFile &file, QIODevice::OpenMode mode, FileType type = OpenQFile)

    {

        if (mode & QIODevice::WriteOnly && !file.exists())

        {

            // Make sure the file exists

            QFile createFile(file.fileName());

            if (!createFile.open(QIODevice::ReadWrite))

                return false;

        }

        // Note: openFd and openStream will truncate the file if write mode.

        switch (type)

        {

            case OpenQFile:

                return file.open(mode);

            case OpenFd:

                return openFd(file, mode);

            case OpenStream:

                return openStream(file, mode);

        }

        return false;

    }

    void closeFile(QFile &file)

    {

        file.close();

        if (-1 != fd_)

            QT_CLOSE(fd_);

        if (stream_)

            ::fclose(stream_);

        fd_ = -1;

        stream_ = 0;

    }

    int fd_;

    FILE *stream_;

};

tst_QFile::tst_QFile()

{

}

tst_QFile::~tst_QFile()

{

}

void tst_QFile::init()

{

// TODO: Add initialization code here.

// This will be executed immediately before each test is run.

    fd_ = -1;

    stream_ = 0;

}

void tst_QFile::cleanup()

{

// TODO: Add cleanup code here.

// This will be executed immediately after each test is run.

    // for copyFallback()

    if (QFile::exists("file-copy-destination.txt")) {

        QFile::setPermissions("file-copy-destination.txt",

                QFile::ReadOwner | QFile::WriteOwner);

        QFile::remove("file-copy-destination.txt");

    }

    // for renameFallback()

    QFile::remove("file-rename-destination.txt");

    // for copyAfterFail()

    QFile::remove("file-to-be-copied.txt");

    QFile::remove("existing-file.txt");

    QFile::remove("copied-file-1.txt");

    QFile::remove("copied-file-2.txt");

    // for renameMultiple()

    QFile::remove("file-to-be-renamed.txt");

    QFile::remove("existing-file.txt");

    QFile::remove("file-renamed-once.txt");

    QFile::remove("file-renamed-twice.txt");

    if (-1 != fd_)

        QT_CLOSE(fd_);

    if (stream_)

        ::fclose(stream_);

}

void tst_QFile::initTestCase()

{

    QFile::remove("noreadfile");

    // create a file and make it read-only

    QFile file("readonlyfile");

    file.open(QFile::WriteOnly);

    file.write("a", 1);

    file.close();

    file.setPermissions(QFile::ReadOwner);

    // create another file and make it not readable

    file.setFileName("noreadfile");

    file.open(QFile::WriteOnly);

    file.write("b", 1);

    file.close();

    file.setPermissions(0);

}

void tst_QFile::cleanupTestCase()

{

    // clean up the files we created

    QFile::remove("readonlyfile");

    QFile::remove("noreadfile");

    QFile::remove("myLink.lnk");

    QFile::remove("appendme.txt");

    QFile::remove("createme.txt");

    QFile::remove("file.txt");

    QFile::remove("genfile.txt");

    QFile::remove("seekToPos.txt");

    QFile::remove("setsizeseek.txt");

    QFile::remove("stdfile.txt");

    QFile::remove("textfile.txt");

    QFile::remove("truncate.txt");

    QFile::remove("winfile.txt");

    QFile::remove("writeonlyfile");

    QFile::remove("largeblockfile.txt");

    QFile::remove("tst_qfile_copy.cpp");

    QFile::remove("nullinline.txt");

    QFile::remove("myLink2.lnk");

    QFile::remove("resources");

    QFile::remove("qfile_map_testfile");

    QFile::remove("readAllBuffer.txt");

}

//------------------------------------------

// The 'testfile' is currently just a

// testfile. The path of this file, the

// attributes and the contents itself

// will be changed as far as we have a

// proper way to handle files in the

// testing enviroment.

//------------------------------------------

void tst_QFile::exists()

{

    QFile f( SRCDIR "testfile.txt" );

    QCOMPARE( f.exists(), (bool)TRUE );

    QFile file("nobodyhassuchafile");

    file.remove();

    QVERIFY(!file.exists());

    QFile file2("nobodyhassuchafile");

    QVERIFY(file2.open(QIODevice::WriteOnly));

    file2.close();

    QVERIFY(file.exists());

    QVERIFY(file.open(QIODevice::WriteOnly));

    file.close();

    QVERIFY(file.exists());

    file.remove();

    QVERIFY(!file.exists());

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

    QFile unc("//" + QtNetworkSettings::winServerName() + "/testshare/readme.txt");

    QVERIFY(unc.exists());

#endif

}

void tst_QFile::open_data()

{

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

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

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

    QTest::addColumn<QFile::FileError>("status");

#ifdef Q_OS_MAC

    static const QString denied("Operation not permitted");

#else

    static const QString denied("Permission denied");

#endif

    QTest::newRow( "exist_readOnly"  )

        << QString(SRCDIR "testfile.txt") << int(QIODevice::ReadOnly)

        << (bool)TRUE << QFile::NoError;

    QTest::newRow( "exist_writeOnly" )

        << QString("readonlyfile")

        << int(QIODevice::WriteOnly)

        << (bool)FALSE

        << QFile::OpenError;

    QTest::newRow( "exist_append"    )

        << QString("readonlyfile") << int(QIODevice::Append)

        << (bool)FALSE << QFile::OpenError;

    QTest::newRow( "nonexist_readOnly"  )

        << QString("nonExist.txt") << int(QIODevice::ReadOnly)

        << (bool)FALSE << QFile::OpenError;

    QTest::newRow("emptyfile")

        << QString("")

        << int(QIODevice::ReadOnly)

        << (bool)FALSE

        << QFile::OpenError;

    QTest::newRow("nullfile") << QString() << int(QIODevice::ReadOnly) << (bool)FALSE

        << QFile::OpenError;

    QTest::newRow("two-dots") << QString(SRCDIR "two.dots.file") << int(QIODevice::ReadOnly) << (bool)TRUE

        << QFile::NoError;

    QTest::newRow("readonlyfile") << QString("readonlyfile") << int(QIODevice::WriteOnly)

                                  << (bool)FALSE << QFile::OpenError;

    QTest::newRow("noreadfile") << QString("noreadfile") << int(QIODevice::ReadOnly)

                                << (bool)FALSE << QFile::OpenError;

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

    QTest::newRow("//./PhysicalDrive0") << QString("//./PhysicalDrive0") << int(QIODevice::ReadOnly)

                                        << (bool)TRUE << QFile::NoError;

                             << true << QFile::NoError;

#endif

}

void tst_QFile::open()

{

    QFETCH( QString, filename );

    QFETCH( int, mode );

    QFile f( filename );

    QFETCH( bool, ok );

#if defined(Q_OS_SYMBIAN)

    if (qstrcmp(QTest::currentDataTag(), "noreadfile") == 0)

        QSKIP("Symbian does not support non-readable files", SkipSingle);

#elif defined(Q_OS_UNIX)

    if (::getuid() == 0)

        // root and Chuck Norris don't care for file permissions. Skip.

        QSKIP("Running this test as root doesn't make sense", SkipAll);

#endif

#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)

    QEXPECT_FAIL("noreadfile", "Windows does not currently support non-readable files.", Abort);

#endif

    if (filename.isEmpty())

        QTest::ignoreMessage(QtWarningMsg, "QFSFileEngine::open: No file name specified");

    QCOMPARE(f.open( QIODevice::OpenMode(mode) ), ok);

    QTEST( f.error(), "status" );

}

void tst_QFile::openUnbuffered()

{

    QFile file(SRCDIR "testfile.txt");