tests/benchmarks/qfile/main.cpp
changeset 3 41300fa6a67c
parent 0 1918ee327afb
child 4 3b1da2848fc7
equal deleted inserted replaced
2:56cd8111b7f7 3:41300fa6a67c
   126     void removeSmallFiles();
   126     void removeSmallFiles();
   127     QString filename;
   127     QString filename;
   128     QString tmpDirName;
   128     QString tmpDirName;
   129 };
   129 };
   130 
   130 
       
   131 Q_DECLARE_METATYPE(tst_qfile::BenchmarkType)
       
   132 Q_DECLARE_METATYPE(QIODevice::OpenMode)
       
   133 Q_DECLARE_METATYPE(QIODevice::OpenModeFlag)
       
   134 
   131 void tst_qfile::createFile()
   135 void tst_qfile::createFile()
   132 {
   136 {
       
   137     removeFile();  // Cleanup in case previous test case aborted before cleaning up
       
   138 
   133     QTemporaryFile tmpFile;
   139     QTemporaryFile tmpFile;
   134     tmpFile.setAutoRemove(false);
   140     tmpFile.setAutoRemove(false);
   135     if (!tmpFile.open())
   141     if (!tmpFile.open())
   136         ::_exit(1);
   142         ::exit(1);
   137     filename = tmpFile.fileName();
   143     filename = tmpFile.fileName();
   138     tmpFile.close();
   144     tmpFile.close();
   139 }
   145 }
   140 
   146 
   141 void tst_qfile::removeFile()
   147 void tst_qfile::removeFile()
   215     if (b & QIODevice::Unbuffered) flagstring += "unbuffered ";
   221     if (b & QIODevice::Unbuffered) flagstring += "unbuffered ";
   216     if (flagstring.isEmpty())      flagstring = "none";
   222     if (flagstring.isEmpty())      flagstring = "none";
   217 
   223 
   218     for (int i=0; i<bs_entries; ++i)
   224     for (int i=0; i<bs_entries; ++i)
   219         QTest::newRow((QString("BS: %1, Flags: %2" )).arg(bs[i]).arg(flagstring).toLatin1().constData()) << type << bs[i] << t << b;
   225         QTest::newRow((QString("BS: %1, Flags: %2" )).arg(bs[i]).arg(flagstring).toLatin1().constData()) << type << bs[i] << t << b;
   220   
       
   221 }
   226 }
   222 
   227 
   223 void tst_qfile::readBigFile()
   228 void tst_qfile::readBigFile()
   224 {
   229 {
   225     QFETCH(tst_qfile::BenchmarkType, testType);
   230     QFETCH(tst_qfile::BenchmarkType, testType);
   226     QFETCH(int, blockSize);
   231     QFETCH(int, blockSize);
   227     QFETCH(QFile::OpenModeFlag, textMode);
   232     QFETCH(QFile::OpenModeFlag, textMode);
   228     QFETCH(QFile::OpenModeFlag, bufferedMode);
   233     QFETCH(QFile::OpenModeFlag, bufferedMode);
   229 
   234 
   230     char buffer[BUFSIZE]; // we can't allocate buffers nice and dynamically in c++
   235 #ifndef Q_OS_WIN
   231     removeFile();
   236     if (testType == Win32Benchmark)
       
   237         QSKIP("This is Windows only benchmark.", SkipSingle);
       
   238 #endif
       
   239 
       
   240     char *buffer = new char[BUFSIZE];
   232     createFile();
   241     createFile();
   233     fillFile();
   242     fillFile();
   234 
   243 
   235     switch (testType) {
   244     switch (testType) {
   236         case(QFileBenchmark): {
   245         case(QFileBenchmark): {
   295             QFAIL("Not running on a non-Windows platform!");
   304             QFAIL("Not running on a non-Windows platform!");
   296 #endif
   305 #endif
   297         }
   306         }
   298         break;
   307         break;
   299     }
   308     }
       
   309 
       
   310     removeFile();
       
   311     delete[] buffer;
   300 }
   312 }
   301 
   313 
   302 void tst_qfile::seek_data()
   314 void tst_qfile::seek_data()
   303 {
   315 {
   304     QTest::addColumn<tst_qfile::BenchmarkType>("testType");
   316     QTest::addColumn<tst_qfile::BenchmarkType>("testType");
   372             QFAIL("Not running on a Windows plattform!");
   384             QFAIL("Not running on a Windows plattform!");
   373 #endif
   385 #endif
   374         }
   386         }
   375         break;
   387         break;
   376     }
   388     }
       
   389 
       
   390     removeFile();
   377 }
   391 }
   378 
   392 
   379 void tst_qfile::open_data()
   393 void tst_qfile::open_data()
   380 {
   394 {
   381     QTest::addColumn<tst_qfile::BenchmarkType>("testType");
   395     QTest::addColumn<tst_qfile::BenchmarkType>("testType");
   390 
   404 
   391 void tst_qfile::open()
   405 void tst_qfile::open()
   392 {
   406 {
   393     QFETCH(tst_qfile::BenchmarkType, testType);
   407     QFETCH(tst_qfile::BenchmarkType, testType);
   394 
   408 
   395     removeFile();
       
   396     createFile();
   409     createFile();
   397 
   410 
   398     switch (testType) {
   411     switch (testType) {
   399         case(QFileBenchmark): {
   412         case(QFileBenchmark): {
   400             QBENCHMARK {
   413             QBENCHMARK {
   433             QBENCHMARK {
   446             QBENCHMARK {
   434                 QFile file;
   447                 QFile file;
   435                 file.open(cfile, QIODevice::ReadOnly);
   448                 file.open(cfile, QIODevice::ReadOnly);
   436                 file.close();
   449                 file.close();
   437             }
   450             }
       
   451             ::fclose(cfile);
   438         }
   452         }
   439         break;
   453         break;
   440         case(Win32Benchmark): {
   454         case(Win32Benchmark): {
   441 #ifdef Q_OS_WIN
   455 #ifdef Q_OS_WIN
   442             HANDLE hndl;
   456             HANDLE hndl;
   454 #endif
   468 #endif
   455         }
   469         }
   456         break;
   470         break;
   457     }
   471     }
   458 
   472 
       
   473     removeFile();
   459 }
   474 }
   460 
   475 
   461 
   476 
   462 void tst_qfile::readSmallFiles_QFile() { readSmallFiles(); }
   477 void tst_qfile::readSmallFiles_QFile() { readSmallFiles(); }
   463 void tst_qfile::readSmallFiles_QFSFileEngine() { readSmallFiles(); }
   478 void tst_qfile::readSmallFiles_QFSFileEngine() { readSmallFiles(); }
   513 }
   528 }
   514 
   529 
   515 void tst_qfile::createSmallFiles()
   530 void tst_qfile::createSmallFiles()
   516 {
   531 {
   517     QDir dir = QDir::temp();
   532     QDir dir = QDir::temp();
   518     Q_ASSERT(dir.mkdir("tst"));
   533     dir.mkdir("tst");
   519     dir.cd("tst");
   534     dir.cd("tst");
   520     tmpDirName = dir.absolutePath();
   535     tmpDirName = dir.absolutePath();
   521 
   536 
       
   537 #ifdef Q_OS_SYMBIAN
       
   538     for (int i = 0; i < 100; ++i)
       
   539 #else
   522     for (int i = 0; i < 1000; ++i)
   540     for (int i = 0; i < 1000; ++i)
       
   541 #endif
   523     {
   542     {
   524         QFile f(tmpDirName+"/"+QString::number(i));
   543         QFile f(tmpDirName+"/"+QString::number(i));
   525         f.open(QIODevice::WriteOnly);
   544         f.open(QIODevice::WriteOnly);
   526         f.seek(512);
   545         f.seek(511);
       
   546         f.putChar('\n');
   527         f.close();
   547         f.close();
   528     }
   548     }
   529 }
   549 }
   530 
   550 
   531 void tst_qfile::removeSmallFiles()
   551 void tst_qfile::removeSmallFiles()
   542     QFETCH(tst_qfile::BenchmarkType, testType);
   562     QFETCH(tst_qfile::BenchmarkType, testType);
   543     QFETCH(int, blockSize);
   563     QFETCH(int, blockSize);
   544     QFETCH(QFile::OpenModeFlag, textMode);
   564     QFETCH(QFile::OpenModeFlag, textMode);
   545     QFETCH(QFile::OpenModeFlag, bufferedMode);
   565     QFETCH(QFile::OpenModeFlag, bufferedMode);
   546 
   566 
   547     removeSmallFiles();
   567 #ifndef Q_OS_WIN
       
   568     if (testType == Win32Benchmark)
       
   569         QSKIP("This is Windows only benchmark.", SkipSingle);
       
   570 #endif
       
   571 
   548     createSmallFiles();
   572     createSmallFiles();
       
   573 
   549     QDir dir(tmpDirName);
   574     QDir dir(tmpDirName);
   550     const QStringList files = dir.entryList(QDir::NoDotAndDotDot|QDir::NoSymLinks);
   575     const QStringList files = dir.entryList(QDir::NoDotAndDotDot|QDir::NoSymLinks|QDir::Files);
   551     char buffer[BUFSIZE]; // we can't allocate buffers nice and dynamically in c++
   576     char *buffer = new char[BUFSIZE];
   552 
   577 
   553     switch (testType) {
   578     switch (testType) {
   554         case(QFileBenchmark): {
   579         case(QFileBenchmark): {
   555             QList<QFile*> fileList;
   580             QList<QFile*> fileList;
   556             Q_FOREACH(QString file, files) {
   581             Q_FOREACH(QString file, files) {
   557                 QFile *f = new QFile(file);
   582                 QFile *f = new QFile(tmpDirName+ "/" + file);
   558                 f->open(QIODevice::ReadOnly|textMode|bufferedMode);
   583                 f->open(QIODevice::ReadOnly|textMode|bufferedMode);
   559                 fileList.append(f);
   584                 fileList.append(f);
   560             }
   585             }
   561 
   586 
   562             QBENCHMARK {
   587             QBENCHMARK {
   574         }
   599         }
   575         break;
   600         break;
   576         case(QFSFileEngineBenchmark): {
   601         case(QFSFileEngineBenchmark): {
   577             QList<QFSFileEngine*> fileList;
   602             QList<QFSFileEngine*> fileList;
   578             Q_FOREACH(QString file, files) {
   603             Q_FOREACH(QString file, files) {
   579                 QFSFileEngine *fse = new QFSFileEngine(file);
   604                 QFSFileEngine *fse = new QFSFileEngine(tmpDirName+ "/" + file);
   580                 fse->open(QIODevice::ReadOnly|textMode|bufferedMode);
   605                 fse->open(QIODevice::ReadOnly|textMode|bufferedMode);
   581                 fileList.append(fse);
   606                 fileList.append(fse);
   582             }
   607             }
   583 
   608 
   584             QBENCHMARK {
   609             QBENCHMARK {
   594         }
   619         }
   595         break;
   620         break;
   596         case(PosixBenchmark): {
   621         case(PosixBenchmark): {
   597             QList<FILE*> fileList;
   622             QList<FILE*> fileList;
   598             Q_FOREACH(QString file, files) {
   623             Q_FOREACH(QString file, files) {
   599                 fileList.append(::fopen(QFile::encodeName(file).constData(), "rb"));
   624                 fileList.append(::fopen(QFile::encodeName(tmpDirName+ "/" + file).constData(), "rb"));
   600             }
   625             }
   601 
   626 
   602             QBENCHMARK {
   627             QBENCHMARK {
   603                 Q_FOREACH(FILE* cfile, fileList) {
   628                 Q_FOREACH(FILE* cfile, fileList) {
   604                     while(!feof(cfile))
   629                     while(!feof(cfile))
   638             QFAIL("Not running on a non-Windows platform!");
   663             QFAIL("Not running on a non-Windows platform!");
   639 #endif
   664 #endif
   640         }
   665         }
   641         break;
   666         break;
   642     }
   667     }
   643 }
   668 
   644 
   669     removeSmallFiles();
   645 Q_DECLARE_METATYPE(tst_qfile::BenchmarkType)
   670     delete[] buffer;
   646 Q_DECLARE_METATYPE(QIODevice::OpenMode)
   671 }
   647 Q_DECLARE_METATYPE(QIODevice::OpenModeFlag)
       
   648 
   672 
   649 QTEST_MAIN(tst_qfile)
   673 QTEST_MAIN(tst_qfile)
   650 
   674 
   651 #include "main.moc"
   675 #include "main.moc"