qt 6.5.1 original

tests/benchmarks/corelib/io/qdir/10000/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#####################################################################
+## tst_bench_qdir_10000 Binary:
+#####################################################################
+
+qt_internal_add_benchmark(tst_bench_qdir_10000
+    SOURCES
+        tst_bench_qdir_10000.cpp
+    LIBRARIES
+        Qt::Test
+)

tests/benchmarks/corelib/io/qdir/10000/tst_bench_qdir_10000.cpp

@@ -0,0 +1,185 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <QTest>
+#include <QDirIterator>
+
+#ifdef Q_OS_WIN
+#   include <qt_windows.h>
+#else
+#   include <sys/stat.h>
+#   include <sys/types.h>
+#   include <dirent.h>
+#   include <unistd.h>
+#endif
+
+class tst_QDir_10000 : public QObject
+{
+    Q_OBJECT
+public slots:
+    void initTestCase()
+    {
+        QDir testdir = QDir::tempPath();
+
+        const QString subfolder_name = QLatin1String("test_speed");
+        QVERIFY(testdir.mkdir(subfolder_name));
+        QVERIFY(testdir.cd(subfolder_name));
+
+        for (uint i=0; i<10000; ++i) {
+            QFile file(testdir.absolutePath() + "/testfile_" + QString::number(i));
+            file.open(QIODevice::WriteOnly);
+        }
+    }
+    void cleanupTestCase()
+    {
+        QDir testdir(QDir::tempPath() + QLatin1String("/test_speed"));
+        QVERIFY(testdir.removeRecursively());
+    }
+private slots:
+    void sizeSpeed()
+    {
+        QBENCHMARK {
+            QDir testdir(QDir::tempPath() + QLatin1String("/test_speed"));
+            QFileInfoList fileInfoList = testdir.entryInfoList(QDir::Files, QDir::Unsorted);
+            foreach (const QFileInfo &fileInfo, fileInfoList) {
+                fileInfo.isDir();
+                fileInfo.size();
+            }
+        }
+    }
+    void sizeSpeedIterator()
+    {
+        QBENCHMARK {
+            QDir testdir(QDir::tempPath() + QLatin1String("/test_speed"));
+            QDirIterator dit(testdir.path(), QDir::Files);
+            while (dit.hasNext()) {
+                const auto fi = dit.nextFileInfo();
+                (void)fi.isDir();
+                (void)fi.size();
+            }
+        }
+    }
+
+    void sizeSpeedWithoutFilter()
+    {
+        QBENCHMARK {
+            QDir testdir(QDir::tempPath() + QLatin1String("/test_speed"));
+            QFileInfoList fileInfoList = testdir.entryInfoList(QDir::NoFilter, QDir::Unsorted);
+            foreach (const QFileInfo &fileInfo, fileInfoList) {
+                fileInfo.size();
+            }
+        }
+    }
+    void sizeSpeedWithoutFilterIterator()
+    {
+        QBENCHMARK {
+            QDir testdir(QDir::tempPath() + QLatin1String("/test_speed"));
+            QDirIterator dit(testdir.path());
+            while (dit.hasNext()) {
+                const auto fi = dit.nextFileInfo();
+                (void)fi.isDir();
+                (void)fi.size();
+            }
+        }
+    }
+
+    void sizeSpeedWithoutFileInfoList()
+    {
+        QBENCHMARK {
+            QDir testdir(QDir::tempPath() + QLatin1String("/test_speed"));
+            testdir.setSorting(QDir::Unsorted);
+            QStringList fileList = testdir.entryList(QDir::NoFilter, QDir::Unsorted);
+            foreach (const QString &filename, fileList) {
+                QFileInfo fileInfo(filename);
+                fileInfo.size();
+            }
+        }
+    }
+
+    void iDontWantAnyStat()
+    {
+        QBENCHMARK {
+            QDir testdir(QDir::tempPath() + QLatin1String("/test_speed"));
+            testdir.setSorting(QDir::Unsorted);
+            testdir.setFilter(QDir::AllEntries | QDir::System | QDir::Hidden);
+            QStringList fileList = testdir.entryList(QDir::NoFilter, QDir::Unsorted);
+            foreach (const QString &filename, fileList) {
+                Q_UNUSED(filename);
+            }
+        }
+    }
+    void iDontWantAnyStatIterator()
+    {
+        QBENCHMARK {
+            QDirIterator dit(QDir::tempPath() + QLatin1String("/test_speed"));
+            while (dit.hasNext()) {
+                dit.next();
+            }
+        }
+    }
+
+    void sorted_byTime()
+    {
+        QBENCHMARK {
+            QDir testdir(QDir::tempPath() + QLatin1String("/test_speed"));
+            testdir.setSorting(QDir::Time);
+            testdir.setFilter(QDir::AllEntries | QDir::System | QDir::Hidden);
+            QStringList fileList = testdir.entryList(QDir::NoFilter, QDir::Time);
+            foreach (const QString &filename, fileList) {
+                Q_UNUSED(filename);
+            }
+        }
+    }
+
+    void sorted_byName()
+    {
+        QBENCHMARK {
+            QDir testdir(QDir::tempPath() + QLatin1String("/test_speed"));
+            testdir.setFilter(QDir::AllEntries | QDir::System | QDir::Hidden);
+            [[maybe_unused]] auto r = testdir.entryInfoList(QDir::NoFilter, QDir::Name);
+        }
+    }
+
+    void sizeSpeedWithoutFilterLowLevel()
+    {
+        QDir testdir(QDir::tempPath() + QLatin1String("/test_speed"));
+#ifdef Q_OS_WIN
+        const wchar_t *dirpath = (wchar_t*)testdir.absolutePath().utf16();
+        wchar_t appendedPath[MAX_PATH];
+        wcscpy(appendedPath, dirpath);
+        wcscat(appendedPath, L"\\*");
+
+        QBENCHMARK {
+            WIN32_FIND_DATA fd;
+            HANDLE hSearch = FindFirstFileW(appendedPath, &fd);
+            QVERIFY(hSearch != INVALID_HANDLE_VALUE);
+
+            do {
+
+            } while (FindNextFile(hSearch, &fd));
+            FindClose(hSearch);
+        }
+#else
+        QVERIFY(!chdir(qPrintable(testdir.absolutePath())));
+        QBENCHMARK {
+            DIR *dir = opendir(qPrintable(testdir.absolutePath()));
+            QVERIFY(dir);
+
+            struct dirent *item = readdir(dir);
+            while (item) {
+                char *fileName = item->d_name;
+
+                struct stat fileStat;
+                QVERIFY(!stat(fileName, &fileStat));
+
+                item = readdir(dir);
+            }
+            closedir(dir);
+        }
+#endif
+    }
+};
+
+QTEST_MAIN(tst_QDir_10000)
+
+#include "tst_bench_qdir_10000.moc"

