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

**

** Copyright (C) 2009 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

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 seek();

    void setSize();

    void setSizeSeek();

    void atEnd();

    void readLine();

    void readLine2();

    void readLineNullInLine();

    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();

    // --- Task related tests below this line

    void task167217();

    void openDirectory();

public:

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

    void invalidFile_data();

    void invalidFile();

};

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.

}

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");

}

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");

}

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

// 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;

    QTest::newRow("uncFile") << "//" + QtNetworkSettings::winServerName() + "/testsharewritable/test.pri" << int(QIODevice::ReadOnly)

                             << 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");

    QVERIFY(file.open(QIODevice::ReadOnly | QIODevice::Unbuffered));

    char c = '\0';

    QVERIFY(file.seek(1));

    QCOMPARE(file.pos(), qint64(1));

    QVERIFY(file.getChar(&c));

    QCOMPARE(file.pos(), qint64(2));

    char d = '\0';

    QVERIFY(file.seek(3));

    QCOMPARE(file.pos(), qint64(3));

    QVERIFY(file.getChar(&d));

    QCOMPARE(file.pos(), qint64(4));

    QVERIFY(file.seek(1));

    QCOMPARE(file.pos(), qint64(1));

    char c2 = '\0';

    QVERIFY(file.getChar(&c2));

    QCOMPARE(file.pos(), qint64(2));

    QVERIFY(file.seek(3));

    QCOMPARE(file.pos(), qint64(3));

    char d2 = '\0';

    QVERIFY(file.getChar(&d2));

    QCOMPARE(file.pos(), qint64(4));

    QCOMPARE(c, c2);

    QCOMPARE(d, d2);

    QCOMPARE(c, '-');

    QCOMPARE(d, '-');

}

void tst_QFile::size_data()

{

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

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

    QTest::newRow( "exist01" ) << QString(SRCDIR "testfile.txt") << 245;

    QTest::newRow( "nonexist01" ) << QString("foo.txt") << 0;

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

    // Only test UNC on Windows./

    QTest::newRow("unc") << "//" + QString(QtNetworkSettings::winServerName() + "/testsharewritable/test.pri") << 34;

#endif

}

void tst_QFile::size()

{

    QFETCH( QString, filename );

    QFile f( filename );

    QTEST( (int)f.size(), "size" );

    if (f.open(QFile::ReadOnly))

        QTEST( (int)f.size(), "size" );

}

void tst_QFile::seek()

{

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

    QFile file("newfile.txt");

    file.open(QIODevice::WriteOnly);

    QCOMPARE(file.size(), qint64(0));

    QCOMPARE(file.pos(), qint64(0));

    QVERIFY(file.seek(10));

    QCOMPARE(file.pos(), qint64(10));

    QCOMPARE(file.size(), qint64(0));

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

}

void tst_QFile::setSize()

{

    DEPENDS_ON( "size" );

    if ( QFile::exists( "createme.txt" ) )

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

    QVERIFY( !QFile::exists( "createme.txt" ) );

    QFile f("createme.txt");

    QVERIFY(f.open(QIODevice::Truncate | QIODevice::ReadWrite));

    f.putChar('a');

    f.seek(0);

    char c = '\0';

    f.getChar(&c);

    QCOMPARE(c, 'a');

    QCOMPARE(f.size(), (qlonglong)1);

	bool ok = f.resize(99);

    QVERIFY(ok);

    QCOMPARE(f.size(), (qlonglong)99);

    f.seek(0);

    c = '\0';

    f.getChar(&c);

    QCOMPARE(c, 'a');

    QVERIFY(f.resize(1));

    QCOMPARE(f.size(), (qlonglong)1);

    f.seek(0);

    c = '\0';

    f.getChar(&c);

    QCOMPARE(c, 'a');

    f.close();

    QCOMPARE(f.size(), (qlonglong)1);

    QVERIFY(f.resize(100));

    QCOMPARE(f.size(), (qlonglong)100);

    QVERIFY(f.resize(50));

    QCOMPARE(f.size(), (qlonglong)50);

}

void tst_QFile::setSizeSeek()

{

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

    QFile f("setsizeseek.txt");

    QVERIFY(f.open(QFile::WriteOnly));

    f.write("ABCD");

    QCOMPARE(f.pos(), qint64(4));

    f.resize(2);

    QCOMPARE(f.pos(), qint64(2));

    f.resize(4);

    QCOMPARE(f.pos(), qint64(2));