From 8684d1e799d379a913535b527b301f31cd566a01 Mon Sep 17 00:00:00 2001 From: Lorn Potter Date: Mon, 17 Oct 2011 14:43:35 +1000 Subject: add QSensorGestures API. Long live QSensorGestures! Change-Id: Iada4e8888aad8b7b2180cc0bfb8576a766f75b24 Sanity-Review: Qt Sanity Bot Reviewed-by: Lincoln Ramsay --- tests/auto/auto.pro | 2 +- .../plugins/test/qtest2recognizer.cpp | 99 ++++ .../plugins/test/qtest2recognizer.h | 76 +++ .../plugins/test/qtestrecognizer.cpp | 106 ++++ .../qsensorgestures/plugins/test/qtestrecognizer.h | 79 +++ .../plugins/test/qtestsensorgestureplugin.cpp | 110 ++++ .../plugins/test/qtestsensorgestureplugin_p.h | 70 +++ .../plugins/test1/qtest2recognizerdup.cpp | 96 ++++ .../plugins/test1/qtest2recognizerdup.h | 75 +++ .../plugins/test1/qtestrecognizerdup.cpp | 95 ++++ .../plugins/test1/qtestrecognizerdup.h | 77 +++ .../plugins/test1/qtestsensorgestureplugindup.cpp | 108 ++++ .../plugins/test1/qtestsensorgestureplugindup.h | 71 +++ tests/auto/qsensorgestures/plugins/test1/test1.pro | 18 + tests/auto/qsensorgestures/qsensorgestures.pro | 33 ++ .../qsensorgestures/tst_qsensorgesturetest.cpp | 621 +++++++++++++++++++++ tests/tests.pro | 1 - 17 files changed, 1735 insertions(+), 2 deletions(-) create mode 100644 tests/auto/qsensorgestures/plugins/test/qtest2recognizer.cpp create mode 100644 tests/auto/qsensorgestures/plugins/test/qtest2recognizer.h create mode 100644 tests/auto/qsensorgestures/plugins/test/qtestrecognizer.cpp create mode 100644 tests/auto/qsensorgestures/plugins/test/qtestrecognizer.h create mode 100644 tests/auto/qsensorgestures/plugins/test/qtestsensorgestureplugin.cpp create mode 100644 tests/auto/qsensorgestures/plugins/test/qtestsensorgestureplugin_p.h create mode 100644 tests/auto/qsensorgestures/plugins/test1/qtest2recognizerdup.cpp create mode 100644 tests/auto/qsensorgestures/plugins/test1/qtest2recognizerdup.h create mode 100644 tests/auto/qsensorgestures/plugins/test1/qtestrecognizerdup.cpp create mode 100644 tests/auto/qsensorgestures/plugins/test1/qtestrecognizerdup.h create mode 100644 tests/auto/qsensorgestures/plugins/test1/qtestsensorgestureplugindup.cpp create mode 100644 tests/auto/qsensorgestures/plugins/test1/qtestsensorgestureplugindup.h create mode 100644 tests/auto/qsensorgestures/plugins/test1/test1.pro create mode 100644 tests/auto/qsensorgestures/qsensorgestures.pro create mode 100644 tests/auto/qsensorgestures/tst_qsensorgesturetest.cpp (limited to 'tests') diff --git a/tests/auto/auto.pro b/tests/auto/auto.pro index e16b33c0..b3042af2 100644 --- a/tests/auto/auto.pro +++ b/tests/auto/auto.pro @@ -4,4 +4,4 @@ SUBDIRS += qsensor SUBDIRS += sensors2qmlapi SUBDIRS += legacy_sensors SUBDIRS += qtsensors5 - +SUBDIRS += qsensorgestures diff --git a/tests/auto/qsensorgestures/plugins/test/qtest2recognizer.cpp b/tests/auto/qsensorgestures/plugins/test/qtest2recognizer.cpp new file mode 100644 index 00000000..d493143c --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test/qtest2recognizer.cpp @@ -0,0 +1,99 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qtest2recognizer.h" + +#include "qtestsensorgestureplugin_p.h" + +QTest2Recognizer::QTest2Recognizer(QObject *parent) + : QSensorGestureRecognizer(parent), + active(0) +{ +} + +QTest2Recognizer::~QTest2Recognizer() +{ +} + +bool QTest2Recognizer::start() +{ + Q_EMIT test2(); + + Q_EMIT detected("test2"); + + Q_EMIT test3(true); + active = true; + + return true; +} + +bool QTest2Recognizer::stop() +{ + active = false; + return true; +} + +bool QTest2Recognizer::isActive() +{ + return active; +} + + +void QTest2Recognizer::create() +{ + active = false; +} + +QString QTest2Recognizer::id() const +{ + return QString("QtSensors.test2"); +} + +int QTest2Recognizer::thresholdTime() const +{ + return timerTimeout; +} + +void QTest2Recognizer::setThresholdTime(int msec) +{ + timer->setInterval(msec); +} + diff --git a/tests/auto/qsensorgestures/plugins/test/qtest2recognizer.h b/tests/auto/qsensorgestures/plugins/test/qtest2recognizer.h new file mode 100644 index 00000000..01059975 --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test/qtest2recognizer.h @@ -0,0 +1,76 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTEST2RECOGNIZER_H +#define QTEST2RECOGNIZER_H + +#include + +class QTest2Recognizer : public QSensorGestureRecognizer +{ + Q_OBJECT + +public: + QTest2Recognizer(QObject *parent = 0); + ~QTest2Recognizer(); + + void create(); + + QString id() const; + bool start(); + bool stop(); + bool isActive(); + + int thresholdTime() const; + void setThresholdTime(int msec); + +Q_SIGNALS: + void test2(); + void test3(bool); + +private: + int timerTimeout; + QTimer *timer; + bool active; +}; + + +#endif // QTEST2RECOGNIZER_H diff --git a/tests/auto/qsensorgestures/plugins/test/qtestrecognizer.cpp b/tests/auto/qsensorgestures/plugins/test/qtestrecognizer.cpp new file mode 100644 index 00000000..dcbb9fd1 --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test/qtestrecognizer.cpp @@ -0,0 +1,106 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include + +#include "qtestrecognizer.h" +#include "qtestsensorgestureplugin_p.h" + + +QTestRecognizer::QTestRecognizer(QObject *parent) + : QSensorGestureRecognizer(parent), + active(0) +{ + QTimer::singleShot(2000,this, SLOT(timeout())); +} + +QTestRecognizer::~QTestRecognizer() +{ +} + +void QTestRecognizer::timeout() +{ + Q_EMIT detected("tested"); + Q_EMIT tested(); + QTimer::singleShot(2000,this, SLOT(timeout())); +} + + +bool QTestRecognizer::start() +{ + Q_EMIT detected("tested"); + Q_EMIT tested(); + active = true; + return true; +} + +bool QTestRecognizer::stop() +{ + active = false; + return true; +} + +bool QTestRecognizer::isActive() +{ + return active; +} + +void QTestRecognizer::create() +{ + active = false; +} + +QString QTestRecognizer::id() const +{ + return QString("QtSensors.test"); +} + + +int QTestRecognizer::thresholdTime() const +{ + return timerTimeout; +} + +void QTestRecognizer::setThresholdTime(int msec) +{ + timer->setInterval(msec); +} diff --git a/tests/auto/qsensorgestures/plugins/test/qtestrecognizer.h b/tests/auto/qsensorgestures/plugins/test/qtestrecognizer.h new file mode 100644 index 00000000..620c28b7 --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test/qtestrecognizer.h @@ -0,0 +1,79 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTESTRECOGNIZER_H +#define QTESTRECOGNIZER_H + +#include + +class QTestRecognizer : public QSensorGestureRecognizer +{ + Q_OBJECT + Q_PROPERTY(int thresholdTime READ thresholdTime WRITE setThresholdTime) + +public: + + QTestRecognizer(QObject *parent = 0); + ~QTestRecognizer(); + + void create(); + + QString id() const; + bool start(); + bool stop(); + bool isActive(); + + int thresholdTime() const; + void setThresholdTime(int msec); + +Q_SIGNALS: + void tested(); + +private: + int timerTimeout; + QTimer *timer; + bool active; + +public slots: + void timeout(); +}; + +#endif // QTESTRECOGNIZER_H diff --git a/tests/auto/qsensorgestures/plugins/test/qtestsensorgestureplugin.cpp b/tests/auto/qsensorgestures/plugins/test/qtestsensorgestureplugin.cpp new file mode 100644 index 00000000..c7077e15 --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test/qtestsensorgestureplugin.cpp @@ -0,0 +1,110 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include +#include +#include +#include + +#include "qtestrecognizer.h" +#include "qtest2recognizer.h" + +#include "qtestsensorgestureplugin_p.h" + +#include +#include +#include + + +QTestSensorGesturePlugin::QTestSensorGesturePlugin() +{ +} + +QTestSensorGesturePlugin::~QTestSensorGesturePlugin() +{ +} + + +///*! +// Describes this gesture's possible gesture signals. +//handled through the detected(const QString &) signal. +// */ +//QStringList QTestSensorGesturePlugin::gestureSignals() const +//{ +// QStringList list; +// Q_FOREACH (const QSensorGestureRecognizer* rec, recognizersList) { +// list.append(rec->gestureSignals()); +// } +// return list; +//} + +QList QTestSensorGesturePlugin::createRecognizers() +{ + QSensorGestureRecognizer *sRec = new QTestRecognizer(this); + recognizersList.append(sRec); + + QSensorGestureRecognizer *sRec2 = new QTest2Recognizer(this); + recognizersList.append(sRec2); + + return recognizersList; +} + +QStringList QTestSensorGesturePlugin::supportedIds() const +{ + QStringList list; + list << "QtSensors.test"; + list <<"QtSensors.test2"; + + return list; +} + +QList QTestSensorGesturePlugin::recognizers() const +{ + return recognizersList; +} + +QString QTestSensorGesturePlugin::name() const +{ + return "TestGestures"; +} + +REGISTER_STATIC_PLUGIN_V2(QTestSensorGesturePlugin) diff --git a/tests/auto/qsensorgestures/plugins/test/qtestsensorgestureplugin_p.h b/tests/auto/qsensorgestures/plugins/test/qtestsensorgestureplugin_p.h new file mode 100644 index 00000000..a87f6a0c --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test/qtestsensorgestureplugin_p.h @@ -0,0 +1,70 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTESTSENSORGESTUREPLUGIN_P_H +#define QTESTSENSORGESTUREPLUGIN_P_H + +#include +#include + +class QTestSensorGesturePlugin : public QObject, QSensorGesturePluginInterface +{ + Q_OBJECT + Q_INTERFACES(QSensorGesturePluginInterface) +public: + explicit QTestSensorGesturePlugin(); + ~QTestSensorGesturePlugin(); + + QList createRecognizers(); + +// QStringList gestureSignals() const; + QStringList supportedIds() const; + QString name() const; + + QList recognizers() const; + + QList recognizersList; + +}; + + + +#endif // QTESTSENSORGESTUREPLUGIN_H diff --git a/tests/auto/qsensorgestures/plugins/test1/qtest2recognizerdup.cpp b/tests/auto/qsensorgestures/plugins/test1/qtest2recognizerdup.cpp new file mode 100644 index 00000000..0523d84c --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test1/qtest2recognizerdup.cpp @@ -0,0 +1,96 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qtest2recognizerdup.h" + +#include "qtestsensorgestureplugindup.h" + +QTest2RecognizerDup::QTest2RecognizerDup(QObject *parent) + : QSensorGestureRecognizer(parent), + active(0) +{ +} + +QTest2RecognizerDup::~QTest2RecognizerDup() +{ +} + +bool QTest2RecognizerDup::start() +{ + Q_EMIT test2_dup(); + + active = true; + + return true; +} + +bool QTest2RecognizerDup::stop() +{ + active = false; + return true; +} + +bool QTest2RecognizerDup::isActive() +{ + return active; +} + + +void QTest2RecognizerDup::create() +{ + active = false; +} + +QString QTest2RecognizerDup::id() const +{ + return QString("QtSensors.test.dup"); +} + +int QTest2RecognizerDup::thresholdTime() const +{ + return timerTimeout; +} + +void QTest2RecognizerDup::setThresholdTime(int msec) +{ + timer->setInterval(msec); +} + diff --git a/tests/auto/qsensorgestures/plugins/test1/qtest2recognizerdup.h b/tests/auto/qsensorgestures/plugins/test1/qtest2recognizerdup.h new file mode 100644 index 00000000..502918c1 --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test1/qtest2recognizerdup.h @@ -0,0 +1,75 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTEST2RECOGNIZERDUP_H +#define QTEST2RECOGNIZERDUP_H + +#include + +class QTest2RecognizerDup : public QSensorGestureRecognizer +{ + Q_OBJECT + +public: + QTest2RecognizerDup(QObject *parent = 0); + ~QTest2RecognizerDup(); + + void create(); + + QString id() const; + bool start(); + bool stop(); + bool isActive(); + + int thresholdTime() const; + void setThresholdTime(int msec); + +Q_SIGNALS: + void test2_dup(); + +private: + int timerTimeout; + QTimer *timer; + bool active; +}; + + +#endif // QTEST2RECOGNIZERDUP_H diff --git a/tests/auto/qsensorgestures/plugins/test1/qtestrecognizerdup.cpp b/tests/auto/qsensorgestures/plugins/test1/qtestrecognizerdup.cpp new file mode 100644 index 00000000..ded86e33 --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test1/qtestrecognizerdup.cpp @@ -0,0 +1,95 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include + +#include "qtestrecognizerdup.h" +#include "qtestsensorgestureplugindup.h" + +QTestRecognizerDup::QTestRecognizerDup(QObject *parent) + : QSensorGestureRecognizer(parent), + active(0) +{ +} + +QTestRecognizerDup::~QTestRecognizerDup() +{ +} + +bool QTestRecognizerDup::start() +{ + active = true; + Q_EMIT detected("test2_dup"); + Q_EMIT test2_dup(); + return true; +} + +bool QTestRecognizerDup::stop() +{ + active = false; + return true; +} + +bool QTestRecognizerDup::isActive() +{ + return active; +} + +void QTestRecognizerDup::create() +{ + active = false; +} + +QString QTestRecognizerDup::id() const +{ + return QString("QtSensors.test.dup"); +} + + +int QTestRecognizerDup::thresholdTime() const +{ + return timerTimeout; +} + +void QTestRecognizerDup::setThresholdTime(int msec) +{ + timer->setInterval(msec); +} diff --git a/tests/auto/qsensorgestures/plugins/test1/qtestrecognizerdup.h b/tests/auto/qsensorgestures/plugins/test1/qtestrecognizerdup.h new file mode 100644 index 00000000..7ca06f82 --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test1/qtestrecognizerdup.h @@ -0,0 +1,77 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTESTRECOGNIZERDUP_H +#define QTESTRECOGNIZERDUP_H + +#include + +class QTestRecognizerDup : public QSensorGestureRecognizer +{ + Q_OBJECT + Q_PROPERTY(int thresholdTime READ thresholdTime WRITE setThresholdTime) + +public: + + QTestRecognizerDup(QObject *parent = 0); + ~QTestRecognizerDup(); + + void create(); + + QString id() const; + bool start(); + bool stop(); + bool isActive(); + + int thresholdTime() const; + void setThresholdTime(int msec); + +Q_SIGNALS: + void test2_dup(); + +private: + int timerTimeout; + QTimer *timer; + bool active; + +}; + +#endif // QTESTRECOGNIZERDUP_H diff --git a/tests/auto/qsensorgestures/plugins/test1/qtestsensorgestureplugindup.cpp b/tests/auto/qsensorgestures/plugins/test1/qtestsensorgestureplugindup.cpp new file mode 100644 index 00000000..3b2b5da9 --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test1/qtestsensorgestureplugindup.cpp @@ -0,0 +1,108 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include +#include +#include + +#include "qtestrecognizerdup.h" +#include "qtest2recognizerdup.h" + +#include "qtestsensorgestureplugindup.h" + +#include +#include +#include + + +QTestSensorGestureDupPlugin::QTestSensorGestureDupPlugin() +{ +} + +QTestSensorGestureDupPlugin::~QTestSensorGestureDupPlugin() +{ +} + +/*! + Describes this gesture's possible gesture signals. +handled through the detected(const QString &) signal. + */ +QStringList QTestSensorGestureDupPlugin::gestureSignals() const +{ + QStringList list; + Q_FOREACH (const QSensorGestureRecognizer* rec,recognizersList) { + list.append(rec->gestureSignals()); + } + return list; +} + +QList QTestSensorGestureDupPlugin::createRecognizers() +{ + QSensorGestureRecognizer *sRec = new QTestRecognizerDup(this); + recognizersList.append(sRec); + + QSensorGestureRecognizer *sRec2 = new QTest2RecognizerDup(this); + recognizersList.append(sRec2); + + return recognizersList; +} + +QStringList QTestSensorGestureDupPlugin::supportedIds() const +{ + QStringList list; + list << "QtSensors.test.dup"; + list << "QtSensors.test.dup"; + + return list; +} + +QList QTestSensorGestureDupPlugin::recognizers() const +{ + return recognizersList; +} + +QString QTestSensorGestureDupPlugin::name() const +{ + return "TestGesturesDup"; +} + +REGISTER_STATIC_PLUGIN_V2(QTestSensorGestureDupPlugin) diff --git a/tests/auto/qsensorgestures/plugins/test1/qtestsensorgestureplugindup.h b/tests/auto/qsensorgestures/plugins/test1/qtestsensorgestureplugindup.h new file mode 100644 index 00000000..b6c083bf --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test1/qtestsensorgestureplugindup.h @@ -0,0 +1,71 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTESTSENSORGESTUREDUPPLUGIN_H +#define QTESTSENSORGESTUREDUPPLUGIN_H + +#include +#include + +class QTestSensorGestureDupPlugin : public QObject, public QSensorGesturePluginInterface +{ + Q_OBJECT + Q_INTERFACES(QSensorGesturePluginInterface) +public: + explicit QTestSensorGestureDupPlugin(); + ~QTestSensorGestureDupPlugin(); + + + QList createRecognizers(); + + QStringList gestureSignals() const; + QStringList supportedIds() const; + QString name() const; + + QList recognizers() const; + + QList recognizersList; + +}; + + + +#endif // QTESTSENSORGESTUREDUPPLUGIN_H diff --git a/tests/auto/qsensorgestures/plugins/test1/test1.pro b/tests/auto/qsensorgestures/plugins/test1/test1.pro new file mode 100644 index 00000000..bd3e428e --- /dev/null +++ b/tests/auto/qsensorgestures/plugins/test1/test1.pro @@ -0,0 +1,18 @@ +TEMPLATE = lib +CONFIG += plugin + +TARGET = qtsensorgestures_testplugin1 + +QT += sensors sensorgestures +DESTDIR = $$QT.sensorgestures.plugins/sensorgestures + +# Input +HEADERS += qtestsensorgestureplugindup_p.h \ + qtestrecognizerdup.h \ + qtest2recognizerdup.h +SOURCES += qtestsensorgestureplugindup.cpp \ + qtestrecognizerdup.cpp \ + qtest2recognizerduo.cpp + +target.path += $$[QT_INSTALL_PLUGINS]/sensorgestures +INSTALLS += target diff --git a/tests/auto/qsensorgestures/qsensorgestures.pro b/tests/auto/qsensorgestures/qsensorgestures.pro new file mode 100644 index 00000000..5bccd762 --- /dev/null +++ b/tests/auto/qsensorgestures/qsensorgestures.pro @@ -0,0 +1,33 @@ +TEMPLATE = app +TARGET = tst_qsensorgesturetest +CONFIG += testcase + +QT += core testlib sensors +QT -= gui + +SOURCES += tst_qsensorgesturetest.cpp + + +PLUGIN_1_HEADERS = \ + plugins/test1/qtestsensorgestureplugindup.h \ + plugins/test1/qtestrecognizerdup.h \ + plugins/test1/qtest2recognizerdup.h + +PLUGIN_1_SOURCES = \ + plugins/test1/qtestsensorgestureplugindup.cpp \ + plugins/test1/qtestrecognizerdup.cpp \ + plugins/test1/qtest2recognizerdup.cpp + +HEADERS += $$PLUGIN_1_HEADERS +SOURCES += $$PLUGIN_1_SOURCES + +HEADERS += \ + plugins/test/qtestsensorgestureplugin_p.h \ + plugins/test/qtestrecognizer.h \ + plugins/test/qtest2recognizer.h + +SOURCES += \ + plugins/test/qtestsensorgestureplugin.cpp \ + plugins/test/qtestrecognizer.cpp \ + plugins/test/qtest2recognizer.cpp + diff --git a/tests/auto/qsensorgestures/tst_qsensorgesturetest.cpp b/tests/auto/qsensorgestures/tst_qsensorgesturetest.cpp new file mode 100644 index 00000000..8f88425b --- /dev/null +++ b/tests/auto/qsensorgestures/tst_qsensorgesturetest.cpp @@ -0,0 +1,621 @@ +/**************************************************************************** +** +** 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 QtSensors module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +static bool waitForSignal(QObject *obj, const char *signal, int timeout = 0) +{ + QEventLoop loop; + QObject::connect(obj, signal, &loop, SLOT(quit())); + QTimer timer; + QSignalSpy timeoutSpy(&timer, SIGNAL(timeout())); + if (timeout > 0) { + QObject::connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit())); + timer.setSingleShot(true); + timer.start(timeout); + } + loop.exec(); + return timeoutSpy.isEmpty(); +} + +class QTest3Recognizer : public QSensorGestureRecognizer +{ + Q_OBJECT + +public: + + QTest3Recognizer(QObject *parent = 0); + + void create(); + + QString id() const; + bool start() ; + bool stop(); + bool isActive(); + void changeId(const QString &); + + QString recognizerId; +}; + +QTest3Recognizer::QTest3Recognizer(QObject *parent) : QSensorGestureRecognizer(parent), + recognizerId("QtSensors/test3"){} + +void QTest3Recognizer::create(){} + +QString QTest3Recognizer::id() const{ return recognizerId; } +bool QTest3Recognizer::start(){return true;} +bool QTest3Recognizer::stop() { return true;} +bool QTest3Recognizer::isActive() { return true; } +void QTest3Recognizer::changeId(const QString &id) +{ + recognizerId = id; +} + + +class GestureThread : public QThread +{ + Q_OBJECT +public: + GestureThread(const QStringList &name) { ids = name;} + ~GestureThread() { delete gesture; } + void run() + { + gesture = new QSensorGesture(ids, this); + QObject::connect(gesture,SIGNAL(detected(QString)),this,SIGNAL(detected(QString))); + gesture->startDetection(); + } + + QSensorGesture *gesture; + QStringList ids; + +Q_SIGNALS: + void detected(const QString &); +}; + +class Tst_qsensorgestureTest : public QObject +{ + Q_OBJECT + +public: + Tst_qsensorgestureTest(); + +private Q_SLOTS: + + void tst_recognizer_dup(); //comes first to weed out messages + + void tst_manager(); + void tst_manager_gestureids(); + void tst_manager_recognizerSignals(); + void tst_manager_registerSensorGestureRecognizer(); + void tst_manager__newSensorAvailable(); + + void tst_sensor_gesture_signals(); + void tst_sensor_gesture_threaded(); + + void tst_sensor_gesture(); + + void tst_recognizer(); + + void tst_sensorgesture_noid(); + + void tst_sensor_gesture_multi(); + + void shakeDetected(const QString &); + +private: + QString currentSignal; +}; + +Tst_qsensorgestureTest::Tst_qsensorgestureTest() +{ +} + +void Tst_qsensorgestureTest::tst_recognizer_dup() +{ + { + QStringList idList; + QTest::ignoreMessage(QtWarningMsg, "\"QtSensors.test.dup\" from the plugin \"TestGesturesDup\" is already known. "); + QSensorGestureManager manager; + idList = manager.gestureIds(); + + for (int i = 0; i < idList.count(); i++) { + if (idList.at(i) == "QtSensors.test.dup") + + QTest::ignoreMessage(QtWarningMsg, "Ignoring recognizer \"QtSensors.test.dup\" from plugin \"TestGesturesDup\" because it is already registered "); + QStringList recognizerSignalsList = manager.recognizerSignals(idList.at(i)); + + QVERIFY(!recognizerSignalsList.contains("QtSensors.test2")); + } + + QSensorGesture *sensorGesture = new QSensorGesture(idList, this); + QVERIFY(sensorGesture->availableIds().contains("QtSensors.test2")); + QVERIFY(sensorGesture->availableIds().contains("QtSensors.test")); + QVERIFY(sensorGesture->availableIds().contains("QtSensors.test.dup")); + delete sensorGesture; + } + + QSensorGesture *thisGesture; + QString plugin; + plugin = "QtSensors.test2"; + thisGesture = new QSensorGesture(QStringList() << plugin, this); + QVERIFY(thisGesture->availableIds().contains("QtSensors.test2")); + + plugin = "QtSensors.test.dup"; + thisGesture = new QSensorGesture(QStringList() << plugin, this); + QVERIFY(!thisGesture->availableIds().contains("QtSensors.test2")); + delete thisGesture; +} + +void Tst_qsensorgestureTest::tst_manager() +{ + QSensorGestureManager *manager2; + manager2 = new QSensorGestureManager(this); + QVERIFY(manager2 != 0); + delete manager2; +} + +void Tst_qsensorgestureTest::tst_manager_gestureids() +{ + { + QStringList idList; + QSensorGestureManager manager; + idList = manager.gestureIds(); + + QVERIFY(idList.count() > 0); + + QVERIFY(idList.contains("QtSensors.test")); + QVERIFY(idList.contains("QtSensors.test2")); + QVERIFY(idList.contains("QtSensors.test.dup")); + } +} + +void Tst_qsensorgestureTest::tst_manager_recognizerSignals() +{ + { + QStringList idList; + + QSensorGestureManager manager; + idList = manager.gestureIds(); + + idList.removeOne("QtSensors.test.dup"); + + for (int i = 0; i < idList.count(); i++) { + + QStringList recognizerSignalsList = manager.recognizerSignals(idList.at(i)); + + if (idList.at(i) == "QtSensors.test") { + QStringList signalList; + signalList << "detected(QString)"; + signalList << "tested()"; + QVERIFY(recognizerSignalsList.count() == 2); + + QVERIFY(recognizerSignalsList == signalList); + + } else if (idList.at(i) == "QtSensors.test2") { + QStringList signalList; + signalList << "detected(QString)"; + signalList << "test2()"; + signalList << "test3(bool)"; + + QVERIFY(recognizerSignalsList.count() == 3); + QVERIFY(recognizerSignalsList == signalList); + } + } + } +} + +void Tst_qsensorgestureTest::tst_manager_registerSensorGestureRecognizer() +{ + QSensorGestureManager manager; + int num = manager.gestureIds().count(); + QSensorGestureRecognizer *recognizer = new QTest3Recognizer; + bool ok = manager.registerSensorGestureRecognizer(recognizer); + QCOMPARE(ok, true); + QVERIFY(num+1 == manager.gestureIds().count()); + + recognizer = new QTest3Recognizer; + QTest::ignoreMessage(QtWarningMsg, "\"QtSensors/test3\" is already known "); + ok = manager.registerSensorGestureRecognizer(recognizer); + QCOMPARE(ok, false); + QVERIFY(num+1 == manager.gestureIds().count()); + +} + +void Tst_qsensorgestureTest::tst_manager__newSensorAvailable() +{ + QSensorGestureManager manager; + + QSignalSpy spy_manager_available(&manager, SIGNAL(newSensorGestureAvailable())); + + manager.gestureIds(); + QCOMPARE(spy_manager_available.count(),0); + + QTest3Recognizer *recognizer = new QTest3Recognizer; + recognizer->changeId("QtSensors.test4"); + + bool ok = manager.registerSensorGestureRecognizer(recognizer); + QCOMPARE(ok, true); + QCOMPARE(spy_manager_available.count(),1); + + recognizer = new QTest3Recognizer; + recognizer->changeId("QtSensors.test4"); + QTest::ignoreMessage(QtWarningMsg, "\"QtSensors.test4\" is already known "); + ok = manager.registerSensorGestureRecognizer(recognizer); + QCOMPARE(ok, false); + QCOMPARE(spy_manager_available.count(),1); +} + + +void Tst_qsensorgestureTest::tst_sensor_gesture_signals() +{ + QStringList testidList; + testidList << "QtSensors.test"; + testidList << "QtSensors.test2"; + + Q_FOREACH (const QString &plugin, testidList) { + + QSensorGesture *thisGesture; + thisGesture = new QSensorGesture(QStringList() << plugin, this); + + QSignalSpy spy_gesture_detected(thisGesture, SIGNAL(detected(QString))); + + QSignalSpy *spy_gesture_tested; + QSignalSpy *spy_gesture_test2; + + if (plugin == "QtSensors.test") { + QStringList signalList; + signalList << "detected(QString)"; + signalList << "tested()"; + + QVERIFY(thisGesture->gestureSignals().count() == 2); + QVERIFY(thisGesture->gestureSignals() == signalList); + + QVERIFY(thisGesture->gestureSignals().at(1) == "tested()"); + + spy_gesture_tested = new QSignalSpy(thisGesture, SIGNAL(tested())); + } + + if (plugin == "QtSensors.test2") { + QStringList signalList; + signalList << "detected(QString)"; + signalList << "test2()"; + signalList << "test3(bool)"; + QVERIFY(thisGesture->gestureSignals().count() == 3); + QVERIFY(thisGesture->gestureSignals() == signalList); + + QVERIFY(thisGesture->gestureSignals().at(1) == "test2()"); + spy_gesture_test2 = new QSignalSpy(thisGesture, SIGNAL(test2())); + + } + + QVERIFY( thisGesture->availableIds() != QStringList()); + thisGesture->startDetection(); + + QCOMPARE(spy_gesture_detected.count(),1); + + if (plugin == "QtSensors.test") { + QCOMPARE(spy_gesture_tested->count(),1); + QList arguments ; + arguments = spy_gesture_detected.takeFirst(); // take the first signal + QVERIFY(arguments.at(0) == "tested"); + } + + if (plugin == "QtSensors.test2") { + QCOMPARE(spy_gesture_test2->count(),1); + } + + delete thisGesture; + thisGesture = 0; + } + +} + + +void Tst_qsensorgestureTest::tst_sensor_gesture_threaded() +{ + + QSensorGesture *gesture = new QSensorGesture(QStringList() << "QtSensors.test", this); + + GestureThread *thread = new GestureThread( QStringList() << "QtSensors.test"); + + currentSignal = gesture->gestureSignals().at(0).left(gesture->gestureSignals().at(0).indexOf("(")); + + QSignalSpy thread_gesture(thread, SIGNAL(detected(QString))); + QSignalSpy spy_gesture2(gesture, SIGNAL(detected(QString))); + + QCOMPARE(gesture->isActive(),false); + gesture->startDetection(); + + QCOMPARE(thread_gesture.count(),0); + QCOMPARE(spy_gesture2.count(),1); + + QCOMPARE(gesture->isActive(),true); + + thread->run(); + QCOMPARE(thread->gesture->isActive(),true); + + QVERIFY(::waitForSignal(thread, SIGNAL(detected(QString)), 60 * 1000)); + + QVERIFY(::waitForSignal(gesture, SIGNAL(detected(QString)), 60 * 1000)); + + thread->gesture->stopDetection(); + + QCOMPARE(thread->gesture->isActive(),false); + QCOMPARE(gesture->isActive(),true); + + delete gesture; + gesture = 0; + delete thread; + thread = 0; +} + +void Tst_qsensorgestureTest::tst_sensor_gesture() +{ + QSensorGesture *gesture = new QSensorGesture(QStringList() << "QtSensors.test", this); + + QSensorGesture *gesture2 = new QSensorGesture(QStringList() << "QtSensors.test2", this); + QSensorGesture *gesture3 = new QSensorGesture(QStringList() << "QtSensors.test2", this); + + QCOMPARE(gesture->availableIds(),QStringList() << "QtSensors.test"); + + QCOMPARE(gesture->gestureSignals().at(1).left(gesture->gestureSignals().at(1).indexOf("(")),QString("tested")); + + currentSignal = gesture->gestureSignals().at(1).left(gesture->gestureSignals().at(1).indexOf("(")); + + QSignalSpy spy_gesture(gesture, SIGNAL(detected(QString))); + + QSignalSpy spy_gesture2(gesture2, SIGNAL(detected(QString))); + + QSignalSpy spy_gesture3_detected(gesture3, SIGNAL(detected(QString))); + + QSignalSpy spy_gesture4_test2(gesture3, SIGNAL(test2())); + QSignalSpy spy_gesture5_test3(gesture3, SIGNAL(test3(bool))); + + + QCOMPARE(gesture->isActive(),false); + gesture->startDetection(); + + QCOMPARE(spy_gesture.count(),1); + + QCOMPARE(gesture->isActive(),true); + QCOMPARE(gesture2->availableIds(),QStringList() <<"QtSensors.test2"); + QCOMPARE(gesture2->gestureSignals().at(1).left(gesture2->gestureSignals().at(1).indexOf("(")),QString("test2")); + currentSignal = gesture2->gestureSignals().at(1).left(gesture2->gestureSignals().at(1).indexOf("(")); + + connect(gesture2,SIGNAL(detected(QString)), + this,SLOT(shakeDetected(QString))); + + QCOMPARE(gesture2->isActive(),false); + + gesture2->startDetection(); + + QCOMPARE(gesture2->isActive(),true); + + QCOMPARE(spy_gesture2.count(),1); + + QCOMPARE(spy_gesture3_detected.count(),0); + + gesture2->stopDetection(); + + QCOMPARE(gesture2->isActive(),false); + QCOMPARE(gesture3->isActive(),false); + + gesture3->startDetection(); + + QCOMPARE(gesture3->isActive(),true); + QCOMPARE(gesture2->isActive(),false); + + QCOMPARE(spy_gesture.count(),1); + + QCOMPARE(spy_gesture2.count(),1); + + + QCOMPARE(spy_gesture3_detected.count(),1); + + QCOMPARE(spy_gesture4_test2.count(),1); + + QCOMPARE(spy_gesture5_test3.count(),1); + + QList arguments2 = spy_gesture5_test3.takeFirst(); + QVERIFY(arguments2.at(0).type() == QVariant::Bool); + QVERIFY(arguments2.at(0) == true); + + delete gesture; + gesture = 0; + delete gesture2; + gesture2 = 0; + delete gesture3; + gesture3 = 0; +} + + +void Tst_qsensorgestureTest::tst_recognizer() +{ + QSensorGesture *gesture = new QSensorGesture(QStringList() << "QtSensors.test", this); + QSensorGesture *gesture2 = new QSensorGesture(QStringList() << "QtSensors.test", this); + + QSignalSpy spy_gesture(gesture, SIGNAL(detected(QString))); + QSignalSpy spy_gesture2(gesture2, SIGNAL(detected(QString))); + + QCOMPARE(gesture->isActive(),false); + QCOMPARE(gesture2->isActive(),false); + + currentSignal = gesture2->gestureSignals().at(0).left(gesture2->gestureSignals().at(0).indexOf("(")); + + gesture2->startDetection();//activate 2 + + QCOMPARE(gesture->isActive(),false); + QCOMPARE(gesture2->isActive(),true); + + QCOMPARE(spy_gesture.count(),0); + + QCOMPARE(spy_gesture2.count(),1); + + QList arguments = spy_gesture2.takeFirst(); + QVERIFY(arguments.at(0) == "tested"); + + QCOMPARE(spy_gesture2.count(),0); + + gesture->startDetection(); //activate 1 + + QCOMPARE(gesture->isActive(),true); + QCOMPARE(gesture2->isActive(),true); + + QVERIFY(::waitForSignal(gesture, SIGNAL(detected(QString)), 5 * 1000)); + QCOMPARE(spy_gesture.count(),1); + + QCOMPARE(spy_gesture2.count(),1); + + arguments = spy_gesture.takeFirst(); // take the first signal + QVERIFY(arguments.at(0) == "tested"); + spy_gesture2.removeFirst(); + + gesture->stopDetection(); //stop 1 gesture object + + QCOMPARE(gesture->isActive(),false); + QCOMPARE(gesture2->isActive(),true); + + gesture2->startDetection(); + + QCOMPARE(gesture->isActive(),false); + QCOMPARE(spy_gesture.count(),0); + + QCOMPARE(gesture2->isActive(),true); + + QVERIFY(::waitForSignal(gesture2, SIGNAL(detected(QString)), 60 * 1000)); + + delete gesture; + gesture = 0; + delete gesture2; + gesture2 = 0; +} + + +void Tst_qsensorgestureTest::tst_sensorgesture_noid() +{ + QSensorGesture *gesture = new QSensorGesture(QStringList() << "QtSensors.noid", this); + QVERIFY(gesture->availableIds().isEmpty()); + QVERIFY(!gesture->isValid()); + + QTest::ignoreMessage(QtWarningMsg, "QSignalSpy: No such signal: 'detected(QString)'"); + QSignalSpy spy_gesture(gesture, SIGNAL(detected(QString))); + + QCOMPARE(spy_gesture.count(),0); + + gesture->startDetection(); + QCOMPARE(gesture->isActive(),false); + QCOMPARE(spy_gesture.count(),0); + + gesture->stopDetection(); + QCOMPARE(gesture->isActive(),false); + QCOMPARE(spy_gesture.count(),0); + + QVERIFY(gesture->gestureSignals().isEmpty()); + + delete gesture; + gesture = 0; +} + +void Tst_qsensorgestureTest::tst_sensor_gesture_multi() +{ + + QStringList ids; + ids << "QtSensors.test"; + ids <<"QtSensors.test2"; + ids << "QtSensors.bogus"; + + QSensorGesture *gesture = new QSensorGesture(ids,this); + QStringList gestureSignals = gesture->gestureSignals(); + + gestureSignals.removeDuplicates() ; + QVERIFY(gestureSignals == gesture->gestureSignals()); + + QVERIFY(gesture->gestureSignals().count() == 4); + QVERIFY(!gesture->availableIds().contains("QtSensors.bogus")); + + QCOMPARE(gesture->isActive(),false); + + QSignalSpy spy_gesture_detected(gesture, SIGNAL(detected(QString))); + gesture->startDetection(); + QCOMPARE(gesture->isActive(),true); + QCOMPARE(spy_gesture_detected.count(),2); + + QList arguments ; + arguments = spy_gesture_detected.takeAt(0); + QVERIFY(arguments.at(0) == "tested"); + + arguments = spy_gesture_detected.takeAt(0); + QVERIFY(arguments.at(0) == "test2"); + + QVERIFY(::waitForSignal(gesture, SIGNAL(detected(QString)), 60 * 1000)); + QCOMPARE(spy_gesture_detected.count(),1); + + gesture->stopDetection(); + + QCOMPARE(gesture->isActive(),false); + + { + QSensorGestureManager manager; + QVERIFY(!manager.gestureIds().contains("QtSensors.bogus")); + QSensorGestureRecognizer *recognizer = manager.sensorGestureRecognizer("QtSensors.bogus"); + QVERIFY(recognizer == NULL); + } + +} + +void Tst_qsensorgestureTest::shakeDetected(const QString &type) +{ + QCOMPARE(type,currentSignal); +} + +QTEST_MAIN(Tst_qsensorgestureTest); + +#include "tst_qsensorgesturetest.moc" diff --git a/tests/tests.pro b/tests/tests.pro index f1633f70..f9277000 100644 --- a/tests/tests.pro +++ b/tests/tests.pro @@ -1,4 +1,3 @@ TEMPLATE = subdirs SUBDIRS += auto - -- cgit v1.2.3