--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/auto/qfilesystemwatcher/tst_qfilesystemwatcher.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,536 @@
+/****************************************************************************
+**
+** 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 <QCoreApplication>
+
+#include <QFileSystemWatcher>
+
+#ifdef Q_OS_LINUX
+# ifdef QT_NO_INOTIFY
+# include <linux/version.h>
+# else
+# include <sys/inotify.h>
+# endif
+#endif
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QFileSystemWatcher : public QObject
+{
+ Q_OBJECT
+
+public:
+ tst_QFileSystemWatcher();
+
+private slots:
+ void basicTest_data();
+ void basicTest();
+
+ void watchDirectory_data() { basicTest_data(); }
+ void watchDirectory();
+
+ void addPath();
+ void removePath();
+ void addPaths();
+ void removePaths();
+
+ void watchFileAndItsDirectory_data() { basicTest_data(); }
+ void watchFileAndItsDirectory();
+
+ void nonExistingFile();
+
+ void cleanup();
+private:
+ QStringList do_force_engines;
+ bool do_force_native;
+};
+
+tst_QFileSystemWatcher::tst_QFileSystemWatcher()
+ : do_force_native(false)
+{
+#ifdef Q_OS_LINUX
+ // the inotify implementation in the kernel is known to be buggy in certain versions of the linux kernel
+ do_force_engines << "native";
+ do_force_engines << "dnotify";
+
+#ifdef QT_NO_INOTIFY
+ if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13))
+ do_force_engines << "inotify";
+#else
+ if (inotify_init() != -1)
+ do_force_engines << "inotify";
+#endif
+#elif defined(Q_OS_WIN) || defined(Q_OS_DARWIN) || defined(Q_OS_FREEBSD) || defined(Q_OS_SYMBIAN)
+ // we have native engines for win32, macosx and freebsd
+ do_force_engines << "native";
+#endif
+}
+
+void tst_QFileSystemWatcher::basicTest_data()
+{
+ QTest::addColumn<QString>("backend");
+ foreach(QString engine, do_force_engines)
+ QTest::newRow(engine.toLatin1().constData()) << engine;
+ QTest::newRow("poller") << "poller";
+}
+
+void tst_QFileSystemWatcher::basicTest()
+{
+ QFETCH(QString, backend);
+ qDebug() << "Testing" << backend << "engine";
+
+ // create test file
+ QFile testFile("testfile.txt");
+ testFile.setPermissions(QFile::ReadOwner | QFile::WriteOwner);
+ testFile.remove();
+ QVERIFY(testFile.open(QIODevice::WriteOnly | QIODevice::Truncate));
+ testFile.write(QByteArray("hello"));
+ testFile.close();
+
+ // set some file permissions
+ testFile.setPermissions(QFile::ReadOwner | QFile::WriteOwner);
+
+ // create watcher, forcing it to use a specific backend
+ QFileSystemWatcher watcher;
+ watcher.setObjectName(QLatin1String("_qt_autotest_force_engine_") + backend);
+ watcher.addPath(testFile.fileName());
+
+ QSignalSpy changedSpy(&watcher, SIGNAL(fileChanged(const QString &)));
+ QEventLoop eventLoop;
+ connect(&watcher,
+ SIGNAL(fileChanged(const QString &)),
+ &eventLoop,
+ SLOT(quit()));
+ QTimer timer;
+ connect(&timer, SIGNAL(timeout()), &eventLoop, SLOT(quit()));
+
+ // modify the file, should get a signal from the watcher
+
+ // resolution of the modification time is system dependent, but it's at most 1 second when using
+ // the polling engine. I've heard rumors that FAT32 has a 2 second resolution. So, we have to
+ // wait a bit before we can modify the file (hrmph)...
+#ifndef Q_OS_WINCE
+ QTest::qWait(2000);
+#else
+ // WinCE is always a little bit slower. Give it a little bit more time
+ QTest::qWait(5000);
+#endif
+
+ testFile.open(QIODevice::WriteOnly | QIODevice::Append);
+ testFile.write(QByteArray("world"));
+ testFile.close();
+
+ // qDebug() << "waiting max 5 seconds for notification for file modification to trigger(1)";
+ timer.start(5000);
+ eventLoop.exec();
+
+ QCOMPARE(changedSpy.count(), 1);
+ QCOMPARE(changedSpy.at(0).count(), 1);
+
+ QString fileName = changedSpy.at(0).at(0).toString();
+ QCOMPARE(fileName, testFile.fileName());
+
+ changedSpy.clear();
+
+ // remove the watch and modify the file, should not get a signal from the watcher
+ watcher.removePath(testFile.fileName());
+ testFile.open(QIODevice::WriteOnly | QIODevice::Truncate);
+ testFile.write(QByteArray("hello universe!"));
+ testFile.close();
+
+ // qDebug() << "waiting max 5 seconds for notification for file modification to trigger (2)";
+ timer.start(5000);
+ eventLoop.exec();
+
+ QCOMPARE(changedSpy.count(), 0);
+
+ // readd the file watch with a relative path
+ watcher.addPath(testFile.fileName().prepend("./"));
+ testFile.open(QIODevice::WriteOnly | QIODevice::Truncate);
+ testFile.write(QByteArray("hello multiverse!"));
+ testFile.close();
+
+ timer.start(5000);
+ eventLoop.exec();
+
+ QVERIFY(changedSpy.count() > 0);
+
+ watcher.removePath(testFile.fileName().prepend("./"));
+
+ changedSpy.clear();
+
+ // readd the file watch
+ watcher.addPath(testFile.fileName());
+
+ // change the permissions, should get a signal from the watcher
+ testFile.setPermissions(QFile::ReadOwner);
+
+ // qDebug() << "waiting max 5 seconds for notification for file permission modification to trigger(1)";
+ timer.start(5000);
+ eventLoop.exec();
+
+ QCOMPARE(changedSpy.count(), 1);
+ QCOMPARE(changedSpy.at(0).count(), 1);
+
+ fileName = changedSpy.at(0).at(0).toString();
+ QCOMPARE(fileName, testFile.fileName());
+
+ changedSpy.clear();
+
+ // remove the watch and modify file permissions, should not get a signal from the watcher
+ watcher.removePath(testFile.fileName());
+ testFile.setPermissions(QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOther);
+
+ // qDebug() << "waiting max 5 seconds for notification for file modification to trigger (2)";
+ timer.start(5000);
+ eventLoop.exec();
+
+ QCOMPARE(changedSpy.count(), 0);
+
+ // readd the file watch
+ watcher.addPath(testFile.fileName());
+
+ // remove the file, should get a signal from the watcher
+ QVERIFY(testFile.remove());
+
+ // qDebug() << "waiting max 5 seconds for notification for file removal to trigger";
+ timer.start(5000);
+ eventLoop.exec();
+
+ QVERIFY(changedSpy.count() == 1 || changedSpy.count() == 2); // removing a file on some filesystems seems to deliver 2 notifications
+ QCOMPARE(changedSpy.at(0).count(), 1);
+
+ fileName = changedSpy.at(0).at(0).toString();
+ QCOMPARE(fileName, testFile.fileName());
+
+ changedSpy.clear();
+
+ // recreate the file, we should not get any notification
+ QVERIFY(testFile.open(QIODevice::WriteOnly | QIODevice::Truncate));
+ testFile.write(QByteArray("hello"));
+ testFile.close();
+
+ // qDebug() << "waiting max 5 seconds for notification for file recreation to trigger";
+ timer.start(5000);
+ eventLoop.exec();
+
+ QCOMPARE(changedSpy.count(), 0);
+
+ QVERIFY(testFile.remove());
+}
+
+void tst_QFileSystemWatcher::watchDirectory()
+{
+ QFETCH(QString, backend);
+ qDebug() << "Testing" << backend << "engine";
+
+ QDir().mkdir("testDir");
+ QDir testDir("testDir");
+
+ QString testFileName = testDir.filePath("testFile.txt");
+ QFile::remove(testFileName);
+
+ QFileSystemWatcher watcher;
+ watcher.setObjectName(QLatin1String("_qt_autotest_force_engine_") + backend);
+ watcher.addPath(testDir.dirName());
+
+ QSignalSpy changedSpy(&watcher, SIGNAL(directoryChanged(const QString &)));
+ QEventLoop eventLoop;
+ connect(&watcher,
+ SIGNAL(directoryChanged(const QString &)),
+ &eventLoop,
+ SLOT(quit()));
+ QTimer timer;
+ connect(&timer, SIGNAL(timeout()), &eventLoop, SLOT(quit()));
+
+ // resolution of the modification time is system dependent, but it's at most 1 second when using
+ // the polling engine. From what I know, FAT32 has a 2 second resolution. So we have to
+ // wait before modifying the directory...
+ QTest::qWait(2000);
+ QFile testFile(testFileName);
+ QString fileName;
+
+ // remove the watch, should not get notification of a new file
+ watcher.removePath(testDir.dirName());
+ QVERIFY(testFile.open(QIODevice::WriteOnly | QIODevice::Truncate));
+ testFile.close();
+
+ // qDebug() << "waiting max 5 seconds for notification for file recreationg to trigger";
+ timer.start(5000);
+ eventLoop.exec();
+
+ QCOMPARE(changedSpy.count(), 0);
+
+ watcher.addPath(testDir.dirName());
+
+ // remove the file again, should get a signal from the watcher
+ QVERIFY(testFile.remove());
+
+ timer.start(5000);
+ eventLoop.exec();
+
+ // remove the directory, should get a signal from the watcher
+ QVERIFY(QDir().rmdir("testDir"));
+
+ // qDebug() << "waiting max 5 seconds for notification for directory removal to trigger";
+ timer.start(5000);
+ eventLoop.exec();
+
+#ifdef Q_OS_WINCE
+ QEXPECT_FAIL("poller", "Directory does not get updated on file removal(See #137910)", Abort);
+#endif
+ QCOMPARE(changedSpy.count(), 2);
+ QCOMPARE(changedSpy.at(0).count(), 1);
+ QCOMPARE(changedSpy.at(1).count(), 1);
+
+ fileName = changedSpy.at(0).at(0).toString();
+ QCOMPARE(fileName, testDir.dirName());
+ fileName = changedSpy.at(1).at(0).toString();
+ QCOMPARE(fileName, testDir.dirName());
+
+ changedSpy.clear();
+
+ // recreate the file, we should not get any notification
+ if (!QDir().mkdir("testDir"))
+ QSKIP("Failed to recreate directory, skipping final test.", SkipSingle);
+
+ // qDebug() << "waiting max 5 seconds for notification for dir recreation to trigger";
+ timer.start(5000);
+ eventLoop.exec();
+
+ QCOMPARE(changedSpy.count(), 0);
+
+ QVERIFY(QDir().rmdir("testDir"));
+}
+
+void tst_QFileSystemWatcher::addPath()
+{
+ QFileSystemWatcher watcher;
+ QString home = QDir::homePath();
+ watcher.addPath(home);
+ QCOMPARE(watcher.directories().count(), 1);
+ QCOMPARE(watcher.directories().first(), home);
+ watcher.addPath(home);
+ QCOMPARE(watcher.directories().count(), 1);
+
+ // With empty string
+ QTest::ignoreMessage(QtWarningMsg, "QFileSystemWatcher::addPath: path is empty");
+ watcher.addPath(QString());
+}
+
+void tst_QFileSystemWatcher::removePath()
+{
+ QFileSystemWatcher watcher;
+ QString home = QDir::homePath();
+ watcher.addPath(home);
+ watcher.removePath(home);
+ QCOMPARE(watcher.directories().count(), 0);
+ watcher.removePath(home);
+ QCOMPARE(watcher.directories().count(), 0);
+
+ // With empty string
+ QTest::ignoreMessage(QtWarningMsg, "QFileSystemWatcher::removePath: path is empty");
+ watcher.removePath(QString());
+}
+
+void tst_QFileSystemWatcher::addPaths()
+{
+ QFileSystemWatcher watcher;
+ QStringList paths;
+ paths << QDir::homePath() << QDir::currentPath();
+ watcher.addPaths(paths);
+ QCOMPARE(watcher.directories().count(), 2);
+
+ // With empty list
+ paths.clear();
+ QTest::ignoreMessage(QtWarningMsg, "QFileSystemWatcher::addPaths: list is empty");
+ watcher.addPaths(paths);
+}
+
+void tst_QFileSystemWatcher::removePaths()
+{
+ QFileSystemWatcher watcher;
+ QStringList paths;
+ paths << QDir::homePath() << QDir::currentPath();
+ watcher.addPaths(paths);
+ QCOMPARE(watcher.directories().count(), 2);
+ watcher.removePaths(paths);
+ QCOMPARE(watcher.directories().count(), 0);
+
+ //With empty list
+ paths.clear();
+ QTest::ignoreMessage(QtWarningMsg, "QFileSystemWatcher::removePaths: list is empty");
+ watcher.removePaths(paths);
+}
+
+#if 0
+class SignalTest : public QObject {
+ Q_OBJECT;
+ public slots:
+ void fileSlot(const QString &file) { qDebug() << "file " << file;}
+ void dirSlot(const QString &dir) { qDebug() << "dir" << dir;}
+};
+#endif
+
+void tst_QFileSystemWatcher::watchFileAndItsDirectory()
+{
+ QFETCH(QString, backend);
+ QDir().mkdir("testDir");
+ QDir testDir("testDir");
+
+ QString testFileName = testDir.filePath("testFile.txt");
+ QString secondFileName = testDir.filePath("testFile2.txt");
+ QFile::remove(secondFileName);
+
+ QFile testFile(testFileName);
+ testFile.setPermissions(QFile::ReadOwner | QFile::WriteOwner);
+ testFile.remove();
+
+ QVERIFY(testFile.open(QIODevice::WriteOnly | QIODevice::Truncate));
+ testFile.write(QByteArray("hello"));
+ testFile.close();
+
+ QFileSystemWatcher watcher;
+ watcher.setObjectName(QLatin1String("_qt_autotest_force_engine_") + backend);
+
+ watcher.addPath(testDir.dirName());
+ watcher.addPath(testFileName);
+
+ /*
+ SignalTest signalTest;
+ QObject::connect(&watcher, SIGNAL(fileChanged(const QString &)), &signalTest, SLOT(fileSlot(const QString &)));
+ QObject::connect(&watcher, SIGNAL(directoryChanged(const QString &)), &signalTest, SLOT(dirSlot(const QString &)));
+ */
+
+ QSignalSpy fileChangedSpy(&watcher, SIGNAL(fileChanged(const QString &)));
+ QSignalSpy dirChangedSpy(&watcher, SIGNAL(directoryChanged(const QString &)));
+ QEventLoop eventLoop;
+ QTimer timer;
+ connect(&timer, SIGNAL(timeout()), &eventLoop, SLOT(quit()));
+
+ // resolution of the modification time is system dependent, but it's at most 1 second when using
+ // the polling engine. From what I know, FAT32 has a 2 second resolution. So we have to
+ // wait before modifying the directory...
+ QTest::qWait(2000);
+
+ QVERIFY(testFile.open(QIODevice::WriteOnly | QIODevice::Truncate));
+ testFile.write(QByteArray("hello again"));
+ testFile.close();
+
+ timer.start(3000);
+ eventLoop.exec();
+ QVERIFY(fileChangedSpy.count() > 0);
+ //according to Qt 4 documentation:
+ //void QFileSystemWatcher::directoryChanged ( const QString & path ) [signal]
+ //This signal is emitted when the directory at a specified path, is modified
+ //(e.g., when a file is added, -->modified<-- or deleted) or removed from disk.
+ //Note that if there are several changes during a short period of time, some
+ //of the changes might not emit this signal. However, the last change in the
+ //sequence of changes will always generate this signal.
+ //Symbian behaves as documented (and can't be filtered), but the other platforms don't
+ //so test should not assert this
+ QVERIFY(dirChangedSpy.count() < 2);
+
+ if (backend == "dnotify")
+ QSKIP("dnotify is broken, skipping the rest of the test.", SkipSingle);
+
+ fileChangedSpy.clear();
+ dirChangedSpy.clear();
+ QFile secondFile(secondFileName);
+ secondFile.open(QIODevice::WriteOnly | QIODevice::Truncate);
+ secondFile.write("Foo");
+ secondFile.close();
+
+ timer.start(3000);
+ eventLoop.exec();
+ QCOMPARE(fileChangedSpy.count(), 0);
+#ifdef Q_OS_WINCE
+ QEXPECT_FAIL("poller", "Directory does not get updated on file removal(See #137910)", Abort);
+#endif
+ QCOMPARE(dirChangedSpy.count(), 1);
+
+ dirChangedSpy.clear();
+
+ QFile::remove(testFileName);
+
+ timer.start(3000);
+ eventLoop.exec();
+ QVERIFY(fileChangedSpy.count() > 0);
+ QCOMPARE(dirChangedSpy.count(), 1);
+
+ fileChangedSpy.clear();
+ dirChangedSpy.clear();
+
+ watcher.removePath(testFileName);
+ QFile::remove(secondFileName);
+
+ timer.start(3000);
+ eventLoop.exec();
+ QCOMPARE(fileChangedSpy.count(), 0);
+ // polling watcher has generated separate events for content and time change
+ // on Symbian emulator, so allow possibility of 2 events
+ QVERIFY(dirChangedSpy.count() == 1 || dirChangedSpy.count() == 2);
+
+ QVERIFY(QDir().rmdir("testDir"));
+}
+
+void tst_QFileSystemWatcher::cleanup()
+{
+ QDir testDir("testDir");
+ QString testFileName = testDir.filePath("testFile.txt");
+ QString secondFileName = testDir.filePath("testFile2.txt");
+ QFile::remove(testFileName);
+ QFile::remove(secondFileName);
+ QDir().rmdir("testDir");
+}
+
+void tst_QFileSystemWatcher::nonExistingFile()
+{
+ // Don't crash...
+ QFileSystemWatcher watcher;
+ watcher.addPath("file_that_does_not_exist.txt");
+ QVERIFY(true);
+}
+
+QTEST_MAIN(tst_QFileSystemWatcher)
+#include "tst_qfilesystemwatcher.moc"