58     void testTimeColumnContainsEvent();

    59     void testTimeColumnAddOffset();

    60     void testSlotIntervalAddOffset();

    61     void testSlotIntervalOverlaps();

    62     void testSlotIntervalUnion();

    63     void testSlotIntervalAdjacent();

    64     void testRegionAddOffset();

    65     void testRegionOverlaps();

    66     void testIsAlldayEvent_data();

    67     void testIsAlldayEvent();

    68     void testGetLocation();

    69     void testGetSelectedSlot();

    70     void testFindRegion();

    71     void testFindEvent();

    72     void testIsAlldayEventSelected();

    73     void testAlldayEvent();

   386  Test CalenTimeColumn::ContainsEvent() function

   387  1. Test ContainsEvent(), no events

   388  2. Test ContainsEvent(), events found

   389  */

   390 void TestCalenDayInfo::testTimeColumnContainsEvent() 

   391 {

   392     CalenTimeColumn column;

   393     

   394     //1)

   395     ulong id = 1;

   396     QDateTime dateTime = QDateTime::currentDateTime();

   397     bool instanceViewed = true;

   398     TCalenInstanceId instanceId(id, dateTime, instanceViewed);

   399     QCOMPARE(column.ContainsEvent(instanceId), false);

   400     

   401     //2)

   402     CalenTimedEventInfo info;

   403     info.iStartSlot = 5;

   404     info.iEndSlot = 10;

   405     info.iId = instanceId;

   406     column.AddEvent(info);

   407     QCOMPARE(column.ContainsEvent(instanceId), true);

   408 }

   409 

   410 /*!

   411  Test CalenTimeColumn::AddOffset() function

   412  1. Test addOffset, offset = 0

   413  2. Test addOffset, offset != 0, no events

   414  3. Test addOffset, offset != 0, events count > 0

   415  */

   416 void TestCalenDayInfo::testTimeColumnAddOffset()

   417 {

   418     const int start = 5;

   419     const int end = 10;

   420     CalenTimeColumn column;

   421     column.iStartSlot = start;

   422     column.iEndSlot = end;

   423     

   424     //1)

   425     int offset = 0;

   426     column.AddOffset(offset, 0);

   427     QCOMPARE(column.iStartSlot, start);

   428     QCOMPARE(column.iEndSlot, end);

   429     

   430     //2)

   431     offset = 5;

   432     column.AddOffset(offset, 0);

   433     QCOMPARE(column.iStartSlot, start + offset);

   434     QCOMPARE(column.iEndSlot, end + offset);

   435     

   436     //3)

   437     column.iStartSlot = start;

   438     column.iEndSlot = end;

   439     CalenTimedEventInfo eventInfo;

   440     eventInfo.iStartSlot = start;

   441     eventInfo.iEndSlot = end;

   442     column.iEventArray.append(eventInfo);

   443     column.AddOffset(offset, 0);

   444     QCOMPARE(column.iStartSlot, start + offset);

   445     QCOMPARE(column.iEndSlot, end + offset);

   446     QCOMPARE(column.iEventArray.at(0).iStartSlot, start + offset);

   447     QCOMPARE(column.iEventArray.at(0).iEndSlot, end + offset);

   448 }

   449 

   450 /*!

   451  Test CalenSlotInterval::AddOffset() function

   452  1. Test addOffset, pos < iStartSlot

   453  2. Test addOffset, pos > iStartSlot

   454  3. Test addOffset, pos > iEndSlot

   455  */

   456 void TestCalenDayInfo::testSlotIntervalAddOffset()

   457 {

   458     const int start = 5;

   459     const int end = 10;

   460     

   461     CalenSlotInterval interval;

   462     interval.iStartSlot = start;

   463     interval.iEndSlot = end;

   464     

   465     //1)

   466     int offset = 2;

   467     int pos = 0;

   468     interval.AddOffset(offset, pos);

   469     QCOMPARE(interval.iStartSlot, start + offset);

   470     QCOMPARE(interval.iEndSlot, end + offset);

   471     

   472     //2)

   473     pos = 6;

   474     interval.iStartSlot = start;

   475     interval.iEndSlot = end;

   476     interval.AddOffset(offset, pos);

   477     QCOMPARE(interval.iStartSlot, start);

   478     QCOMPARE(interval.iEndSlot, end + offset);

   479     

   480     //3)

   481     pos = 12;

   482     interval.iStartSlot = start;

   483     interval.iEndSlot = end;

   484     interval.AddOffset(offset, pos);

   485     QCOMPARE(interval.iStartSlot, start);

   486     QCOMPARE(interval.iEndSlot, end);

   487 }

   488 

   489 /*!

   490  Test CalenSlotInterval::Overlaps() function

   491  1. Test non overlapping interval

   492  2. Test overlapping interval

   493  3. Test overlapping interval

   494  */

   495 void TestCalenDayInfo::testSlotIntervalOverlaps()

   496 {

   497     CalenSlotInterval interval;

   498     interval.iStartSlot = 5;

   499     interval.iEndSlot = 10;

   500     

   501     //1)

   502     CalenSlotInterval testInterval;

   503     testInterval.iStartSlot = 15;

   504     testInterval.iEndSlot = 25;

   505     QCOMPARE(interval.Overlaps(testInterval), false);

   506     

   507     //2)

   508     testInterval.iStartSlot = 1;

   509     testInterval.iEndSlot = 8;

   510     QCOMPARE(interval.Overlaps(testInterval), true);

   511     

   512     //3)

   513     testInterval.iStartSlot = 9;

   514     testInterval.iEndSlot = 15;

   515     QCOMPARE(interval.Overlaps(testInterval), true);

   516 }

   517 

   518 /*!

   519  Test CalenSlotInterval::Union() function

   520  1. Test Union(), empty test interval

   521  2. TTest Union(), non empty test interval

   522  */

   523 void TestCalenDayInfo::testSlotIntervalUnion()

   524 {

   525     const int start = 5;

   526     const int end = 10;

   527     

   528     CalenSlotInterval interval;

   529     interval.iStartSlot = start;

   530     interval.iEndSlot = end;

   531     

   532     //1)

   533     CalenSlotInterval testInterval;

   534     testInterval.iStartSlot = start - 1;

   535     testInterval.iEndSlot = start - 2;

   536     interval.Union(testInterval);

   537     QCOMPARE(interval.iStartSlot, start);

   538     QCOMPARE(interval.iEndSlot, end);

   539     

   540     //2)

   541     testInterval.iStartSlot = start + 1;

   542     testInterval.iEndSlot = end + 1;

   543     interval.Union(testInterval);

   544     QCOMPARE(interval.iStartSlot, start);

   545     QCOMPARE(interval.iEndSlot, end + 1);

   546 }

   547 

   548 /*!

   549  Test CalenSlotInterval::Adjacent() function

   550  1. Test overlapping interval

   551  2. Test non overlapping interval, adjacent

   552  3. Test non overlapping interval, non adjacent

   553  */

   554 void TestCalenDayInfo::testSlotIntervalAdjacent()

   555 {

   556     const int start = 5;

   557     const int end = 10;

   558     

   559     CalenSlotInterval interval;

   560     interval.iStartSlot = start;

   561     interval.iEndSlot = end;

   562     

   563     //1)

   564     CalenSlotInterval testInterval;

   565     testInterval.iStartSlot = start + 1;

   566     testInterval.iEndSlot = end - 1;

   567     QCOMPARE(interval.Adjacent(testInterval), true);

   568     

   569     //2)

   570     testInterval.iStartSlot = start - 3;

   571     testInterval.iEndSlot = start;

   572     QCOMPARE(interval.Adjacent(testInterval), true);

   573     

   574     //3)

   575     testInterval.iStartSlot = start - 3;

   576     testInterval.iEndSlot = start - 1;

   577     QCOMPARE(interval.Adjacent(testInterval), false);

   578 }

   579 

   580 /*!

   581  Test CalenTimeRegion::AddOffset() function

   582  1. Test addOffset, offset = 0, intervals empty, columns empty

   583  2. Test addOffset, offset != 0, intervals empty, columns empty

   584  3. Test addOffset, offset != 0, intervals not empty, columns not empty

   585  */

   586 void TestCalenDayInfo::testRegionAddOffset()

   587 {

   588     CalenTimeRegion region;

   589     

   590     //1)

   591     int offset = 0;

   592     int pos = 0;

   593     region.AddOffset(offset, pos);

   594     QCOMPARE(region.iIntervals.count(), 0);

   595     QCOMPARE(region.iColumns.count(), 0);

   596     

   597     //2)

   598     offset = 2;

   599     region.AddOffset(offset, pos);

   600     QCOMPARE(region.iIntervals.count(), 0);

   601     QCOMPARE(region.iColumns.count(), 0);

   602     

   603     //3)

   604     CalenEventInterval interval;

   605     interval.iStartSlot = 1;

   606     interval.iEndSlot = 5;

   607     region.iIntervals.append(interval);

   608     

   609     CalenTimeColumn column;

   610     column.iStartSlot = 2;

   611     column.iEndSlot = 4;

   612     region.iColumns.append(column);

   613     

   614     region.AddOffset(offset, pos);

   615     

   616     QCOMPARE(region.iIntervals.at(0).iStartSlot, interval.iStartSlot + offset);

   617     QCOMPARE(region.iIntervals.at(0).iEndSlot, interval.iEndSlot + offset);

   618     

   619     QCOMPARE(region.iColumns.at(0).iStartSlot, column.iStartSlot + offset);

   620     QCOMPARE(region.iColumns.at(0).iEndSlot, column.iEndSlot + offset);

   621 }

   622 

   623 /*!

   624  Test CalenTimeRegion::Overlaps() function

   625  1. Test non overlapping

   626  2. Test overlapping

   627  */

   628 void TestCalenDayInfo::testRegionOverlaps()

   629 {

   630     CalenTimeRegion region;

   631     region.iStartSlot = 5;

   632     region.iEndSlot = 10;

   633     

   634     CalenTimeColumn column;

   635     region.iColumns.append(column);

   636     

   637     //1)

   638     CalenSlotInterval testInterval;

   639     testInterval.iStartSlot = 15;

   640     testInterval.iEndSlot = 20;

   641     QCOMPARE(region.Overlaps(testInterval), false);

   642     

   643     //2)

   644     testInterval.iStartSlot = 4;

   645     testInterval.iEndSlot = 12;

   646     QCOMPARE(region.Overlaps(testInterval), true);

   647 }

   648 

   649 /*!

   665 /*!

   666  Test data for testIsAlldayEvent

   667  Data:

   668  1. Test if false is return when days are diferent

   669  Below days are the same

   670  2. Test when start and end time are not midnight

   671  3. Test when start is midnight and end not

   672  4. Test when start is not midnight and end is

   673  5. Test when start and end are midnight

   674  */

   675 void TestCalenDayInfo::testIsAlldayEvent_data()

   676 {

   677     QTest::addColumn<QDateTime>("testedValueStart");

   678     QTest::addColumn<QDateTime>("testedValueEnd");

   679     QTest::addColumn<bool>("testValue");

   680 

   681     QTest::newRow("Diferent days") 

   682                   << QDateTime(QDate(2010,9,14),QTime(12,20))

   683                   << QDateTime(QDate(2010,9,15),QTime(12,20))

   684                   << false;

   685     QTest::newRow("Diferent times, not midnight") 

   686                   << QDateTime(QDate(2010,9,14),QTime(12,20))

   687                   << QDateTime(QDate(2010,9,14),QTime(16,40))

   688                   << false;

   689     QTest::newRow("Diferent times, start is mignight") 

   690                   << QDateTime(QDate(2010,9,14),QTime(0,0))

   691                   << QDateTime(QDate(2010,9,14),QTime(12,20))

   692                   << false;

   693     QTest::newRow("Diferent times, end is mignight") 

   694                   << QDateTime(QDate(2010,9,14),QTime(12,20))

   695                   << QDateTime(QDate(2010,9,14),QTime(0,0))

   696                   << false;

   697     QTest::newRow("Both are midnight") 

   698                   << QDateTime(QDate(2010,9,14),QTime(0,0,0,0))

   699                   << QDateTime(QDate(2010,9,15),QTime(0,0,0,0))

   700                   << true;

   701 }

   702 

   703 /*!

   704   Test function for IsAllDayEvent, it use data from testIsAlldayEvent_data

   705 

   706  */

   707 void TestCalenDayInfo::testIsAlldayEvent()

   708 {

   709     //get data to test

   710     QFETCH(QDateTime, testedValueStart); 

   711     QFETCH(QDateTime, testedValueEnd); 

   712     QFETCH(bool, testValue);

   713 

   714     //make test

   715     QCOMPARE(mInfo->IsAlldayEvent(testedValueStart,testedValueEnd),testValue);

   716     

   717 }

   718 

   719 void TestCalenDayInfo::testGetLocation()

   720 {

   721     

   722 }

   723 

   724 /*!

   725    Test function for getSelectedSlot

   726    1)Check when there is no region is selected

   727    2)Check when region is selected

   728  */

   729 void TestCalenDayInfo::testGetSelectedSlot()

   730 {

   731     int slot = 0;

   732     int region = 0;

   733     int columnIndex = 0;

   734     int columns = 0;

   735     //1)

   736     mInfo->iSelectedRegion = -1;

   737     mInfo->GetSelectedSlot(slot,region,columnIndex,columns);

   738     QCOMPARE(slot , mInfo->iSelectedSlot);

   739     QCOMPARE(region, KErrNotFound);

   740     QCOMPARE(columnIndex, mInfo->iSelectedColumn);

   741     QCOMPARE(columns, 0);

   742     

   743     //2)

   744     CalenTimeRegion timeRegion = CalenTimeRegion();

   745     timeRegion.iColumns << CalenTimeColumn();

   746     mInfo->iRegionList.append(CalenTimeRegion());

   747     mInfo->iRegionList.append(CalenTimeRegion());

   748     

   749     mInfo->iSelectedRegion = 1;

   750     mInfo->GetSelectedSlot(slot,region,columnIndex,columns);

   751     QCOMPARE(slot , mInfo->iSelectedSlot);

   752     QCOMPARE(region, mInfo->iSelectedRegion);

   753     QCOMPARE(columnIndex, mInfo->iSelectedColumn);

   754     QCOMPARE(columns, 0);

   755 }

   756 

   757 /*!

   758    Test function for FindRegion.

   759    1)Preapre region in day infor

   760    2)Prepare region inside above

   761    3)Find this inside region

   762  */

   763 void TestCalenDayInfo::testFindRegion()

   764 {

   765 #ifndef __WINSCW__

   766     //1)

   767     CalenTimeRegion region;

   768     region.iStartSlot = 1;  

   769     region.iEndSlot = 16;  

   770     region.iColumns << CalenTimeColumn();

   771     mInfo->iRegionList.append(region);

   772     

   773     //2)

   774     CalenSlotInterval interval;

   775     interval.iStartSlot = 8;

   776     interval.iEndSlot = 12;

   777     

   778     //3)

   779     QVERIFY(mInfo->FindRegion(interval,1) == 0);

   780 #endif /*__WINSCW__*/

   781 }

   782 

   783 /*!

   784    Test function for FindEvent

   785    1)Prepare events and select one to test

   786    2)Find selected event

   787  */

   788 void TestCalenDayInfo::testFindEvent()

   789 {

   790 #ifndef __WINSCW__

   791     //1)

   792     CalenTimedEventInfo event;

   793     event.iStartSlot = 3;

   794     event.iEndSlot = 13;

   795     

   796     CalenTimeColumn column = CalenTimeColumn();

   797     column.AddEvent(event);

   798     

   799     CalenTimeRegion region;

   800     region.iStartSlot = 1;  

   801     region.iEndSlot = 16;  

   802     region.iColumns << column;

   803     mInfo->iRegionList.append(region);

   804     

   805 

   806     region.iStartSlot = 17;  

   807     region.iEndSlot = 20;  

   808     mInfo->iRegionList.append(region);

   809     

   810     //preapre data to search

   811     CalenSlotInterval interval;

   812     interval.iStartSlot = 8;

   813     interval.iEndSlot = 12;

   814     

   815     mInfo->iSelectedRegion = 0;

   816     mInfo->iSelectedColumn = 0;

   817     

   818     //2)

   819     QVERIFY(mInfo->FindEvent(interval,1) == 0);

   820 #endif /*__WINSCW__*/

   821 }

   822 

   823 /*!

   824   Test function for IsAlldayEventSelected

   825   1)There is no all day event selected

   826   2)There is all day event selected

   827  */

   828 void TestCalenDayInfo::testIsAlldayEventSelected()

   829 {

   830     //1)

   831     QVERIFY(mInfo->IsAlldayEventSelected() == false);

   832     

   833     //2)

   834     mInfo->iSelectedAlldayEvent = 0;

   835     mInfo->iAlldayEvents.append(CalenTimedEventInfo());

   836     

   837     QVERIFY(mInfo->IsAlldayEventSelected() == true);

   838 }

   839 

   840 /*!

   841    Test function for AlldayEvent

   842    1)Prepare all day event at inxdex 0

   843    2)Check if good all day event is returned

   844  */

   845 void TestCalenDayInfo::testAlldayEvent()

   846 {

   847     CalenTimedEventInfo allDayEvent;

   848     TCalenInstanceId id;

   849     id = TCalenInstanceId::create(100, QDateTime(QDate(2010,9,21), QTime(12,12,12)),false);

   850     allDayEvent.iId = id;

   851     mInfo->iAlldayEvents.append(allDayEvent);

   852     

   853     QVERIFY(mInfo->AlldayEvent(0).iId == id);

   854 }