summaryrefslogtreecommitdiffstats
path: root/tests/auto/qfileopenevent/test/tst_qfileopenevent.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/qfileopenevent/test/tst_qfileopenevent.cpp')
-rw-r--r--tests/auto/qfileopenevent/test/tst_qfileopenevent.cpp362
1 files changed, 362 insertions, 0 deletions
diff --git a/tests/auto/qfileopenevent/test/tst_qfileopenevent.cpp b/tests/auto/qfileopenevent/test/tst_qfileopenevent.cpp
new file mode 100644
index 0000000..1177131
--- /dev/null
+++ b/tests/auto/qfileopenevent/test/tst_qfileopenevent.cpp
@@ -0,0 +1,362 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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 <QEvent>
+
+#ifdef Q_OS_SYMBIAN
+#include <apgcli.h>
+#include "private/qcore_symbian_p.h"
+#endif
+
+class tst_qfileopenevent : public QObject
+{
+ Q_OBJECT
+public:
+ tst_qfileopenevent(){}
+ ~tst_qfileopenevent();
+
+public slots:
+ void initTestCase();
+
+private slots:
+ void constructor();
+ void fileOpen();
+ void handleLifetime();
+ void multiOpen();
+ void sendAndReceive();
+ void external_data();
+ void external();
+
+private:
+#ifdef Q_OS_SYMBIAN
+ RFile createRFile(const TDesC& filename, const TDesC8& content);
+#else
+ void createFile(const QString &filename, const QByteArray &content);
+#endif
+ QFileOpenEvent * createFileAndEvent(const QString &filename, const QByteArray &content);
+ void checkReadAndWrite(QFileOpenEvent& event, const QByteArray& readContent, const QByteArray& writeContent, bool writeOk);
+ QByteArray readFileContent(QFileOpenEvent& event);
+ bool appendFileContent(QFileOpenEvent& event, const QByteArray& writeContent);
+
+ bool event(QEvent *);
+
+private:
+#ifdef Q_OS_SYMBIAN
+ struct AutoRFs : public RFs
+ {
+ AutoRFs()
+ {
+ qt_symbian_throwIfError(Connect());
+ qt_symbian_throwIfError(ShareProtected());
+ }
+
+ ~AutoRFs()
+ {
+ Close();
+ }
+ };
+ AutoRFs fsSession;
+#endif
+};
+
+tst_qfileopenevent::~tst_qfileopenevent()
+{
+};
+
+void tst_qfileopenevent::initTestCase()
+{
+}
+
+#ifdef Q_OS_SYMBIAN
+RFile tst_qfileopenevent::createRFile(const TDesC& filename, const TDesC8& content)
+{
+ RFile file;
+ qt_symbian_throwIfError(file.Replace(fsSession, filename, EFileWrite));
+ qt_symbian_throwIfError(file.Write(content));
+ return file;
+}
+#else
+void tst_qfileopenevent::createFile(const QString &filename, const QByteArray &content)
+{
+ QFile file(filename);
+ file.open(QFile::WriteOnly);
+ file.write(content);
+ file.close();
+}
+#endif
+
+QFileOpenEvent * tst_qfileopenevent::createFileAndEvent(const QString &filename, const QByteArray &content)
+{
+#ifdef Q_OS_SYMBIAN
+ RFile rFile = createRFile(qt_QString2TPtrC(filename), TPtrC8((TText8*)content.constData(), content.size()));
+ QScopedPointer<RFile, QScopedPointerRCloser<RFile> > closeRFile(&rFile);
+ return new QFileOpenEvent(rFile);
+#else
+ createFile(filename, content);
+ return new QFileOpenEvent(filename);
+#endif
+}
+
+void tst_qfileopenevent::constructor()
+{
+ // check that filename get/set works
+ QFileOpenEvent nameTest(QLatin1String("fileNameTest"));
+ QCOMPARE(nameTest.file(), QLatin1String("fileNameTest"));
+
+ // check that url get/set works
+ QFileOpenEvent urlTest(QUrl(QLatin1String("file:///urlNameTest")));
+ QCOMPARE(urlTest.url().toString(), QLatin1String("file:///urlNameTest"));
+
+#ifdef Q_OS_SYMBIAN
+ // check that RFile construction works
+ RFile rFile = createRFile(_L("testRFile"), _L8("test content"));
+ QFileOpenEvent rFileTest(rFile);
+ QString targetName(QLatin1String("testRFile"));
+ QCOMPARE(rFileTest.file().right(targetName.size()), targetName);
+ QCOMPARE(rFileTest.url().toString().right(targetName.size()), targetName);
+ rFile.Close();
+#endif
+}
+
+QByteArray tst_qfileopenevent::readFileContent(QFileOpenEvent& event)
+{
+ QFile file;
+ event.openFile(file, QFile::ReadOnly);
+ file.seek(0);
+ QByteArray data = file.readAll();
+ return data;
+}
+
+bool tst_qfileopenevent::appendFileContent(QFileOpenEvent& event, const QByteArray& writeContent)
+{
+ QFile file;
+ bool ok = event.openFile(file, QFile::Append | QFile::Unbuffered);
+ if (ok)
+ ok = file.write(writeContent) == writeContent.size();
+ return ok;
+}
+
+void tst_qfileopenevent::checkReadAndWrite(QFileOpenEvent& event, const QByteArray& readContent, const QByteArray& writeContent, bool writeOk)
+{
+ QCOMPARE(readFileContent(event), readContent);
+ QCOMPARE(appendFileContent(event, writeContent), writeOk);
+ QCOMPARE(readFileContent(event), writeOk ? readContent+writeContent : readContent);
+}
+
+void tst_qfileopenevent::fileOpen()
+{
+#ifdef Q_OS_SYMBIAN
+ // create writeable file
+ {
+ RFile rFile = createRFile(_L("testFileOpen"), _L8("test content"));
+ QFileOpenEvent rFileTest(rFile);
+ checkReadAndWrite(rFileTest, QByteArray("test content"), QByteArray("+RFileWrite"), true);
+ rFile.Close();
+ }
+
+ // open read-only RFile
+ {
+ RFile rFile;
+ int err = rFile.Open(fsSession, _L("testFileOpen"), EFileRead);
+ QFileOpenEvent rFileTest(rFile);
+ checkReadAndWrite(rFileTest, QByteArray("test content+RFileWrite"), QByteArray("+RFileRead"), false);
+ rFile.Close();
+ }
+#else
+ createFile(QLatin1String("testFileOpen"), QByteArray("test content+RFileWrite"));
+#endif
+
+ // filename event
+ QUrl fileUrl; // need to get the URL during the file test, for use in the URL test
+ {
+ QFileOpenEvent nameTest(QLatin1String("testFileOpen"));
+ fileUrl = nameTest.url();
+ checkReadAndWrite(nameTest, QByteArray("test content+RFileWrite"), QByteArray("+nameWrite"), true);
+ }
+
+ // url event
+ {
+ QFileOpenEvent urlTest(fileUrl);
+ checkReadAndWrite(urlTest, QByteArray("test content+RFileWrite+nameWrite"), QByteArray("+urlWrite"), true);
+ }
+
+ QFile::remove(QLatin1String("testFileOpen"));
+}
+
+void tst_qfileopenevent::handleLifetime()
+{
+ QScopedPointer<QFileOpenEvent> event(createFileAndEvent(QLatin1String("testHandleLifetime"), QByteArray("test content")));
+
+ // open a QFile after the original RFile is closed
+ QFile qFile;
+ QCOMPARE(event->openFile(qFile, QFile::Append | QFile::Unbuffered), true);
+ event.reset(0);
+
+ // write to the QFile after the event is closed
+ QString writeContent(QLatin1String("+closed original handles"));
+ QCOMPARE(int(qFile.write(writeContent.toUtf8())), writeContent.size());
+ qFile.close();
+
+ // check the content
+ QFile check("testHandleLifetime");
+ check.open(QFile::ReadOnly);
+ QString content(check.readAll());
+ QCOMPARE(content, QLatin1String("test content+closed original handles"));
+ check.close();
+
+ QFile::remove(QLatin1String("testHandleLifetime"));
+}
+
+void tst_qfileopenevent::multiOpen()
+{
+ QScopedPointer<QFileOpenEvent> event(createFileAndEvent(QLatin1String("testMultiOpen"), QByteArray("itlum")));
+
+ QFile files[5];
+ for (int i=0; i<5; i++) {
+ QCOMPARE(event->openFile(files[i], QFile::ReadOnly), true);
+ }
+ for (int i=0; i<5; i++)
+ files[i].seek(i);
+ QString str;
+ for (int i=4; i>=0; i--) {
+ char c;
+ files[i].getChar(&c);
+ str.append(c);
+ files[i].close();
+ }
+ QCOMPARE(str, QLatin1String("multi"));
+
+ QFile::remove(QLatin1String("testMultiOpen"));
+}
+
+bool tst_qfileopenevent::event(QEvent *event)
+{
+ if (event->type() != QEvent::FileOpen)
+ return QObject::event(event);
+ QFileOpenEvent* fileOpenEvent = static_cast<QFileOpenEvent *>(event);
+ appendFileContent(*fileOpenEvent, "+received");
+ return true;
+}
+
+void tst_qfileopenevent::sendAndReceive()
+{
+ QScopedPointer<QFileOpenEvent> event(createFileAndEvent(QLatin1String("testSendAndReceive"), QByteArray("sending")));
+
+ QCoreApplication::instance()->postEvent(this, event.take());
+ QCoreApplication::instance()->processEvents();
+
+ // QTBUG-17468: On Mac, processEvents doesn't always process posted events
+ QCoreApplication::instance()->sendPostedEvents();
+
+ // check the content
+ QFile check("testSendAndReceive");
+ QCOMPARE(check.open(QFile::ReadOnly), true);
+ QString content(check.readAll());
+ QCOMPARE(content, QLatin1String("sending+received"));
+ check.close();
+
+ QFile::remove(QLatin1String("testSendAndReceive"));
+}
+
+void tst_qfileopenevent::external_data()
+{
+ QTest::addColumn<QString>("filename");
+ QTest::addColumn<QByteArray>("targetContent");
+ QTest::addColumn<bool>("sendHandle");
+
+ QString privateName(QLatin1String("tst_qfileopenevent_external"));
+ QString publicName(QLatin1String("C:\\Data\\tst_qfileopenevent_external"));
+ QByteArray writeSuccess("original+external");
+ QByteArray writeFail("original");
+ QTest::newRow("public name") << publicName << writeSuccess << false;
+ QTest::newRow("data caged name") << privateName << writeFail << false;
+ QTest::newRow("public handle") << publicName << writeSuccess << true;
+ QTest::newRow("data caged handle") << privateName << writeSuccess << true;
+}
+
+void tst_qfileopenevent::external()
+{
+#ifndef Q_OS_SYMBIAN
+ QSKIP("external app file open test only valid in Symbian", SkipAll);
+#else
+
+ QFETCH(QString, filename);
+ QFETCH(QByteArray, targetContent);
+ QFETCH(bool, sendHandle);
+
+ RFile rFile = createRFile(qt_QString2TPtrC(filename), _L8("original"));
+
+ // launch app with the file
+ RApaLsSession apa;
+ QCOMPARE(apa.Connect(), KErrNone);
+ TThreadId threadId;
+ TDataType type(_L8("application/x-tst_qfileopenevent"));
+ if (sendHandle) {
+ QCOMPARE(apa.StartDocument(rFile, type, threadId), KErrNone);
+ rFile.Close();
+ } else {
+ TFileName fullName;
+ rFile.FullName(fullName);
+ rFile.Close();
+ QCOMPARE(apa.StartDocument(fullName, type, threadId), KErrNone);
+ }
+
+ // wait for app exit
+ RThread appThread;
+ if (appThread.Open(threadId) == KErrNone) {
+ TRequestStatus status;
+ appThread.Logon(status);
+ User::WaitForRequest(status);
+ }
+
+ // check the contents
+ QFile check(filename);
+ QCOMPARE(check.open(QFile::ReadOnly), true);
+ QCOMPARE(check.readAll(), targetContent);
+ bool ok = check.remove();
+
+ QFile::remove(filename);
+#endif
+}
+
+QTEST_MAIN(tst_qfileopenevent)
+#include "tst_qfileopenevent.moc"