phoneuis/bubblemanager2/tsrc/unit/ut_bubbleheadingwidget/ut_bubbleheadingwidget.cpp
branchGCC_SURGE
changeset 51 f39ed5e045e0
parent 30 ebdbd102c78a
parent 46 bc5a64e5bc3c
equal deleted inserted replaced
40:bab96b7ed1a4 51:f39ed5e045e0
    22 #include <hbmainwindow.h>
    22 #include <hbmainwindow.h>
    23 #include <hbaction.h>
    23 #include <hbaction.h>
    24 #include <hbmainwindow.h>
    24 #include <hbmainwindow.h>
    25 #include <hbinstance.h>
    25 #include <hbinstance.h>
    26 #include <hbstyle.h>
    26 #include <hbstyle.h>
       
    27 #include <hbtextitem.h>
       
    28 #include <hbiconitem.h>
    27 
    29 
    28 #include "bubbletest.h"
    30 #include "bubbletest.h"
    29 #include "bubbleheadingwidget.h"
    31 #include "bubbleheadingwidget.h"
    30 #include "bubbleheader.h"
    32 #include "bubbleheader.h"
    31 #include "bubblemanagerif.h"
    33 #include "bubblemanagerif.h"
    44     void testOneLinedHeading();
    46     void testOneLinedHeading();
    45 
    47 
    46 private:
    48 private:
    47     BubbleHeadingWidget* mHeading;
    49     BubbleHeadingWidget* mHeading;
    48     HbMainWindow* mMainWindow;
    50     HbMainWindow* mMainWindow;
    49     int mStyleBaseId;
    51 
       
    52     HbTextItem* mText1;
       
    53     HbTextItem* mText2;
       
    54     HbTextItem* mText3;
       
    55 
       
    56     HbIconItem* mIndi1;
       
    57     HbIconItem* mIndi2;
       
    58 
    50 };
    59 };
    51 
    60 
    52 void ut_BubbleHeadingWidget::initTestCase()
    61 void ut_BubbleHeadingWidget::initTestCase()
    53 {
    62 {
    54     mMainWindow = new HbMainWindow();
    63     mMainWindow = new HbMainWindow();
    55     mHeading = new BubbleHeadingWidget();
    64     mHeading = new BubbleHeadingWidget();
    56     mMainWindow->addView(mHeading);
    65     mMainWindow->addView(mHeading);
    57     mMainWindow->show();
    66     mMainWindow->show();
       
    67 
       
    68     mText1 = qgraphicsitem_cast<HbTextItem*>(
       
    69                  static_cast<HbWidget*>(mHeading)->primitive("text_line_1"));
       
    70     QVERIFY(mText1);
       
    71     mText2 = qgraphicsitem_cast<HbTextItem*>(
       
    72                  static_cast<HbWidget*>(mHeading)->primitive("text_line_2"));
       
    73     QVERIFY(mText2);
       
    74     mText3 = qgraphicsitem_cast<HbTextItem*>(
       
    75                  static_cast<HbWidget*>(mHeading)->primitive("text_line_3"));
       
    76     QVERIFY(mText3);
       
    77 
       
    78     mIndi1 = qgraphicsitem_cast<HbIconItem*>(
       
    79                 static_cast<HbWidget*>(mHeading)->primitive("indicator_icon_1"));
       
    80     QVERIFY(mIndi1);
       
    81     mIndi2 = qgraphicsitem_cast<HbIconItem*>(
       
    82                 static_cast<HbWidget*>(mHeading)->primitive("indicator_icon_2"));
       
    83     QVERIFY(mIndi2);
    58 }
    84 }
    59 
    85 
    60 void ut_BubbleHeadingWidget::cleanupTestCase()
    86 void ut_BubbleHeadingWidget::cleanupTestCase()
    61 {
    87 {
    62     delete mMainWindow;
    88     delete mMainWindow;
    68     mHeading->reset();
    94     mHeading->reset();
    69 }
    95 }
    70 
    96 
    71 void ut_BubbleHeadingWidget::testThreeLinedHeading()
    97 void ut_BubbleHeadingWidget::testThreeLinedHeading()
    72 {
    98 {
       
    99     mHeading->setLineCount(3);
       
   100 
    73     BubbleHeader header;
   101     BubbleHeader header;
    74     header.setCli("John Doe",Qt::ElideRight);
   102     header.setCli("John Doe",Qt::ElideRight);
    75     header.setSecondaryCli("12345",Qt::ElideLeft);
   103     header.setSecondaryCli("12345",Qt::ElideLeft);
    76     header.setText("",Qt::ElideRight);
   104     header.setText("",Qt::ElideRight);
    77     header.setTimerCost("0:00");
   105     header.setTimerCost("0:00");
    78     header.setCallState(BubbleManagerIF::Active);
   106     header.setCallState(BubbleManagerIF::Active);
    79     header.setCallFlag(BubbleManagerIF::NoCiphering);
   107     header.setCallFlag(BubbleManagerIF::NoCiphering);
    80     mHeading->setLineCount(3);
   108     QVERIFY(mHeading->lineCount()==3);
    81     Q_ASSERT(mHeading->lineCount()==3);
   109     mHeading->readBubbleHeader(header);
    82     mHeading->readBubbleHeader(header);
   110     mHeading->show();
    83     mHeading->show();
   111     QTest::qWait(200);
    84     QTest::qWait(1000);
   112     QVERIFY(mHeading->layout()=="three_lines_1");
       
   113 
       
   114     QVERIFY(mText1->text()=="John Doe");
       
   115     QVERIFY(mText2->text()=="12345");
       
   116     QVERIFY(mText2->alignment()&Qt::AlignLeft);
       
   117     QVERIFY(mText3->text()=="0:00");
       
   118 
       
   119     header.setTimerCost("0:01");
    85     mHeading->updateTimerDisplayNow();
   120     mHeading->updateTimerDisplayNow();
       
   121     QVERIFY(mText3->text()=="0:01");
       
   122 
       
   123     header.setCallState(BubbleManagerIF::Incoming);
       
   124     header.setCallFlag(BubbleManagerIF::NoCiphering);
       
   125     header.setCallFlag(BubbleManagerIF::Diverted);
       
   126     mHeading->readBubbleHeader(header);
       
   127     mHeading->show();
       
   128     QTest::qWait(200);
       
   129     QVERIFY(mHeading->layout()=="three_lines_2");
       
   130 
       
   131     header.setCallFlags(BubbleManagerIF::Normal);
       
   132     mHeading->readBubbleHeader(header);
       
   133     mHeading->show();
       
   134     QTest::qWait(200);
       
   135     QVERIFY(mHeading->layout()=="three_lines");
    86 }
   136 }
    87 
   137 
    88 void ut_BubbleHeadingWidget::testTwoLinedHeading()
   138 void ut_BubbleHeadingWidget::testTwoLinedHeading()
    89 {
   139 {
    90     BubbleHeader header;
       
    91     header.setCli("John Doe",Qt::ElideRight);
       
    92     header.setSecondaryCli("12345",Qt::ElideLeft);
       
    93     header.setText("",Qt::ElideRight);
       
    94     header.setTimerCost("0:00");
       
    95     header.setCallState(BubbleManagerIF::Outgoing);
       
    96     header.setCallFlag(BubbleManagerIF::NoCiphering);
       
    97 
       
    98     mHeading->setLineCount(2);
   140     mHeading->setLineCount(2);
    99     Q_ASSERT(mHeading->lineCount()==2);
   141 
   100     mHeading->readBubbleHeader(header);
       
   101     mHeading->show();
       
   102     QTest::qWait(100);
       
   103     mHeading->updateTimerDisplayNow();
       
   104 }
       
   105 
       
   106 void ut_BubbleHeadingWidget::testOneLinedHeading()
       
   107 {
       
   108     BubbleHeader header;
   142     BubbleHeader header;
   109     header.setCli("John Doe",Qt::ElideRight);
   143     header.setCli("John Doe",Qt::ElideRight);
   110     header.setSecondaryCli("12345",Qt::ElideLeft);
   144     header.setSecondaryCli("12345",Qt::ElideLeft);
   111     header.setText("",Qt::ElideRight);
   145     header.setText("",Qt::ElideRight);
   112     header.setTimerCost("0:00");
   146     header.setTimerCost("0:00");
   113     header.setCallState(BubbleManagerIF::Active);
   147     header.setCallState(BubbleManagerIF::Active);
   114     header.setCallFlag(BubbleManagerIF::NoCiphering);
   148     header.setCallFlag(BubbleManagerIF::NoCiphering);
   115 
   149     QVERIFY(mHeading->lineCount()==2);
       
   150     mHeading->readBubbleHeader(header);
       
   151     mHeading->show();
       
   152     QTest::qWait(200);
       
   153     QVERIFY(mHeading->layout()=="two_lines_1");
       
   154 
       
   155     QVERIFY(mText1->text()=="John Doe");
       
   156     QVERIFY(mText2->text()=="0:00");
       
   157     QVERIFY(mText2->alignment()&Qt::AlignLeft);
       
   158     QVERIFY(!mText3->isVisible());
       
   159 
       
   160     header.setTimerCost("0:01");
       
   161     mHeading->updateTimerDisplayNow();
       
   162     QVERIFY(mText2->text()=="0:01");
       
   163 
       
   164     header.setCallState(BubbleManagerIF::Incoming);
       
   165     header.setCallFlag(BubbleManagerIF::NoCiphering);
       
   166     header.setCallFlag(BubbleManagerIF::Diverted);
       
   167     mHeading->readBubbleHeader(header);
       
   168     mHeading->show();
       
   169     QTest::qWait(200);
       
   170     QVERIFY(mHeading->layout()=="two_lines_2");
       
   171 
       
   172     header.setCallFlags(BubbleManagerIF::Normal);
       
   173     mHeading->readBubbleHeader(header);
       
   174     mHeading->show();
       
   175     QTest::qWait(200);
       
   176     QVERIFY(mHeading->layout()=="two_lines");
       
   177 
       
   178 }
       
   179 
       
   180 void ut_BubbleHeadingWidget::testOneLinedHeading()
       
   181 {
   116     mHeading->setLineCount(1);
   182     mHeading->setLineCount(1);
   117     Q_ASSERT(mHeading->lineCount()==1);
   183 
   118     header.setCallState(BubbleManagerIF::OnHold);
   184     BubbleHeader header;
   119     mHeading->readBubbleHeader(header);
   185     header.setCli("John Doe",Qt::ElideRight);
   120     mHeading->show();
   186     header.setSecondaryCli("12345",Qt::ElideLeft);
   121     QTest::qWait(100);
   187     header.setText("",Qt::ElideRight);
       
   188     header.setTimerCost("0:00");
       
   189     header.setCallState(BubbleManagerIF::Active);
       
   190     header.setCallFlag(BubbleManagerIF::NoCiphering);
       
   191     QVERIFY(mHeading->lineCount()==1);
       
   192     mHeading->readBubbleHeader(header);
       
   193     mHeading->show();
       
   194     QTest::qWait(200);
       
   195     QVERIFY(mHeading->layout()=="one_line_1");
       
   196     QVERIFY(mText1->text()=="John Doe");
       
   197     QVERIFY(mText2->text()=="0:00");
       
   198     QVERIFY(mText2->alignment()&Qt::AlignRight);
       
   199     QVERIFY(!mText3->isVisible());
       
   200 
       
   201     header.setTimerCost("0:01");
   122     mHeading->updateTimerDisplayNow();
   202     mHeading->updateTimerDisplayNow();
       
   203     QVERIFY(mText2->text()=="0:01");
       
   204 
       
   205     header.setCallState(BubbleManagerIF::Incoming);
       
   206     header.setCallFlag(BubbleManagerIF::NoCiphering);
       
   207     header.setCallFlag(BubbleManagerIF::Diverted);
       
   208     mHeading->hide();
       
   209     mHeading->readBubbleHeader(header);
       
   210     mHeading->show();
       
   211     QTest::qWait(200);
       
   212     QVERIFY(mHeading->layout()=="one_line_2");
       
   213     QVERIFY(mText2->alignment()&Qt::AlignRight);
       
   214 
       
   215     header.setCallFlags(BubbleManagerIF::Normal);
       
   216     mHeading->hide();
       
   217     mHeading->readBubbleHeader(header);
       
   218     mHeading->show();
       
   219     QTest::qWait(200);
       
   220     QVERIFY(mHeading->layout()=="one_line");
       
   221     QVERIFY(mText2->alignment()&Qt::AlignRight);
   123 }
   222 }
   124 
   223 
   125 BUBBLE_TEST_MAIN(ut_BubbleHeadingWidget)
   224 BUBBLE_TEST_MAIN(ut_BubbleHeadingWidget)
   126 #include "ut_bubbleheadingwidget.moc"
   225 #include "ut_bubbleheadingwidget.moc"