Fixed compile of shm/sem tests with vcproj generator.

SUBDIRS+=../path/to/lackey from two different places means that qmake
sees the lackey project twice.  This breaks the vcproj generator.

Make it so that lackey is only referred to once.

10 files changed, 541 insertions, 0 deletions

diff --git a/tests/auto/qtipc/lackey/lackey.pro b/tests/auto/qtipc/lackey/lackey.pro
new file mode 100644
index 0000000..3912312
--- /dev/null
+++ b/tests/auto/qtipc/lackey/lackey.pro
@@ -0,0 +1,20 @@
+include(../qsharedmemory/src/src.pri)
+
+QT = core script
+
+CONFIG += qtestlib
+
+DESTDIR = ./
+
+win32: CONFIG += console
+mac:CONFIG -= app_bundle
+
+requires(contains(QT_CONFIG,script))
+
+DEFINES	+= QSHAREDMEMORY_DEBUG
+DEFINES	+= QSYSTEMSEMAPHORE_DEBUG
+
+SOURCES		+= main.cpp 
+TARGET		= lackey
+
+
diff --git a/tests/auto/qtipc/lackey/main.cpp b/tests/auto/qtipc/lackey/main.cpp
new file mode 100644
index 0000000..fef8d22
--- /dev/null
+++ b/tests/auto/qtipc/lackey/main.cpp
@@ -0,0 +1,370 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 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 <qscriptengine.h>
+
+#include <QtCore/QFile>
+#include <QtCore/QTextStream>
+#include <QTest>
+
+#include <qstringlist.h>
+#include <stdlib.h>
+#include <qsharedmemory.h>
+#include <qsystemsemaphore.h>
+#include <qsystemlock.h>
+
+class ScriptSystemSemaphore : public QObject
+{
+    Q_OBJECT
+
+public:
+    ScriptSystemSemaphore(QObject *parent = 0) : QObject(parent), ss(QString())
+    {
+    }
+
+public slots:
+    bool acquire()
+    {
+        return ss.acquire();
+    };
+
+    bool release(int n = 1)
+    {
+        return ss.release(n);
+    };
+
+    void setKey(const QString &key, int n = 0)
+    {
+        ss.setKey(key, n);
+    };
+
+    QString key() const
+    {
+        return ss.key();
+    }
+
+private:
+    QSystemSemaphore ss;
+};
+
+class ScriptSystemLock : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString key WRITE setKey READ key)
+
+public:
+    ScriptSystemLock(QObject *parent = 0) : QObject(parent), sl(QString())
+    {
+    }
+
+public slots:
+
+    bool lockReadOnly()
+    {
+        return sl.lock(QSystemLock::ReadOnly);
+    }
+
+    bool lock()
+    {
+        return sl.lock();
+    };
+
+    bool unlock()
+    {
+        return sl.unlock();
+    };
+
+    void setKey(const QString &key)
+    {
+        sl.setKey(key);
+    };
+
+    QString key() const
+    {
+        return sl.key();
+    }
+
+private:
+    QSystemLock sl;
+};
+
+class ScriptSharedMemory : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool attached READ isAttached)
+    Q_PROPERTY(QString key WRITE setKey READ key)
+
+public:
+    enum SharedMemoryError
+    {
+        NoError = 0,
+        PermissionDenied = 1,
+        InvalidSize = 2,
+        KeyError = 3,
+        AlreadyExists = 4,
+        NotFound = 5,
+        LockError = 6,
+        OutOfResources = 7,
+        UnknownError = 8
+    };
+
+    ScriptSharedMemory(QObject *parent = 0) : QObject(parent)
+    {
+    }
+
+public slots:
+    void sleep(int x) const
+    {
+        QTest::qSleep(x);
+    }
+
+    bool create(int size)
+    {
+        return sm.create(size);
+    };
+
+    bool createReadOnly(int size)
+    {
+        return sm.create(size, QSharedMemory::ReadOnly);
+    };
+
+    int size() const
+    {
+        return sm.size();
+    };
+
+    bool attach()
+    {
+        return sm.attach();
+    };
+
+    bool attachReadOnly()
+    {
+        return sm.attach(QSharedMemory::ReadOnly);
+    };
+
+    bool isAttached() const
+    {
+        return sm.isAttached();
+    };
+
+    bool detach()
+    {
+        return sm.detach();
+    };
+
+    int error() const
+    {
+        return (int)sm.error();
+    };
+
+    QString errorString() const
+    {
+        return sm.errorString();
+    };
+
+    void set(int i, QChar value)
+    {
+        ((char*)sm.data())[i] = value.toLatin1();
+    }
+
+    QString get(int i)
+    {
+        return QChar::fromLatin1(((char*)sm.data())[i]);
+    }
+
+    char *data() const
+    {
+        return (char*)sm.data();
+    };
+
+    void setKey(const QString &key)
+    {
+        sm.setKey(key);
+    };
+
+    QString key() const
+    {
+        return sm.key();
+    }
+
+    bool lock()
+    {
+        return sm.lock();
+    }
+
+    bool unlock()
+    {
+        return sm.unlock();
+    }
+
+private:
+    QSharedMemory sm;
+};
+
+QT_BEGIN_NAMESPACE
+Q_SCRIPT_DECLARE_QMETAOBJECT(ScriptSharedMemory, QObject*);
+Q_SCRIPT_DECLARE_QMETAOBJECT(ScriptSystemLock, QObject*);
+Q_SCRIPT_DECLARE_QMETAOBJECT(ScriptSystemSemaphore, QObject*);
+QT_END_NAMESPACE
+
+static void interactive(QScriptEngine &eng)
+{
+#ifdef Q_OS_WINCE
+    fprintf(stderr, "Interactive mode not supported on Windows CE\n");
+    return;
+#endif
+    QTextStream qin(stdin, QFile::ReadOnly);
+
+    const char *qscript_prompt = "qs> ";
+    const char *dot_prompt = ".... ";
+    const char *prompt = qscript_prompt;
+
+    QString code;
+
+    forever {
+        QString line;
+
+        printf("%s", prompt);
+        fflush(stdout);
+
+        line = qin.readLine();
+        if (line.isNull())
+        break;
+
+        code += line;
+        code += QLatin1Char('\n');
+
+        if (line.trimmed().isEmpty()) {
+            continue;
+
+        } else if (! eng.canEvaluate(code)) {
+            prompt = dot_prompt;
+
+        } else {
+            QScriptValue result = eng.evaluate(code);
+            code.clear();
+            prompt = qscript_prompt;
+            if (!result.isUndefined())
+                fprintf(stderr, "%s\n", qPrintable(result.toString()));
+        }
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication app(argc, argv);
+
+    QScriptEngine eng;
+    QScriptValue globalObject = eng.globalObject();
+
+    QScriptValue sm = qScriptValueFromQMetaObject<ScriptSharedMemory>(&eng);
+    eng.globalObject().setProperty("ScriptSharedMemory", sm);
+
+    QScriptValue sl = qScriptValueFromQMetaObject<ScriptSystemLock>(&eng);
+    eng.globalObject().setProperty("ScriptSystemLock", sl);
+
+    QScriptValue ss = qScriptValueFromQMetaObject<ScriptSystemSemaphore>(&eng);
+    eng.globalObject().setProperty("ScriptSystemSemaphore", ss);
+
+
+    if (! *++argv) {
+        interactive(eng);
+        return EXIT_SUCCESS;
+    }
+
+    QStringList arguments = app.arguments();
+    arguments.takeFirst();
+
+    while (!arguments.isEmpty()) {
+        QString fn = arguments.takeFirst();
+
+        if (fn == QLatin1String("-i")) {
+            interactive(eng);
+            break;
+        }
+
+        QString contents;
+
+        if (fn == QLatin1String("-")) {
+            QTextStream stream(stdin, QFile::ReadOnly);
+            contents = stream.readAll();
+        } else {
+            QFile file(fn);
+	    if (!file.exists()) {
+                fprintf(stderr, "%s doesn't exists\n", qPrintable(fn));
+	        return EXIT_FAILURE;
+	    }
+            if (file.open(QFile::ReadOnly)) {
+                QTextStream stream(&file);
+                contents = stream.readAll();
+                file.close();
+            }
+        }
+
+        if (contents.isEmpty())
+            continue;
+
+        if (contents[0] == '#') {
+            contents.prepend("//");
+            QScriptValue args = eng.newArray();
+            args.setProperty("0", QScriptValue(&eng, fn));
+            int i = 1;
+            while (!arguments.isEmpty())
+                args.setProperty(i++, QScriptValue(&eng, arguments.takeFirst()));
+            eng.currentContext()->activationObject().setProperty("args", args);
+        }
+        QScriptValue r = eng.evaluate(contents);
+        if (eng.hasUncaughtException()) {
+            int line = eng.uncaughtExceptionLineNumber();
+            fprintf(stderr, "%d: %s\n\t%s\n\n", line, qPrintable(fn), qPrintable(r.toString()));
+            return EXIT_FAILURE;
+        }
+        if (r.isNumber())
+            return r.toInt32();
+    }
+
+    return EXIT_SUCCESS;
+}
+
+#include "main.moc"
diff --git a/tests/auto/qtipc/lackey/scripts/consumer.js b/tests/auto/qtipc/lackey/scripts/consumer.js
new file mode 100644
index 0000000..4d12dca
--- /dev/null
+++ b/tests/auto/qtipc/lackey/scripts/consumer.js
@@ -0,0 +1,41 @@
+function QVERIFY(x, debugInfo) {
+    if (!(x)) {
+        print(debugInfo);
+        throw(debugInfo);
+    }
+}
+
+var consumer = new ScriptSharedMemory;
+consumer.setKey("market");
+
+//print("consumer starting");
+var tries = 0;;
+while(!consumer.attach()) {
+    if (tries == 5000) {
+        var message = "consumer exiting, waiting too long";
+        print(message);
+        throw(message);
+    }
+    ++tries;
+    consumer.sleep(1);
+}
+//print("consumer attached");
+
+
+var i = 0;
+while(true) {
+    QVERIFY(consumer.lock(), "lock");
+    if (consumer.get(0) == 'Q') {
+        consumer.set(0, ++i);
+        //print ("consumer sets" + i);
+    }
+    if (consumer.get(0) == 'E') {
+        QVERIFY(consumer.unlock(), "unlock");
+        break;
+    }
+    QVERIFY(consumer.unlock(), "unlock");
+    consumer.sleep(10);
+}
+
+//print("consumer detaching");
+QVERIFY(consumer.detach());
diff --git a/tests/auto/qtipc/lackey/scripts/producer.js b/tests/auto/qtipc/lackey/scripts/producer.js
new file mode 100644
index 0000000..e02cd8b
--- /dev/null
+++ b/tests/auto/qtipc/lackey/scripts/producer.js
@@ -0,0 +1,44 @@
+function QVERIFY(x, debugInfo) {
+    if (!(x)) {
+        print(debugInfo);
+        throw(debugInfo);
+    }
+}
+
+var producer = new ScriptSharedMemory;
+producer.setKey("market");
+
+var size = 1024;
+if (!producer.create(size)) {
+    QVERIFY(producer.error() == 4, "create");
+    QVERIFY(producer.attach());
+}
+//print ("producer created and attached");
+
+QVERIFY(producer.lock());
+producer.set(0, 'Q');
+QVERIFY(producer.unlock());
+
+var i = 0;
+while(i < 5) {
+    QVERIFY(producer.lock(), "lock");
+    if (producer.get(0) == 'Q') {
+        QVERIFY(producer.unlock(), "unlock");
+        producer.sleep(1);
+        continue;
+    }
+    //print("producer: " + i);
+    ++i;
+    producer.set(0, 'Q');
+    QVERIFY(producer.unlock(), "unlock");
+    producer.sleep(1);
+}
+QVERIFY(producer.lock());
+producer.set(0, 'E');
+QVERIFY(producer.unlock());
+
+//print ("producer done");
+
+// Sleep for a bit to let all consumers start, otherwise they will get stuck in the attach loop,
+// because at least in Symbian the shared memory will be destroyed if there are no active handles to it.
+producer.sleep(3000);
\ No newline at end of file
diff --git a/tests/auto/qtipc/lackey/scripts/readonly_segfault.js b/tests/auto/qtipc/lackey/scripts/readonly_segfault.js
new file mode 100644
index 0000000..3eaf789
--- /dev/null
+++ b/tests/auto/qtipc/lackey/scripts/readonly_segfault.js
@@ -0,0 +1,4 @@
+var sm = new ScriptSharedMemory;
+sm.setKey("readonly_segfault");
+sm.createReadOnly(1024);
+var data = sm.set(0, "a");
diff --git a/tests/auto/qtipc/lackey/scripts/systemlock_read.js b/tests/auto/qtipc/lackey/scripts/systemlock_read.js
new file mode 100644
index 0000000..1048bc7
--- /dev/null
+++ b/tests/auto/qtipc/lackey/scripts/systemlock_read.js
@@ -0,0 +1,11 @@
+function QVERIFY(x, debugInfo) {
+    if (!(x)) {
+        print(debugInfo);
+        throw(debugInfo);
+    }
+}
+
+var lock = new ScriptSystemLock;
+lock.setKey("market");
+QVERIFY(lock.lockReadOnly());
+QVERIFY(lock.unlock());
\ No newline at end of file
diff --git a/tests/auto/qtipc/lackey/scripts/systemlock_readwrite.js b/tests/auto/qtipc/lackey/scripts/systemlock_readwrite.js
new file mode 100644
index 0000000..fc6367f
--- /dev/null
+++ b/tests/auto/qtipc/lackey/scripts/systemlock_readwrite.js
@@ -0,0 +1,11 @@
+function QVERIFY(x, debugInfo) {
+    if (!(x)) {
+        print(debugInfo);
+        throw(debugInfo);
+    }
+}
+
+var lock = new ScriptSystemLock;
+lock.setKey("market");
+QVERIFY(lock.lock());
+QVERIFY(lock.unlock());
diff --git a/tests/auto/qtipc/lackey/scripts/systemsemaphore_acquire.js b/tests/auto/qtipc/lackey/scripts/systemsemaphore_acquire.js
new file mode 100644
index 0000000..5cff429
--- /dev/null
+++ b/tests/auto/qtipc/lackey/scripts/systemsemaphore_acquire.js
@@ -0,0 +1,18 @@
+#/bin/qscript
+function QVERIFY(x, debugInfo) {
+    if (!(x)) {
+        print(debugInfo);
+        throw(debugInfo);
+    }
+}
+
+
+var sem = new ScriptSystemSemaphore;
+sem.setKey("store");
+
+var count = Number(args[1]);
+if (isNaN(count))
+    count = 1;
+for (var i = 0; i < count; ++i)
+    QVERIFY(sem.acquire());
+print("done aquiring");
diff --git a/tests/auto/qtipc/lackey/scripts/systemsemaphore_acquirerelease.js b/tests/auto/qtipc/lackey/scripts/systemsemaphore_acquirerelease.js
new file mode 100644
index 0000000..cedde3f
--- /dev/null
+++ b/tests/auto/qtipc/lackey/scripts/systemsemaphore_acquirerelease.js
@@ -0,0 +1,11 @@
+function QVERIFY(x, debugInfo) {
+    if (!(x)) {
+        print(debugInfo);
+        throw(debugInfo);
+    }
+}
+
+var lock = new ScriptSystemSemaphore;
+lock.setKey("store");
+QVERIFY(lock.acquire());
+QVERIFY(lock.release());
diff --git a/tests/auto/qtipc/lackey/scripts/systemsemaphore_release.js b/tests/auto/qtipc/lackey/scripts/systemsemaphore_release.js
new file mode 100644
index 0000000..c805e0f
--- /dev/null
+++ b/tests/auto/qtipc/lackey/scripts/systemsemaphore_release.js
@@ -0,0 +1,11 @@
+function QVERIFY(x, debugInfo) {
+    if (!(x)) {
+        print(debugInfo);
+        throw(debugInfo);
+    }
+}
+
+var sem = new ScriptSystemSemaphore;
+sem.setKey("store");
+QVERIFY(sem.release());
+print ("done releasing");