tests/benchmarks/corelib/io/qdir/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_subdirectory(10000)
+add_subdirectory(tree)

tests/benchmarks/corelib/io/qdir/tree/CMakeLists.txt

@@ -0,0 +1,25 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#####################################################################
+## tst_bench_qdir_tree Binary:
+#####################################################################
+
+qt_internal_add_benchmark(tst_bench_qdir_tree
+    SOURCES
+        tst_bench_qdir_tree.cpp
+    LIBRARIES
+        Qt::Test
+)
+
+# Resources:
+set(qdir_tree_resource_files
+    "4.6.0-list.txt"
+)
+
+qt_internal_add_resource(tst_bench_qdir_tree "tst_bench_qdir_tree"
+    PREFIX
+        "/"
+    FILES
+        ${qdir_tree_resource_files}
+)

tests/benchmarks/corelib/io/qdir/tree/tst_bench_qdir_tree.cpp

@@ -0,0 +1,201 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <QtTest/QTest>
+
+#include <QDirIterator>
+#include <QFile>
+#include <QString>
+#include <QStack>
+
+#include "../../../../../shared/filesystem.h"
+
+class tst_QDir_tree
+    : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QDir_tree()
+        : prefix("test-tree/"),
+          musicprefix(QLatin1String("music")),
+          photoprefix(QLatin1String("photos")),
+          sourceprefix(QLatin1String("source")),
+          musicsize(0),
+          photosize(0),
+          sourcesize(0)
+    {
+    }
+
+private:
+    QByteArray prefix;
+    QString musicprefix;
+    QString photoprefix;
+    QString sourceprefix;
+    qint64 musicsize;
+    qint64 photosize;
+    qint64 sourcesize;
+    FileSystem fs; // Uses QTemporaryDir to tidy away file tree created.
+
+private slots:
+    void initTestCase()
+    {
+        QFile list(":/4.6.0-list.txt");
+        QVERIFY(list.open(QIODevice::ReadOnly | QIODevice::Text));
+
+        QVERIFY(fs.createDirectory(prefix));
+
+        QStack<QByteArray> stack;
+        QByteArray line;
+        while (true) {
+            char ch;
+            if (!list.getChar(&ch))
+                break;
+            if (ch != ' ') {
+                line.append(ch);
+                continue;
+            }
+
+            int pop = 1;
+            if (!line.isEmpty())
+                pop = line.toInt();
+
+            while (pop) {
+                stack.pop();
+                --pop;
+            }
+
+            line = list.readLine().trimmed();
+            stack.push(line);
+
+            line = prefix;
+            for (const QByteArray &pathElement : std::as_const(stack))
+                line += pathElement;
+
+            if (line.endsWith('/'))
+                QVERIFY(fs.createDirectory(line));
+            else
+                QVERIFY(fs.createFile(line));
+
+            line.clear();
+        }
+
+        //Use case: music collection - 10 files in 100 directories (albums)
+        QVERIFY(fs.createDirectory(musicprefix));
+        for (int i=0;i<1000;i++) {
+            if ((i % 10) == 0)
+                QVERIFY(fs.createDirectory(QString("%1/directory%2").arg(musicprefix).arg(i/10)));
+            qint64 size = fs.createFileWithContent(QString("%1/directory%2/file%3").arg(musicprefix).arg(i/10).arg(i));
+            QVERIFY(size > 0);
+            musicsize += size;
+        }
+        //Use case: photos - 1000 files in 1 directory
+        QVERIFY(fs.createDirectory(photoprefix));
+        for (int i=0;i<1000;i++) {
+            qint64 size = fs.createFileWithContent(QString("%1/file%2").arg(photoprefix).arg(i));
+            QVERIFY(size > 0);
+            photosize += size;
+        }
+        //Use case: source - 10 files in 10 subdirectories in 10 directories (1000 total)
+        QVERIFY(fs.createDirectory(sourceprefix));
+        for (int i=0;i<1000;i++) {
+            if ((i % 100) == 0)
+                QVERIFY(fs.createDirectory(QString("%1/directory%2").arg(sourceprefix).arg(i/100)));
+            if ((i % 10) == 0)
+                QVERIFY(fs.createDirectory(QString("%1/directory%2/subdirectory%3").arg(sourceprefix).arg(i/100).arg(i/10)));
+            qint64 size = fs.createFileWithContent(QString("%1/directory%2/subdirectory%3/file%4").arg(sourceprefix).arg(i/100).arg(i/10).arg(i));
+            QVERIFY(size > 0);
+            sourcesize += size;
+        }
+    }
+
+    void fileSearch_data() const
+    {
+        QTest::addColumn<QStringList>("nameFilters");
+        QTest::addColumn<int>("filter");
+        QTest::addColumn<int>("entryCount");
+
+        QTest::newRow("*.cpp") << QStringList("*.cpp") << int(QDir::Files) << 3791;
+        QTest::newRow("executables")
+            << QStringList("*")
+            << int(QDir::Executable | QDir::Files | QDir::AllDirs | QDir::NoDotAndDotDot)
+            << 536;
+    }
+
+    void fileSearch() const
+    {
+        QFETCH(QStringList, nameFilters);
+        QFETCH(int, filter);
+        QFETCH(int, entryCount);
+
+        int count = 0;
+        QBENCHMARK {
+            // Recursive directory iteration
+            QDirIterator iterator(fs.absoluteFilePath(prefix),
+                                  nameFilters, QDir::Filter(filter),
+                                  QDirIterator::Subdirectories | QDirIterator::FollowSymlinks);
+
+            count = 0;
+            while (iterator.hasNext()) {
+                iterator.next();
+                ++count;
+            }
+
+            QCOMPARE(count, entryCount);
+        }
+
+        QCOMPARE(count, entryCount);
+    }
+
+    void traverseDirectory() const
+    {
+        int count = 0;
+        QBENCHMARK {
+            QDirIterator iterator(
+                    fs.absoluteFilePath(prefix),
+                    QDir::AllEntries | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System,
+                    QDirIterator::Subdirectories | QDirIterator::FollowSymlinks);
+
+            count = 0;
+            while (iterator.hasNext()) {
+                iterator.next();
+                ++count;
+            }
+
+            QCOMPARE(count, 11906);
+        }
+
+        QCOMPARE(count, 11906);
+    }
+
+    void thousandFiles_data() const
+    {
+        QTest::addColumn<QString>("dirName");
+        QTest::addColumn<qint64>("expectedSize");
+        QTest::newRow("music") << musicprefix << musicsize;
+        QTest::newRow("photos") << photoprefix << photosize;
+        QTest::newRow("src") << sourceprefix << sourcesize;
+    }
+
+    void thousandFiles() const
+    {
+        QFETCH(QString, dirName);
+        QFETCH(qint64, expectedSize);
+        QBENCHMARK {
+            qint64 totalsize = 0;
+            int count = 0;
+            QDirIterator iter(fs.absoluteFilePath(dirName),
+                              QDir::Files, QDirIterator::Subdirectories);
+            while(iter.hasNext()) {
+                count++;
+                totalsize += iter.nextFileInfo().size();
+            }
+            QCOMPARE(count, 1000);
+            QCOMPARE(totalsize, expectedSize);
+        }
+    }
+};
+
+QTEST_MAIN(tst_QDir_tree)
+
+#include "tst_bench_qdir_tree.moc"

tests/benchmarks/corelib/io/qdir/tree/tst_bench_qdir_tree.qrc

@@ -0,0 +1,5 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+    <file>4.6.0-list.txt</file>
+</qresource>
+</RCC>