1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 #include <qplatformdefs.h>

    45 

    46 #include <QAbstractFileEngine>

    47 #include <QFSFileEngine>

    48 #include <QCoreApplication>

    49 #include <QDebug>

    50 #include <QDir>

    51 #include <QFile>

    52 #include <QFileInfo>

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

    54 #include <QHostInfo>

    55 #endif

    56 #include <QProcess>

    57 #ifndef Q_OS_WIN

    58 # include <sys/types.h>

    59 # include <unistd.h>

    60 #endif

    61 #ifdef Q_OS_MAC

    62 # include <sys/mount.h>

    63 #elif defined(Q_OS_LINUX)

    64 # include <sys/vfs.h>

    65 #elif defined(Q_OS_FREEBSD)

    66 # include <sys/param.h>

    67 # include <sys/mount.h>

    68 #elif defined(Q_OS_IRIX)

    69 # include <sys/statfs.h>

    70 #elif defined(Q_OS_WINCE)

    71 # include <qplatformdefs.h>

    72 # include <private/qfsfileengine_p.h>

    73 #endif

    74 

    75 #include <stdio.h>

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

    77 

    78 #if defined(Q_OS_SYMBIAN)

    79 # define SRCDIR ""

    80 #endif

    81 

    82 Q_DECLARE_METATYPE(QFile::FileError)

    83 

    84 //TESTED_CLASS=

    85 //TESTED_FILES=

    86 

    87 class tst_QFile : public QObject

    88 {

    89     Q_OBJECT

    90 

    91 public:

    92     tst_QFile();

    93     virtual ~tst_QFile();

    94 

    95 

    96 public slots:

    97     void init();

    98     void cleanup();

    99 private slots:

   100     void initTestCase();

   101     void cleanupTestCase();

   102     void exists();

   103     void open_data();

   104     void open();

   105     void openUnbuffered();

   106     void size_data();

   107     void size();

   108     void seek();

   109     void setSize();

   110     void setSizeSeek();

   111     void atEnd();

   112     void readLine();

   113     void readLine2();

   114     void readLineNullInLine();

   115     void readAllStdin();

   116     void readLineStdin();

   117     void readLineStdin_lineByLine();

   118     void text();

   119     void missingEndOfLine();

   120     void readBlock();

   121     void getch();

   122     void ungetChar();

   123     void createFile();

   124     void append();

   125     void permissions_data();

   126     void permissions();

   127     void setPermissions();

   128     void copy();

   129     void copyAfterFail();

   130     void copyRemovesTemporaryFile() const;

   131     void copyShouldntOverwrite();

   132     void copyFallback();

   133     void link();

   134     void linkToDir();

   135     void absolutePathLinkToRelativePath();

   136     void readBrokenLink();

   137     void readTextFile_data();

   138     void readTextFile();

   139     void readTextFile2();

   140     void writeTextFile_data();

   141     void writeTextFile();

   142     /* void largeFileSupport(); */

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

   144     void largeUncFileSupport();

   145 #endif

   146     void tailFile();

   147     void flush();

   148     void bufferedRead();

   149     void isSequential();

   150     void encodeName();

   151     void truncate();

   152     void seekToPos();

   153     void FILEReadWrite();

   154     void i18nFileName_data();

   155     void i18nFileName();

   156     void longFileName_data();

   157     void longFileName();

   158     void fileEngineHandler();

   159     void useQFileInAFileHandler();

   160     void getCharFF();

   161     void remove_and_exists();

   162     void removeOpenFile();

   163     void fullDisk();

   164     void writeLargeDataBlock_data();

   165     void writeLargeDataBlock();

   166     void readFromWriteOnlyFile();

   167     void writeToReadOnlyFile();

   168     void virtualFile();

   169     void textFile();

   170     void rename_data();

   171     void rename();

   172     void renameWithAtEndSpecialFile() const;

   173     void renameFallback();

   174     void renameMultiple();

   175     void appendAndRead();

   176     void miscWithUncPathAsCurrentDir();

   177     void standarderror();

   178     void handle();

   179 

   180     void readEof_data();

   181     void readEof();

   182 

   183     void map_data();

   184     void map();

   185     void mapResource_data();

   186     void mapResource();

   187     void mapOpenMode_data();

   188     void mapOpenMode();

   189 

   190     // --- Task related tests below this line

   191     void task167217();

   192 

   193     void openDirectory();

   194 

   195 public:

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

   197     void invalidFile_data();

   198     void invalidFile();

   199 };

   200 

   201 tst_QFile::tst_QFile()

   202 {

   203 }

   204 

   205 tst_QFile::~tst_QFile()

   206 {

   207 

   208 }

   209 

   210 void tst_QFile::init()

   211 {

   212 // TODO: Add initialization code here.

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

   214 }

   215 

   216 void tst_QFile::cleanup()

   217 {

   218 // TODO: Add cleanup code here.

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

   220 

   221     // for copyFallback()

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

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

   224                 QFile::ReadOwner | QFile::WriteOwner);

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

   226     }

   227 

   228     // for renameFallback()

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

   230 

   231     // for copyAfterFail()

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

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

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

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

   236 

   237     // for renameMultiple()

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

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

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

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

   242 }

   243 

   244 void tst_QFile::initTestCase()

   245 {

   246     QFile::remove("noreadfile");

   247 

   248     // create a file and make it read-only

   249     QFile file("readonlyfile");

   250     file.open(QFile::WriteOnly);

   251     file.write("a", 1);

   252     file.close();

   253     file.setPermissions(QFile::ReadOwner);

   254 

   255     // create another file and make it not readable

   256     file.setFileName("noreadfile");

   257     file.open(QFile::WriteOnly);

   258     file.write("b", 1);

   259     file.close();

   260     file.setPermissions(0);

   261 }

   262 

   263 void tst_QFile::cleanupTestCase()

   264 {

   265     // clean up the files we created

   266     QFile::remove("readonlyfile");

   267     QFile::remove("noreadfile");

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

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

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

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

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

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

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

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

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

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

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

   279     QFile::remove("writeonlyfile");

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

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

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

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

   284     QFile::remove("resources");

   285     QFile::remove("qfile_map_testfile");

   286 }

   287 

   288 //------------------------------------------

   289 // The 'testfile' is currently just a

   290 // testfile. The path of this file, the

   291 // attributes and the contents itself

   292 // will be changed as far as we have a

   293 // proper way to handle files in the

   294 // testing enviroment.

   295 //------------------------------------------

   296 

   297 void tst_QFile::exists()

   298 {

   299     QFile f( SRCDIR "testfile.txt" );

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

   301 

   302     QFile file("nobodyhassuchafile");

   303     file.remove();

   304     QVERIFY(!file.exists());

   305 

   306     QFile file2("nobodyhassuchafile");

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

   308     file2.close();

   309 

   310     QVERIFY(file.exists());

   311 

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

   313     file.close();

   314     QVERIFY(file.exists());

   315 

   316     file.remove();

   317     QVERIFY(!file.exists());

   318 

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

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

   321     QVERIFY(unc.exists());

   322 #endif

   323 }

   324 

   325 void tst_QFile::open_data()

   326 {

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

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

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

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

   331 

   332 #ifdef Q_OS_MAC

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

   334 #else

   335     static const QString denied("Permission denied");

   336 #endif

   337     QTest::newRow( "exist_readOnly"  )

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

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

   340 

   341     QTest::newRow( "exist_writeOnly" )

   342         << QString("readonlyfile")

   343         << int(QIODevice::WriteOnly)

   344         << (bool)FALSE

   345         << QFile::OpenError;

   346 

   347     QTest::newRow( "exist_append"    )

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

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

   350 

   351     QTest::newRow( "nonexist_readOnly"  )

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

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

   354 

   355     QTest::newRow("emptyfile")

   356         << QString("")

   357         << int(QIODevice::ReadOnly)

   358         << (bool)FALSE

   359         << QFile::OpenError;

   360 

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

   362         << QFile::OpenError;

   363 

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

   365         << QFile::NoError;

   366 

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

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

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

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

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

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

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

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

   375                              << true << QFile::NoError;

   376 #endif

   377 }

   378 

   379 void tst_QFile::open()

   380 {

   381     QFETCH( QString, filename );

   382     QFETCH( int, mode );

   383 

   384     QFile f( filename );

   385 

   386     QFETCH( bool, ok );

   387 

   388 #if defined(Q_OS_SYMBIAN)

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

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

   391 #elif defined(Q_OS_UNIX)

   392     if (::getuid() == 0)

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

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

   395 #endif

   396 

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

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

   399 #endif

   400     if (filename.isEmpty())

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

   402 

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

   404 

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

   406 }

   407 

   408 void tst_QFile::openUnbuffered()

   409 {

   410     QFile file(SRCDIR "testfile.txt");

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

   412     char c = '\0';

   413     QVERIFY(file.seek(1));

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

   415     QVERIFY(file.getChar(&c));

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

   417     char d = '\0';

   418     QVERIFY(file.seek(3));

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

   420     QVERIFY(file.getChar(&d));

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

   422     QVERIFY(file.seek(1));

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

   424     char c2 = '\0';

   425     QVERIFY(file.getChar(&c2));

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

   427     QVERIFY(file.seek(3));

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

   429     char d2 = '\0';

   430     QVERIFY(file.getChar(&d2));

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

   432     QCOMPARE(c, c2);

   433     QCOMPARE(d, d2);

   434     QCOMPARE(c, '-');

   435     QCOMPARE(d, '-');

   436 }

   437 

   438 void tst_QFile::size_data()

   439 {

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

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

   442 

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

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

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

   446     // Only test UNC on Windows./

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

   448 #endif

   449 }

   450 

   451 void tst_QFile::size()

   452 {

   453     QFETCH( QString, filename );

   454     QFile f( filename );

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

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

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

   458 }

   459 

   460 void tst_QFile::seek()

   461 {

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

   463     QFile file("newfile.txt");

   464     file.open(QIODevice::WriteOnly);

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

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

   467     QVERIFY(file.seek(10));

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

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

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

   471 }

   472 

   473 void tst_QFile::setSize()

   474 {

   475     DEPENDS_ON( "size" );

   476 

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

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

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

   480 

   481     QFile f("createme.txt");

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

   483     f.putChar('a');

   484 

   485     f.seek(0);

   486     char c = '\0';

   487     f.getChar(&c);

   488     QCOMPARE(c, 'a');

   489 

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

   491 	bool ok = f.resize(99);

   492     QVERIFY(ok);

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

   494 

   495     f.seek(0);

   496     c = '\0';

   497     f.getChar(&c);

   498     QCOMPARE(c, 'a');

   499 

   500     QVERIFY(f.resize(1));

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

   502 

   503     f.seek(0);

   504     c = '\0';

   505     f.getChar(&c);

   506     QCOMPARE(c, 'a');

   507 

   508     f.close();

   509 

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

   511     QVERIFY(f.resize(100));

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

   513     QVERIFY(f.resize(50));

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

   515 }

   516 

   517 void tst_QFile::setSizeSeek()

   518 {

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

   520     QFile f("setsizeseek.txt");

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

   522     f.write("ABCD");

   523 

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

   525     f.resize(2);

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

   527     f.resize(4);

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

   529     f.resize(0);

   530     QCOMPARE(f.pos(), qint64(0));

   531     f.resize(4);

   532     QCOMPARE(f.pos(), qint64(0));

   533 

   534     f.seek(3);

   535     QCOMPARE(f.pos(), qint64(3));

   536     f.resize(2);

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

   538 }

   539 

   540 void tst_QFile::atEnd()

   541 {

   542     QFile f( SRCDIR "testfile.txt" );

   543     QVERIFY(f.open( QIODevice::ReadOnly ));

   544 

   545     int size = f.size();

   546     f.seek( size );

   547 

   548     bool end = f.atEnd();

   549     f.close();

   550     QCOMPARE( end, (bool)TRUE );

   551 }

   552 

   553 void tst_QFile::readLine()

   554 {

   555     QFile f( SRCDIR "testfile.txt" );

   556     QVERIFY(f.open( QIODevice::ReadOnly ));

   557 

   558     int i = 0;

   559     char p[128];

   560     int foo;

   561     while ( (foo=f.readLine( p, 128 )) > 0 ) {

   562         ++i;

   563         if ( i == 5 ) {

   564             QCOMPARE( p[0], 'T' );

   565             QCOMPARE( p[3], 's' );

   566             QCOMPARE( p[11], 'i' );

   567         }

   568     }

   569     f.close();

   570     QCOMPARE( i, 6 );

   571 }

   572 

   573 void tst_QFile::readLine2()

   574 {

   575     QFile f( SRCDIR "testfile.txt" );

   576     f.open( QIODevice::ReadOnly );

   577 

   578     char p[128];

   579     QCOMPARE(f.readLine(p, 60), qlonglong(59));

   580     QCOMPARE(f.readLine(p, 60), qlonglong(59));

   581     memset(p, '@', sizeof(p));

   582     QCOMPARE(f.readLine(p, 60), qlonglong(59));

   583 

   584     QCOMPARE(p[57], '-');

   585     QCOMPARE(p[58], '\n');

   586     QCOMPARE(p[59], '\0');

   587     QCOMPARE(p[60], '@');

   588 }

   589 

   590 void tst_QFile::readLineNullInLine()

   591 {

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

   593     QFile file("nullinline.txt");

   594     QVERIFY(file.open(QIODevice::ReadWrite));

   595     QVERIFY(file.write("linewith\0null\nanotherline\0withnull\n\0\nnull\0", 42) > 0);

   596     QVERIFY(file.flush());

   597     file.reset();

   598 

   599     QCOMPARE(file.readLine(), QByteArray("linewith\0null\n", 14));

   600     QCOMPARE(file.readLine(), QByteArray("anotherline\0withnull\n", 21));

   601     QCOMPARE(file.readLine(), QByteArray("\0\n", 2));

   602     QCOMPARE(file.readLine(), QByteArray("null\0", 5));

   603     QCOMPARE(file.readLine(), QByteArray());

   604 }

   605 

   606 void tst_QFile::readAllStdin()

   607 {

   608 #if defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)

   609     QSKIP("Currently no stdin/out supported for Windows CE or Symbian", SkipAll);

   610 #endif

   611 #if defined(QT_NO_PROCESS)

   612     QSKIP("Qt was compiled with QT_NO_PROCESS", SkipAll);

   613 #else

   614     QByteArray lotsOfData(1024, '@'); // 10 megs

   615 

   616     QProcess process;

   617     process.start("stdinprocess/stdinprocess all");

   618     for (int i = 0; i < 5; ++i) {

   619         QTest::qWait(1000);

   620         process.write(lotsOfData);

   621         while (process.bytesToWrite() > 0) {

   622             QVERIFY(process.waitForBytesWritten());

   623         }

   624     }

   625 

   626     process.closeWriteChannel();

   627     process.waitForFinished();

   628     QCOMPARE(process.readAll().size(), lotsOfData.size() * 5);

   629 #endif

   630 }

   631 

   632 void tst_QFile::readLineStdin()

   633 {

   634 #if defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)

   635     QSKIP("Currently no stdin/out supported for Windows CE or Symbian", SkipAll);

   636 #endif

   637 #if defined(QT_NO_PROCESS)

   638     QSKIP("Qt was compiled with QT_NO_PROCESS", SkipAll);

   639 #else

   640 

   641     QByteArray lotsOfData(1024, '@'); // 10 megs

   642     for (int i = 0; i < lotsOfData.size(); ++i) {

   643         if ((i % 32) == 31)

   644             lotsOfData[i] = '\n';

   645         else

   646             lotsOfData[i] = char('0' + i % 32);

   647     }

   648 

   649     for (int i = 0; i < 2; ++i) {

   650         QProcess process;

   651         process.start(QString("stdinprocess/stdinprocess line %1").arg(i), QIODevice::Text | QIODevice::ReadWrite);

   652         for (int i = 0; i < 5; ++i) {

   653             QTest::qWait(1000);

   654             process.write(lotsOfData);

   655             while (process.bytesToWrite() > 0) {

   656                 QVERIFY(process.waitForBytesWritten());

   657             }

   658         }

   659 

   660         process.closeWriteChannel();

   661         QVERIFY(process.waitForFinished(5000));

   662 

   663         QByteArray array = process.readAll();

   664         QCOMPARE(array.size(), lotsOfData.size() * 5);

   665         for (int i = 0; i < array.size(); ++i) {

   666             if ((i % 32) == 31)

   667                 QCOMPARE(char(array[i]), '\n');

   668             else

   669                 QCOMPARE(char(array[i]), char('0' + i % 32));

   670         }

   671     }

   672 #endif

   673 }

   674 

   675 void tst_QFile::readLineStdin_lineByLine()

   676 {

   677 #if defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)

   678     QSKIP("Currently no stdin/out supported for Windows CE", SkipAll);

   679 #endif

   680 #if defined(QT_NO_PROCESS)

   681     QSKIP("Qt was compiled with QT_NO_PROCESS", SkipAll);

   682 #else

   683     for (int i = 0; i < 2; ++i) {

   684         QProcess process;

   685         process.start(QString("stdinprocess/stdinprocess line %1").arg(i), QIODevice::Text | QIODevice::ReadWrite);

   686         QVERIFY(process.waitForStarted());

   687 

   688         for (int j = 0; j < 3; ++j) {

   689             QByteArray line = "line " + QByteArray::number(j) + "\n";

   690             QCOMPARE(process.write(line), qint64(line.size()));

   691             QVERIFY(process.waitForBytesWritten(2000));

   692             if (process.bytesAvailable() == 0)

   693                 QVERIFY(process.waitForReadyRead(2000));

   694             QCOMPARE(process.readAll(), line);

   695         }

   696 

   697         process.closeWriteChannel();

   698         QVERIFY(process.waitForFinished(5000));

   699     }

   700 #endif

   701 }

   702 

   703 void tst_QFile::text()

   704 {

   705     // dosfile.txt is a binary CRLF file

   706     QFile file(SRCDIR "dosfile.txt");

   707     QVERIFY(file.open(QFile::Text | QFile::ReadOnly));

   708     QCOMPARE(file.readLine(),

   709             QByteArray("/dev/system/root     /                    reiserfs   acl,user_xattr        1 1\n"));

   710     QCOMPARE(file.readLine(),

   711             QByteArray("/dev/sda1            /boot                ext3       acl,user_xattr        1 2\n"));

   712     file.ungetChar('\n');

   713     file.ungetChar('2');

   714     QCOMPARE(file.readLine().constData(), QByteArray("2\n").constData());

   715 }

   716 

   717 void tst_QFile::missingEndOfLine()

   718 {

   719     QFile file(SRCDIR "noendofline.txt");

   720     QVERIFY(file.open(QFile::ReadOnly));

   721 

   722     int nlines = 0;

   723     while (!file.atEnd()) {

   724         ++nlines;

   725         file.readLine();

   726     }

   727 

   728     QCOMPARE(nlines, 3);

   729 }

   730 

   731 void tst_QFile::readBlock()

   732 {

   733     QFile f( SRCDIR "testfile.txt" );

   734     f.open( QIODevice::ReadOnly );

   735 

   736     int length = 0;

   737     char p[256];

   738     length = f.read( p, 256 );

   739     f.close();

   740     QCOMPARE( length, 245 );

   741     QCOMPARE( p[59], 'D' );

   742     QCOMPARE( p[178], 'T' );

   743     QCOMPARE( p[199], 'l' );

   744 }

   745 

   746 void tst_QFile::getch()

   747 {

   748     QFile f( SRCDIR "testfile.txt" );

   749     f.open( QIODevice::ReadOnly );

   750 

   751     char c;

   752     int i = 0;

   753     while (f.getChar(&c)) {

   754         QCOMPARE(f.pos(), qint64(i + 1));

   755         if ( i == 59 )

   756             QCOMPARE( c, 'D' );

   757         ++i;

   758     }

   759     f.close();

   760     QCOMPARE( i, 245 );

   761 }

   762 

   763 void tst_QFile::ungetChar()

   764 {

   765     QFile f(SRCDIR "testfile.txt");

   766     QVERIFY(f.open(QIODevice::ReadOnly));

   767 

   768     QByteArray array = f.readLine();

   769     QCOMPARE(array.constData(), "----------------------------------------------------------\n");

   770     f.ungetChar('\n');

   771 

   772     array = f.readLine();

   773     QCOMPARE(array.constData(), "\n");

   774 

   775     f.ungetChar('\n');

   776     f.ungetChar('-');

   777     f.ungetChar('-');

   778 

   779     array = f.readLine();

   780     QCOMPARE(array.constData(), "--\n");

   781 

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

   783     QFile out("genfile.txt");

   784     QVERIFY(out.open(QIODevice::ReadWrite));

   785     out.write("123");

   786     out.seek(0);

   787     QCOMPARE(out.readAll().constData(), "123");

   788     out.ungetChar('3');

   789     out.write("4");

   790     out.seek(0);

   791     QCOMPARE(out.readAll().constData(), "124");

   792     out.ungetChar('4');

   793     out.ungetChar('2');

   794     out.ungetChar('1');

   795     char buf[3];

   796     QCOMPARE(out.read(buf, sizeof(buf)), qint64(3));

   797     QCOMPARE(buf[0], '1');

   798     QCOMPARE(buf[1], '2');

   799     QCOMPARE(buf[2], '4');

   800 }

   801 

   802 void tst_QFile::invalidFile_data()

   803 {

   804     QTest::addColumn<QString>("fileName");

   805 #if !defined(Q_WS_WIN) && !defined(Q_OS_SYMBIAN)

   806     QTest::newRow( "x11" ) << QString( "qwe//" );

   807 #else

   808     QTest::newRow( "colon1" ) << QString( "fail:invalid" );

   809     QTest::newRow( "colon2" ) << QString( "f:ail:invalid" );

   810     QTest::newRow( "colon3" ) << QString( ":failinvalid" );

   811     QTest::newRow( "forwardslash" ) << QString( "fail/invalid" );

   812     QTest::newRow( "asterisk" ) << QString( "fail*invalid" );

   813     QTest::newRow( "questionmark" ) << QString( "fail?invalid" );

   814     QTest::newRow( "quote" ) << QString( "fail\"invalid" );

   815     QTest::newRow( "lt" ) << QString( "fail<invalid" );

   816     QTest::newRow( "gt" ) << QString( "fail>invalid" );

   817     QTest::newRow( "pipe" ) << QString( "fail|invalid" );

   818 #endif

   819 }

   820 

   821 void tst_QFile::invalidFile()

   822 {

   823     QFETCH( QString, fileName );

   824     QFile f( fileName );

   825     QVERIFY( !f.open( QIODevice::ReadWrite ) );

   826 }

   827 

   828 void tst_QFile::createFile()

   829 {

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

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

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

   833 

   834     QFile f( "createme.txt" );

   835     QVERIFY( f.open( QIODevice::WriteOnly ) );

   836     f.close();

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

   838 }

   839 

   840 void tst_QFile::append()

   841 {

   842     const QString name("appendme.txt");

   843     if (QFile::exists(name))

   844         QFile::remove(name);

   845     QVERIFY(!QFile::exists(name));

   846 

   847     QFile f(name);

   848     QVERIFY(f.open(QIODevice::WriteOnly | QIODevice::Truncate));

   849     f.putChar('a');

   850     f.close();

   851 

   852     QVERIFY(f.open(QIODevice::Append));

   853     QVERIFY(f.pos() == 1);

   854     f.putChar('a');

   855     f.close();

   856     QCOMPARE(int(f.size()), 2);

   857 }

   858 

   859 void tst_QFile::permissions_data()

   860 {

   861     QTest::addColumn<QString>("file");

   862     QTest::addColumn<uint>("perms");

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

   864 

   865     QTest::newRow("data0") << QCoreApplication::instance()->applicationFilePath() << uint(QFile::ExeUser) << true;

   866     QTest::newRow("data1") << SRCDIR "tst_qfile.cpp" << uint(QFile::ReadUser) << true;

   867 //    QTest::newRow("data2") << "tst_qfile.cpp" << int(QFile::WriteUser) << false;

   868     QTest::newRow("resource1") << ":/tst_qfileinfo/resources/file1.ext1" << uint(QFile::ReadUser) << true;

   869     QTest::newRow("resource2") << ":/tst_qfileinfo/resources/file1.ext1" << uint(QFile::WriteUser) << false;

   870     QTest::newRow("resource3") << ":/tst_qfileinfo/resources/file1.ext1" << uint(QFile::ExeUser) << false;

   871 }

   872 

   873 void tst_QFile::permissions()

   874 {

   875 #if defined(Q_OS_SYMBIAN)

   876     if (qstrcmp(QTest::currentDataTag(), "data0") == 0)

   877         QSKIP("Symbian does not have execution permissions", SkipSingle);

   878 #endif

   879     QFETCH(QString, file);

   880     QFETCH(uint, perms);

   881     QFETCH(bool, expected);

   882     QFile f(file);

   883     QCOMPARE(((f.permissions() & perms) == QFile::Permissions(perms)), expected);

   884 }

   885 

   886 void tst_QFile::setPermissions()

   887 {

   888     DEPENDS_ON( "permissions" ); //if that doesn't work...

   889 

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

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

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

   893 

   894     QFile f("createme.txt");

   895     QVERIFY(f.open(QIODevice::WriteOnly | QIODevice::Truncate));

   896     f.putChar('a');

   897     f.close();

   898 

   899     QFile::Permissions perms(QFile::WriteUser | QFile::ReadUser);

   900     QVERIFY(f.setPermissions(perms));

   901     QVERIFY((f.permissions() & perms) == perms);

   902 

   903 }

   904 

   905 void tst_QFile::copy()

   906 {

   907     QFile::setPermissions("tst_qfile_copy.cpp", QFile::WriteUser);

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

   909     QFile::remove("test2");

   910     QVERIFY(QFile::copy(SRCDIR "tst_qfile.cpp", "tst_qfile_copy.cpp"));

   911     QFile in1(SRCDIR "tst_qfile.cpp"), in2("tst_qfile_copy.cpp");

   912     QVERIFY(in1.open(QFile::ReadOnly));

   913     QVERIFY(in2.open(QFile::ReadOnly));

   914     QByteArray data1 = in1.readAll(), data2 = in2.readAll();

   915     QCOMPARE(data1, data2);

   916     QFile::remove( "main_copy.cpp" );

   917 

   918     QFile::copy(QDir::currentPath(), QDir::currentPath() + QLatin1String("/test2"));

   919 }

   920 

   921 void tst_QFile::copyAfterFail()

   922 {

   923     QFile file1("file-to-be-copied.txt");

   924     QFile file2("existing-file.txt");

   925 

   926     QVERIFY(file1.open(QIODevice::ReadWrite) && "(test-precondition)");

   927     QVERIFY(file2.open(QIODevice::ReadWrite) && "(test-precondition)");

   928     file2.close();

   929     QVERIFY(!QFile::exists("copied-file-1.txt") && "(test-precondition)");

   930     QVERIFY(!QFile::exists("copied-file-2.txt") && "(test-precondition)");

   931 

   932     QVERIFY(!file1.copy("existing-file.txt"));

   933     QCOMPARE(file1.error(), QFile::CopyError);

   934 

   935     QVERIFY(file1.copy("copied-file-1.txt"));

   936     QVERIFY(!file1.isOpen());

   937     QCOMPARE(file1.error(), QFile::NoError);

   938 

   939     QVERIFY(!file1.copy("existing-file.txt"));

   940     QCOMPARE(file1.error(), QFile::CopyError);

   941 

   942     QVERIFY(file1.copy("copied-file-2.txt"));

   943     QVERIFY(!file1.isOpen());

   944     QCOMPARE(file1.error(), QFile::NoError);

   945 

   946     QVERIFY(QFile::exists("copied-file-1.txt"));

   947     QVERIFY(QFile::exists("copied-file-2.txt"));

   948 

   949     QVERIFY(QFile::remove("file-to-be-copied.txt") && "(test-cleanup)");

   950     QVERIFY(QFile::remove("existing-file.txt") && "(test-cleanup)");

   951     QVERIFY(QFile::remove("copied-file-1.txt") && "(test-cleanup)");

   952     QVERIFY(QFile::remove("copied-file-2.txt") && "(test-cleanup)");

   953 }

   954 

   955 void tst_QFile::copyRemovesTemporaryFile() const

   956 {

   957     const QString newName(QLatin1String("copyRemovesTemporaryFile"));

   958     QVERIFY(QFile::copy(SRCDIR "forCopying.txt", newName));

   959 

   960     QVERIFY(!QFile::exists(QLatin1String( SRCDIR "qt_temp.XXXXXX")));

   961     QVERIFY(QFile::remove(newName));

   962 }

   963 

   964 void tst_QFile::copyShouldntOverwrite()

   965 {

   966     // Copy should not overwrite existing files.

   967     QFile::remove("tst_qfile.cpy");

   968     QFile file(SRCDIR "tst_qfile.cpp");

   969     QVERIFY(file.copy("tst_qfile.cpy"));

   970 #if defined(Q_OS_SYMBIAN)

   971 	bool ok = QFile::setPermissions("tst_qfile.cpy", QFile::WriteUser);

   972 #else

   973 	bool ok = QFile::setPermissions("tst_qfile.cpy", QFile::WriteOther);

   974 #endif

   975     QVERIFY(ok);

   976     QVERIFY(!file.copy("tst_qfile.cpy"));

   977     QFile::remove("tst_qfile.cpy");

   978 }

   979 

   980 void tst_QFile::copyFallback()

   981 {

   982     // Using a resource file to trigger QFile::copy's fallback handling

   983     QFile file(":/copy-fallback.qrc");

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

   985 

   986     QVERIFY2(file.exists(), "test precondition");

   987     QVERIFY2(!QFile::exists("file-copy-destination.txt"), "test precondition");

   988 

   989     // Fallback copy of closed file.

   990     QVERIFY(file.copy("file-copy-destination.txt"));

   991     QVERIFY(QFile::exists("file-copy-destination.txt"));

   992     QVERIFY(!file.isOpen());

   993 

   994     // Need to reset permissions on Windows to be able to delete

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

   996             QFile::ReadOwner | QFile::WriteOwner));

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

   998 

   999     // Fallback copy of open file.

  1000     QVERIFY(file.open(QIODevice::ReadOnly));

  1001     QVERIFY(file.copy("file-copy-destination.txt"));

  1002     QVERIFY(QFile::exists("file-copy-destination.txt"));

  1003     QVERIFY(!file.isOpen());

  1004 

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

  1006 }

  1007 

  1008 #ifdef Q_OS_WIN

  1009 #include <objbase.h>

  1010 #include <shlobj.h>

  1011 #endif

  1012 

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

  1014 static QString getWorkingDirectoryForLink(const QString &linkFileName)

  1015 {

  1016     bool neededCoInit = false;

  1017     QString ret;

  1018 

  1019     IShellLink *psl;

  1020     HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);

  1021     if (hres == CO_E_NOTINITIALIZED) { // COM was not initialized

  1022         neededCoInit = true;

  1023         CoInitialize(NULL);

  1024         hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);

  1025     }

  1026 

  1027     if (SUCCEEDED(hres)) {    // Get pointer to the IPersistFile interface.

  1028         IPersistFile *ppf;

  1029         hres = psl->QueryInterface(IID_IPersistFile, (LPVOID *)&ppf);

  1030         if (SUCCEEDED(hres))  {

  1031             hres = ppf->Load((LPOLESTR)linkFileName.utf16(), STGM_READ);

  1032             //The original path of the link is retrieved. If the file/folder

  1033             //was moved, the return value still have the old path.

  1034             if(SUCCEEDED(hres)) {

  1035                 wchar_t szGotPath[MAX_PATH];

  1036                 if (psl->GetWorkingDirectory(szGotPath, MAX_PATH) == NOERROR)

  1037                     ret = QString::fromWCharArray(szGotPath);

  1038             }

  1039             ppf->Release();

  1040         }

  1041         psl->Release();

  1042     }

  1043 

  1044     if (neededCoInit) {

  1045         CoUninitialize();

  1046     }

  1047 

  1048     return ret;

  1049 }

  1050 #endif

  1051 

  1052 void tst_QFile::link()

  1053 {

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

  1055     QFileInfo info1("tst_qfile.cpp");

  1056     QVERIFY(QFile::link("tst_qfile.cpp", "myLink.lnk"));

  1057     QFileInfo info2("myLink.lnk");

  1058     QVERIFY(info2.isSymLink());

  1059     QCOMPARE(info2.symLinkTarget(), info1.absoluteFilePath());

  1060 

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

  1062     QString wd = getWorkingDirectoryForLink(info2.absoluteFilePath());

  1063     QCOMPARE(QDir::fromNativeSeparators(wd), info1.absolutePath());

  1064 #endif

  1065     QVERIFY(QFile::remove(info2.absoluteFilePath()));

  1066 }

  1067 

  1068 void tst_QFile::linkToDir()

  1069 {

  1070 #if defined(Q_OS_SYMBIAN)

  1071     QSKIP("Symbian does not support linking to directories", SkipAll);

  1072 #endif

  1073     QFile::remove("myLinkToDir.lnk");

  1074     QDir dir;

  1075     dir.mkdir("myDir");

  1076     QFileInfo info1("myDir");

  1077     QVERIFY(QFile::link("myDir", "myLinkToDir.lnk"));

  1078     QFileInfo info2("myLinkToDir.lnk");

  1079 #if !(defined Q_OS_HPUX && defined(__ia64))

  1080     // absurd HP-UX filesystem bug on gravlaks - checking if a symlink

  1081     // resolves or not alters the file system to make the broken symlink

  1082     // later fail...

  1083     QVERIFY(info2.isSymLink());

  1084 #endif

  1085     QCOMPARE(info2.symLinkTarget(), info1.absoluteFilePath());

  1086     QVERIFY(QFile::remove(info2.absoluteFilePath()));

  1087     QFile::remove("myLinkToDir.lnk");

  1088     dir.rmdir("myDir");

  1089 }

  1090 

  1091 void tst_QFile::absolutePathLinkToRelativePath()

  1092 {

  1093     QFile::remove("myDir/test.txt");

  1094     QFile::remove("myDir/myLink.lnk");

  1095     QDir dir;

  1096     dir.mkdir("myDir");

  1097     QFile("myDir/test.txt").open(QFile::WriteOnly);

  1098 

  1099 #ifdef Q_OS_WIN

  1100     QVERIFY(QFile::link("test.txt", "myDir/myLink.lnk"));

  1101 #else

  1102     QVERIFY(QFile::link("myDir/test.txt", "myDir/myLink.lnk"));

  1103 #endif

  1104     QEXPECT_FAIL("", "Symlinking using relative paths is currently different on Windows and Unix/Symbian", Continue);

  1105     QCOMPARE(QFileInfo(QFile(QFileInfo("myDir/myLink.lnk").absoluteFilePath()).symLinkTarget()).absoluteFilePath(),

  1106              QFileInfo("myDir/test.txt").absoluteFilePath());

  1107 

  1108     QFile::remove("myDir/test.txt");

  1109     QFile::remove("myDir/myLink.lnk");

  1110     dir.rmdir("myDir");

  1111 }

  1112 

  1113 void tst_QFile::readBrokenLink()

  1114 {

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

  1116     QFileInfo info1("file12");

  1117 #if defined(Q_OS_SYMBIAN)

  1118     // In Symbian can't link to nonexisting file directly, so create the file temporarily

  1119     QFile tempFile("file12");

  1120     tempFile.open(QIODevice::WriteOnly);

  1121     tempFile.link("myLink2.lnk");

  1122     tempFile.remove();

  1123 #else

  1124     QVERIFY(QFile::link("file12", "myLink2.lnk"));

  1125 #endif

  1126     QFileInfo info2("myLink2.lnk");

  1127     QVERIFY(info2.isSymLink());

  1128     QCOMPARE(info2.symLinkTarget(), info1.absoluteFilePath());

  1129     QVERIFY(QFile::remove(info2.absoluteFilePath()));

  1130 

  1131 #if !defined(Q_OS_SYMBIAN)

  1132     QVERIFY(QFile::link("ole/..", "myLink2.lnk"));

  1133     QCOMPARE(QFileInfo("myLink2.lnk").symLinkTarget(), QDir::currentPath());

  1134 #endif