telutils/dialpad/tsrc/unit/ut_dialpadbluetootheventfilter/ut_dialpadbluetootheventfilter.cpp
changeset 31 a2467631ae02
parent 13 e32024264ebb
child 51 12bc758d6a02
equal deleted inserted replaced
27:7eb70891911c 31:a2467631ae02
    29 #ifdef Q_OS_SYMBIAN
    29 #ifdef Q_OS_SYMBIAN
    30 #include "xqservicerequest.h"
    30 #include "xqservicerequest.h"
    31 #endif
    31 #endif
    32 
    32 
    33 #include "dialpadtest.h"
    33 #include "dialpadtest.h"
       
    34 #include "dialpadtestutil.h"
    34 #include "dialpadbluetootheventfilter.h"
    35 #include "dialpadbluetootheventfilter.h"
    35 #include "dialpad.h"
    36 #include "dialpad.h"
    36 
    37 
    37 const int WAIT_TIME = 300;
    38 const int WAIT_TIME = 300;
    38 QString mService;
    39 QString mService;
    75 // test cases
    76 // test cases
    76 class ut_DialpadBluetoothEventFilter : public QObject
    77 class ut_DialpadBluetoothEventFilter : public QObject
    77 {
    78 {
    78     Q_OBJECT
    79     Q_OBJECT
    79 
    80 
    80 public:
       
    81     enum MouseEventType
       
    82     {
       
    83         Press,
       
    84         Release,
       
    85         Click
       
    86     };
       
    87 
       
    88 private slots:
    81 private slots:
    89     void initTestCase();
    82     void initTestCase();
    90     void init();
    83     void init();
    91     void cleanup();
    84     void cleanup();
    92     void cleanupTestCase();
    85     void cleanupTestCase();
    93     void testLongPressAsteriskKey();
    86     void testLongPressAsteriskKey();
    94     void testShortAndLongPressAsteriskKey();
    87     void testShortAndLongPressAsteriskKey();
    95 
    88 
    96 private:
    89 private:
    97     QGraphicsWidget* getWidgetByName(const QString& name);
       
    98     void mouseClickDialpad(int key, MouseEventType type=Click, bool pause=true);
       
    99 
       
   100 private:
       
   101     HbMainWindow*  mMainWindow;
    90     HbMainWindow*  mMainWindow;
   102     Dialpad*       mDialpad;
    91     Dialpad*       mDialpad;
   103     DialpadBluetoothEventFilter *mEventFilter;
    92     DialpadBluetoothEventFilter *mEventFilter;
   104     KeyEventCatcher* mKeyCatcher;
    93     KeyEventCatcher* mKeyCatcher;
   105     QMap<int,QString> mKeyNames;
    94     DialpadTestUtil* mUtil;
   106 };
    95 };
   107 
    96 
   108 void ut_DialpadBluetoothEventFilter::initTestCase()
    97 void ut_DialpadBluetoothEventFilter::initTestCase()
   109 {
    98 {
   110     mMainWindow = new HbMainWindow;
    99     mMainWindow = new HbMainWindow;
   111 
   100 
   112     mKeyCatcher = new KeyEventCatcher;
   101     mKeyCatcher = new KeyEventCatcher;
   113     mMainWindow->installEventFilter(mKeyCatcher);
   102     mMainWindow->installEventFilter(mKeyCatcher);
       
   103 
       
   104     mUtil = new DialpadTestUtil(*mMainWindow);
   114 
   105 
   115     mDialpad = new Dialpad();
   106     mDialpad = new Dialpad();
   116     mEventFilter = new DialpadBluetoothEventFilter(mDialpad, this);
   107     mEventFilter = new DialpadBluetoothEventFilter(mDialpad, this);
   117     hbInstance->allMainWindows().at(0)->installEventFilter(mEventFilter);
   108     hbInstance->allMainWindows().at(0)->installEventFilter(mEventFilter);
   118             
   109             
   120     rect.setHeight(rect.height()*0.7);
   111     rect.setHeight(rect.height()*0.7);
   121     rect.moveTop((mMainWindow->contentsRect().height()-rect.height())/2);
   112     rect.moveTop((mMainWindow->contentsRect().height()-rect.height())/2);
   122 
   113 
   123     mDialpad->setPreferredSize(360,400);
   114     mDialpad->setPreferredSize(360,400);
   124     mDialpad->setPos(0,100);
   115     mDialpad->setPos(0,100);
   125 
       
   126     mKeyNames.insert(Qt::Key_1,"49");
       
   127     mKeyNames.insert(Qt::Key_2,"50");
       
   128     mKeyNames.insert(Qt::Key_3,"51");
       
   129     mKeyNames.insert(Qt::Key_4,"52");
       
   130     mKeyNames.insert(Qt::Key_5,"53");
       
   131     mKeyNames.insert(Qt::Key_6,"54");
       
   132     mKeyNames.insert(Qt::Key_7,"55");
       
   133     mKeyNames.insert(Qt::Key_8,"56");
       
   134     mKeyNames.insert(Qt::Key_9,"57");
       
   135     mKeyNames.insert(Qt::Key_Asterisk,"42");
       
   136     mKeyNames.insert(Qt::Key_0,"48");
       
   137     mKeyNames.insert(Qt::Key_NumberSign,"35");
       
   138     mKeyNames.insert(Qt::Key_Backspace,"16777219");
       
   139     mKeyNames.insert(Qt::Key_Yes,"16842753");
       
   140 
   116 
   141     mMainWindow->show();
   117     mMainWindow->show();
   142     mDialpad->show();
   118     mDialpad->show();
   143     mDialpad->hide();
   119     mDialpad->hide();
   144 }
   120 }
   154 void ut_DialpadBluetoothEventFilter::cleanupTestCase()
   130 void ut_DialpadBluetoothEventFilter::cleanupTestCase()
   155 {
   131 {
   156     delete mDialpad;
   132     delete mDialpad;
   157     delete mMainWindow;
   133     delete mMainWindow;
   158     delete mKeyCatcher;
   134     delete mKeyCatcher;
       
   135     delete mUtil;
   159 }
   136 }
   160 
   137 
   161 void ut_DialpadBluetoothEventFilter::cleanup()
   138 void ut_DialpadBluetoothEventFilter::cleanup()
   162 {
   139 {
   163     mKeyCatcher->mKeyPresses.clear();
   140     mKeyCatcher->mKeyPresses.clear();
   164     mKeyCatcher->mKeyReleases.clear();
   141     mKeyCatcher->mKeyReleases.clear();
   165     mDialpad->editor().setText(QString());
   142     mDialpad->editor().setText(QString());
   166     QTest::qWait(WAIT_TIME); // delay between tests
   143     QTest::qWait(WAIT_TIME); // delay between tests
   167 }
   144 }
   168 
   145 
   169 QGraphicsWidget* ut_DialpadBluetoothEventFilter::getWidgetByName(const QString& name)
       
   170 {
       
   171     Q_ASSERT(mMainWindow!=0);
       
   172 
       
   173     QGraphicsWidget* widget = 0;
       
   174 
       
   175     QList<QGraphicsItem*> items = mMainWindow->scene()->items();
       
   176     foreach (QGraphicsItem* item, items) {
       
   177         if (item->isWidget()) {
       
   178             QGraphicsWidget *w = static_cast<QGraphicsWidget*>(item);
       
   179             if (w->objectName()==name) {
       
   180                 widget = w;
       
   181             }
       
   182         }
       
   183     }
       
   184 
       
   185     return widget;
       
   186 }
       
   187 
       
   188 void ut_DialpadBluetoothEventFilter::mouseClickDialpad(int key, MouseEventType type, bool pause)
       
   189 {
       
   190     QString name = mKeyNames.value(key);
       
   191 
       
   192     QGraphicsWidget* widget = getWidgetByName(name);
       
   193 
       
   194     if (widget) {
       
   195         QPointF widgetPos = widget->scenePos() + widget->rect().center();
       
   196 
       
   197         QPoint windowPos = mMainWindow->mapFromScene(widgetPos);
       
   198 
       
   199         if (type==Press) {
       
   200             QTest::mousePress(mMainWindow->viewport(), Qt::LeftButton, 0, windowPos);
       
   201         } else if (type==Release) {
       
   202             QTest::mouseRelease(mMainWindow->viewport(), Qt::LeftButton, 0, windowPos);
       
   203         } else {
       
   204             QTest::mouseClick(mMainWindow->viewport(), Qt::LeftButton, 0, windowPos);
       
   205         }
       
   206 
       
   207         if (pause) {
       
   208             QTest::qWait(WAIT_TIME);
       
   209         }
       
   210     } else {
       
   211         QFAIL("Button could not be accessed!");
       
   212     }
       
   213 }
       
   214 
       
   215 void ut_DialpadBluetoothEventFilter::testLongPressAsteriskKey()
   146 void ut_DialpadBluetoothEventFilter::testLongPressAsteriskKey()
   216 {
   147 {
   217     mDialpad->openDialpad();
   148     mDialpad->openDialpad();
   218     QTest::qWait(2*WAIT_TIME);
   149     QTest::qWait(2*WAIT_TIME);
   219 
   150 
   220     // Basic long press
   151     // Basic long press
   221     mouseClickDialpad(Qt::Key_Asterisk, Press);
   152     mUtil->mouseClickDialpad(Qt::Key_Asterisk, DialpadTestUtil::Press);
   222     QTest::qWait(2000);
   153     QTest::qWait(2000);
   223     mouseClickDialpad(Qt::Key_Asterisk, Release);
   154     mUtil->mouseClickDialpad(Qt::Key_Asterisk, DialpadTestUtil::Release);
   224     QTest::qWait(1000);
   155     QTest::qWait(1000);
   225     QCOMPARE(mDialpad->editor().text(), QString(""));
   156     QCOMPARE(mDialpad->editor().text(), QString(""));
   226     mDialpad->closeDialpad();
   157     mDialpad->closeDialpad();
   227     
   158     
   228     QVERIFY(mXQServiceConstructed == true);
   159     QVERIFY(mXQServiceConstructed == true);
   234 void ut_DialpadBluetoothEventFilter::testShortAndLongPressAsteriskKey()
   165 void ut_DialpadBluetoothEventFilter::testShortAndLongPressAsteriskKey()
   235 {
   166 {
   236     mDialpad->openDialpad();
   167     mDialpad->openDialpad();
   237 
   168 
   238     // Short press and long press shouldn't do anything
   169     // Short press and long press shouldn't do anything
   239     mouseClickDialpad(Qt::Key_Asterisk, Press);
   170     mUtil->mouseClickDialpad(Qt::Key_Asterisk, DialpadTestUtil::Press);
   240     mouseClickDialpad(Qt::Key_Asterisk, Release);
   171     mUtil->mouseClickDialpad(Qt::Key_Asterisk, DialpadTestUtil::Release);
   241     mouseClickDialpad(Qt::Key_Asterisk, Press);
   172     mUtil->mouseClickDialpad(Qt::Key_Asterisk, DialpadTestUtil::Press);
   242     QTest::qWait(2000);
   173     QTest::qWait(2000);
   243     mouseClickDialpad(Qt::Key_Asterisk, Release);
   174     mUtil->mouseClickDialpad(Qt::Key_Asterisk, DialpadTestUtil::Release);
   244     QCOMPARE(mDialpad->editor().text(), QString("**"));
   175     QCOMPARE(mDialpad->editor().text(), QString("**"));
   245     mDialpad->closeDialpad();	
   176     mDialpad->closeDialpad();	
   246 }
   177 }
   247 
   178 
   248 DIALPAD_TEST_MAIN(ut_DialpadBluetoothEventFilter)
   179 DIALPAD_TEST_MAIN(ut_DialpadBluetoothEventFilter)