Merge into trunk : alarm-fetch-fix : Code : Ubuntu UI Toolkit

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Approve on 2014-04-09
Cris Dywan		2014-02-28	Needs Fixing on 2014-04-02
Review via email: mp+208749@code.launchpad.net

Revision history for this message

Zsombor Egri (zsombi) wrote on 2014-02-28:

#

*DO NOT REVIEW IT YET*

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-02-28:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/1807/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-02-28:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/1811/rebuild

review: Approve (continuous-integration)

Revision history for this message

Renato Araujo Oliveira Filho (renatofilho) wrote on 2014-03-06:

#

blank lines:

202 +
203 +

Revision history for this message

Renato Araujo Oliveira Filho (renatofilho) wrote on 2014-03-06:

#

Missing debug:

114 + qDebug() << "UPDATE OCCURRENCE" << alarm.message << alarm.date << occurrence.startDateTime();

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-03-07:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/1849/rebuild

review: Approve (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-03-10:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/1855/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-03-10:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/1859/rebuild

review: Approve (continuous-integration)

Revision history for this message

Nekhelesh Ramananthan (nik90) wrote on 2014-03-10:

#

Okay it was just confirmed to me by Pat McGowan that this MP seems to also fix https://bugs.launchpad.net/ubuntu-clock-app/+bug/1283212. I will do another test to absolutely confirm this after which you can attach that bug report to this MP as well :)

Revision history for this message

Nekhelesh Ramananthan (nik90) wrote on 2014-03-11:

#

So on testing this MP with the ubuntu-clock-app, here are the following observations,

1. Bug #1283859 doesn't appear to be fixed. The indicator-datetime does not show the updated recurring alarm values despite it being shown in the clock app.

2. Bug #1285958 seemed already fixed with Renato's patch to EDS which one can find at https://code.launchpad.net/~renatofilho/qtorganizer5-eds/fix-1285958/+merge/209791. On talking to zsombi on IRC, he told me that this patch was only for alarms <7 days. While this MP is also meant to fix it for >7 days. However this is not testable using the clock app. Hence I am unable to confirm the fix.

3. It also appears that this MP seemed to have fixed Bug #1283212. This bug was reported by Pat Mcgowan who was able to reproduce the bug in image #229. However after installing this MP, I was unable to reproduce the bug again.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-03-28:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/1967/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-03-31:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/1972/rebuild

review: Approve (continuous-integration)

Revision history for this message

Cris Dywan (kalikiana) wrote on 2014-03-31:

#

// do we get segfault because this is missing?

That's a strange comment. I'd assume you want to a) use deleteLater because you know that it can be used until the next main loop iteration, and have the comment say that, idealy by what b) or you scratch both the comment and the deleterLater if this isn't the case c) or FIXME: Work-around unexplained use of fetchRequest

// with EDS we need to query the occurrences separately as the fetch reports only the main events

Is there a bug on fixing the EDS backend?

// if we are on Monday, the first alarm occurrence is gonna be on Wednesday!

It's very bad to have different test results based on when it runs. I'd rather you mock the date or tweak the environment to test both.

QString envManager(qgetenv("ALARM_BACKEND"));

Would be good to have a test case to check that this works. And it might best to unconditionally set it so that you don't have to scratch your head on whether it was picked up or not but simply fails or works.

review: Needs Fixing

Revision history for this message

Zsombor Egri (zsombi) wrote on 2014-03-31:

#

> // do we get segfault because this is missing?
>
> That's a strange comment. I'd assume you want to a) use deleteLater because
> you know that it can be used until the next main loop iteration, and have the
> comment say that, idealy by what b) or you scratch both the comment and the
> deleterLater if this isn't the case c) or FIXME: Work-around unexplained use
> of fetchRequest

Right, that comment was left there by mistake :)

>
> // with EDS we need to query the occurrences separately as the fetch reports
> only the main events
>
> Is there a bug on fixing the EDS backend?

There was a bug, the fix had landed way before... More than 1 month ago... The fix was made right after the Toolkit's alarm fetch got broken. However, the same logic works well with the memory manager, so basically there's no difference in logic. We skip the occurrences in the main fetch loop anyway, and only memory manager reports occurrences there (in completeFetchAlarms()). If EDS would report occurrences in the same way, we would be in trouble again, performance wise that's unacceptable.

>
> // if we are on Monday, the first alarm occurrence is gonna be on Wednesday!
>
> It's very bad to have different test results based on when it runs. I'd rather
> you mock the date or tweak the environment to test both.

I'll redo the test as it supposed to test whether the first occurrence is the right one. For instance if today is Monday and the occurrence is set to Sunday and Monday, the first occurrence of the alarm should be on Sunday the same week.

>
> QString envManager(qgetenv("ALARM_BACKEND"));
>
> Would be good to have a test case to check that this works. And it might best
> to unconditionally set it so that you don't have to scratch your head on
> whether it was picked up or not but simply fails or works.

This is tricky, as we only have two managers, eds and memory, and eds might not even be available, so I cannot be sure whether that will work. I can only test with arbitrary garbage unavailability....

> // do we get segfault because this is missing?
> 
> That's a strange comment. I'd assume you want to a) use deleteLater because
> you know that it can be used until the next main loop iteration, and have the
> comment say that, idealy by what b) or you scratch both the comment and the
> deleterLater if this isn't the case c) or FIXME: Work-around unexplained use
> of fetchRequest

Right, that comment was left there by mistake :)

> 
> // with EDS we need to query the occurrences separately as the fetch reports
> only the main events
> 
> Is there a bug on fixing the EDS backend?

There was a bug, the fix had landed way before... More than 1 month ago... The fix was made right after the Toolkit's alarm fetch got broken. However, the same logic works well with the memory manager, so basically there's no difference in logic. We skip the occurrences in the main fetch loop anyway, and only memory manager reports occurrences there (in completeFetchAlarms()). If EDS would report occurrences in the same way, we would be in trouble again, performance wise that's unacceptable.

> 
> // if we are on Monday, the first alarm occurrence is gonna be on Wednesday!
> 
> It's very bad to have different test results based on when it runs. I'd rather
> you mock the date or tweak the environment to test both.

I'll redo the test as it supposed to test whether the first occurrence is the right one. For instance if today is Monday and the occurrence is set to Sunday and Monday, the first occurrence of the alarm should be on Sunday the same week.

> 
>  QString envManager(qgetenv("ALARM_BACKEND"));
> 
> Would be good to have a test case to check that this works. And it might best
> to unconditionally set it so that you don't have to scratch your head on
> whether it was picked up or not but simply fails or works.

This is tricky, as we only have two managers, eds and memory, and eds might not even be available, so I cannot be sure whether that will work. I can only test with arbitrary garbage unavailability....

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-03-31:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/1973/rebuild

review: Approve (continuous-integration)

Revision history for this message

Cris Dywan (kalikiana) wrote on 2014-04-02:

#

Thanks for the update.

review: Approve

lp:~zsombi/ubuntu-ui-toolkit/alarm-fetch-fix updated on 2014-04-02

962. By Zsombor Egri on 2014-04-02: small fixes, stronger tests
963. By Zsombor Egri on 2014-04-02: trunk merge

Revision history for this message

Cris Dywan (kalikiana) wrote on 2014-04-02:

#

// } else if (rawData.type != UCAlarm::OneTime) {

This confused me a bit why OneTime is relevant there.

How about changing checkDow() to avoid != to make it less confusing.

// alarm.setDate(QDateTime::currentDateTime().addDays(1));

Somehow this looks arbitrary. Given the fact that it worked before and the week has neither 5 nor 1 days what exactly is the goal here?

review: Needs Fixing

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-04-02:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/1982/rebuild

review: Needs Fixing (continuous-integration)

lp:~zsombi/ubuntu-ui-toolkit/alarm-fetch-fix updated on 2014-04-03

964. By Zsombor Egri on 2014-04-03: kick

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-04-03:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/1984/rebuild

review: Approve (continuous-integration)

Revision history for this message

Zsombor Egri (zsombi) wrote on 2014-04-09:

#

> // } else if (rawData.type != UCAlarm::OneTime) {
>
> This confused me a bit why OneTime is relevant there.
>
> How about changing checkDow() to avoid != to make it less confusing.

Actually you are right, that is not in the right place there. I've moved the code under the recurring alarm check.

>
> // alarm.setDate(QDateTime::currentDateTime().addDays(1));
>
> Somehow this looks arbitrary. Given the fact that it worked before and the
> week has neither 5 nor 1 days what exactly is the goal here?

It doesn't matter how many days are added. The test checks whether an already created alarm updates properly. I'll revert to the original one.

lp:~zsombi/ubuntu-ui-toolkit/alarm-fetch-fix updated on 2014-04-09

965. By Zsombor Egri on 2014-04-09: comments addressed, recurring alarm specific code moved to its proper place

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-04-09:

#

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/2018/rebuild

review: Approve (continuous-integration)

Revision history for this message

Zsombor Egri (zsombi) wrote on 2014-04-10:

#

> > // } else if (rawData.type != UCAlarm::OneTime) {
> >
> > This confused me a bit why OneTime is relevant there.
> >
> > How about changing checkDow() to avoid != to make it less confusing.
>
> Actually you are right, that is not in the right place there. I've moved the
> code under the recurring alarm check.

And also refactored a bit. The date adjustment wasn't really belonging to that method, so I wiped the block out as the code under checkRecurringAlarm() already does the adjustments.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2014-04-10:

#

> > > // } else if (rawData.type != UCAlarm::OneTime) {
> > >
> > > This confused me a bit why OneTime is relevant there.
> > >
> > > How about changing checkDow() to avoid != to make it less confusing.
> >
> > Actually you are right, that is not in the right place there. I've moved the
> > code under the recurring alarm check.
>
> And also refactored a bit. The date adjustment wasn't really belonging to that
> method, so I wiped the block out as the code under checkRecurringAlarm()
> already does the adjustments.

Sorry, checkRepeatingWeekly() I mean :)

lp:~zsombi/ubuntu-ui-toolkit/alarm-fetch-fix updated on 2014-04-10

966. By Zsombor Egri on 2014-04-10: date adjustments moved into checkRepeatingWeekly(); date normalization removed from test case, as that is not the ususl way to give datetime to API.
967. By Zsombor Egri on 2014-04-10: staging merge

Ubuntu UI Toolkit

Merge lp:~zsombi/ubuntu-ui-toolkit/alarm-fetch-fix into lp:ubuntu-ui-toolkit

Commit message

Description of the change

Unmerged revisions

Preview Diff

Subscribers

 === modified file 'components.api'
 --- components.api	2014-04-01 12:57:27 +0000
 +++ components.api	2014-04-10 09:49:53 +0000
@@ -593,6 +593,8 @@
      function findChild(obj,objectName)
      function findInvisibleChild(obj,objectName)
      function mouseMoveSlowly(item,x,y,dx,dy,steps,stepdelay)
++    function flick(item, x, y, dx, dy, pressTimeout, steps, button, modifiers, delay)
++    function mouseLongPress(item, x, y, button, modifiers, delay)
      function tryCompareFunction(func, expectedResult, timeout)
  plugins.qmltypes
      name: "InverseMouseAreaType"
 === modified file 'modules/Ubuntu/Components/plugin/adapters/alarmsadapter_organizer.cpp'
 --- modules/Ubuntu/Components/plugin/adapters/alarmsadapter_organizer.cpp	2014-02-21 20:02:29 +0000
 +++ modules/Ubuntu/Components/plugin/adapters/alarmsadapter_organizer.cpp	2014-04-10 09:49:53 +0000
@@ -21,6 +21,7 @@
  #include "alarmmanager_p.h"
  #include "alarmrequest_p.h"
  #include "alarmsadapter_p.h"
++#include <qorganizertodooccurrence.h>
  #include <QtCore/QFile>
  #include <QtCore/QDir>
@@ -55,11 +56,15 @@
      , manager(0)
      , fetchRequest(0)
+ {
--    QOrganizerManager local;
--    bool usingDefaultManager = local.availableManagers().contains(ALARM_MANAGER);
--    manager = (usingDefaultManager) ? new QOrganizerManager(ALARM_MANAGER) : new QOrganizerManager(ALARM_MANAGER_FALLBACK);
++    QString envManager(qgetenv("ALARM_BACKEND"));
++    if (!envManager.isEmpty() && QOrganizerManager::availableManagers().contains(envManager)) {
++        manager = new QOrganizerManager(envManager);
++    } else {
++        manager = QOrganizerManager::availableManagers().contains(ALARM_MANAGER) ?
++                    new QOrganizerManager(ALARM_MANAGER) : new QOrganizerManager(ALARM_MANAGER_FALLBACK);
++    }
      manager->setParent(q_ptr);
--    if (!usingDefaultManager) {
++    if (manager->managerName() != ALARM_MANAGER) {
          qWarning() << "WARNING: default alarm manager not installed, using" << manager->managerName() << "manager.";
          qWarning() << "This manager may not provide all the needed features.";
+     }
@@ -114,6 +119,7 @@
          int type, days;
          in >> alarm.message >> alarm.date >> alarm.sound >> type >> days >> alarm.enabled;
++        alarm.originalDate = alarm.date;
          alarm.type = static_cast<UCAlarm::AlarmType>(type);
          alarm.days = static_cast<UCAlarm::DaysOfWeek>(days);
@@ -142,7 +148,7 @@
      Q_FOREACH(const AlarmData &alarm, alarmList) {
          out << alarm.message
--            << alarm.date
++            << alarm.originalDate
              << alarm.sound
              << alarm.type
              << alarm.days
@@ -157,7 +163,6 @@
      event.setCollectionId(collection.id());
      event.setAllDay(false);
      event.setStartDateTime(alarm.date);
--    event.setDueDateTime(alarm.date);
      event.setDisplayLabel(alarm.message);
      if (alarm.enabled) {
@@ -224,8 +229,9 @@
      alarm.cookie = QVariant::fromValue<QOrganizerItemId>(event.id());
      alarm.message = event.displayLabel();
--    alarm.date = AlarmData::normalizeDate(event.dueDateTime());
++    alarm.date = AlarmData::normalizeDate(event.startDateTime());
      alarm.sound = QUrl(event.description());
++    alarm.originalDate = alarm.date;
      // check if the alarm is enabled or not
      QOrganizerItemVisualReminder visual = event.detail(QOrganizerItemDetail::TypeVisualReminder);
@@ -303,8 +309,8 @@
      Q_FOREACH(const QOrganizerItem &item, alarms) {
          // repeating alarms may be fetched as occurences, therefore check their parent event
          if (item.type() == QOrganizerItemType::TypeTodoOccurrence) {
--            QOrganizerTodoOccurrence occurence = static_cast<QOrganizerTodoOccurrence>(item);
--            QOrganizerItemId eventId = occurence.parentId();
++            QOrganizerTodoOccurrence occurrence = static_cast<QOrganizerTodoOccurrence>(item);
++            QOrganizerItemId eventId = occurrence.parentId();
              if (parentId.contains(eventId)) {
                  continue;
+             }
@@ -317,6 +323,7 @@
+         }
          AlarmData alarm;
          if (alarmDataFromOrganizerEvent(event, alarm) == UCAlarm::NoError) {
++            adjustAlarmOccurrence(event, alarm);
              alarmList << alarm;
+         }
+     }
@@ -324,9 +331,48 @@
      saveAlarms();
      Q_EMIT q_ptr->alarmsChanged();
      completed = true;
++    fetchRequest->deleteLater();
      fetchRequest = 0;
+ }
++void AlarmsAdapter::adjustAlarmOccurrence(const QOrganizerTodo &event, AlarmData &alarm)
++{
++    if (alarm.type == UCAlarm::OneTime) {
++        return;
++    }
++    // with EDS we need to query the occurrences separately as the fetch reports only the main events
++    // with fallback manager this does not reduce the performance and does work the same way.
++    QDateTime currentDate = AlarmData::normalizeDate(QDateTime::currentDateTime());
++    if (alarm.date > currentDate) {
++        // no need to adjust date, the event occurs in the future
++        return;
++    }
++    QDateTime startDate;
++    QDateTime endDate;
++    if (alarm.type == UCAlarm::Repeating) {
++        // 8 days is enough from the starting date (or current date depending on the start date)
++        startDate = (alarm.date > currentDate) ? alarm.date : currentDate;
++        endDate = startDate.addDays(8);
++    }
++
++    QList<QOrganizerItem> occurrences = manager->itemOccurrences(event, startDate, endDate, 10);
++    // get the first occurrence and use the date from it
++    if ((occurrences.length() > 0) && (occurrences[0].type() == QOrganizerItemType::TypeTodoOccurrence)) {
++        // loop till we get a proper future due date
++        for (int i = 0; i < occurrences.count(); i++) {
++            QOrganizerTodoOccurrence occurrence = static_cast<QOrganizerTodoOccurrence>(occurrences[i]);
++            // check if the date is after the current datetime
++            // the first occurrence is the one closest to the currentDate, therefore we can safely
++            // set that startDate to the alarm
++            alarm.date = occurrence.startDateTime();
++            if (alarm.date > currentDate) {
++                // we have the proper date set, leave
++                break;
++            }
++        }
++    }
++}
++
  /*-----------------------------------------------------------------------------
   * AlarmRequestAdapter implementation
   */
@@ -410,23 +456,10 @@
      QOrganizerItemFetchRequest *operation = new QOrganizerItemFetchRequest(q_ptr);
      operation->setManager(owner->manager);
--    // FIXME: Since returning all events without a limit of date is not a good solution we need to find
--    // a better solution for that.
--    // The current solution filters only the next 7 days (one week).
--    // This will be enough for now, since the current alarms occur weekly, but for the future
--    // we want to allow create alarms with monthly or yearly recurrence
--    QDate currentDate = QDate::currentDate();
--    QDateTime startDate(currentDate,
--                        QTime(0,0,0));
--    QDateTime endDate(currentDate.addDays(7),
--                      QTime(23,59,59));
--    operation->setStartDate(startDate);
--    operation->setEndDate(endDate);
--
      // set sort order
      QOrganizerItemSortOrder sortOrder;
      sortOrder.setDirection(Qt::AscendingOrder);
--    sortOrder.setDetail(QOrganizerItemDetail::TypeTodoTime, QOrganizerTodoTime::FieldDueDateTime);
++    sortOrder.setDetail(QOrganizerItemDetail::TypeTodoTime, QOrganizerTodoTime::FieldStartDateTime);
      operation->setSorting(QList<QOrganizerItemSortOrder>() << sortOrder);
      // set filter
 === modified file 'modules/Ubuntu/Components/plugin/adapters/alarmsadapter_p.h'
 --- modules/Ubuntu/Components/plugin/adapters/alarmsadapter_p.h	2013-09-18 10:13:04 +0000
 +++ modules/Ubuntu/Components/plugin/adapters/alarmsadapter_p.h	2014-04-10 09:49:53 +0000
@@ -24,6 +24,7 @@
  #include <qorganizer.h>
  #include <qorganizermanager.h>
++#include <qorganizertodo.h>
  QTORGANIZER_USE_NAMESPACE
@@ -78,6 +79,7 @@
      QOrganizerCollection collection;
      void completeFetchAlarms(const QList<QOrganizerItem> &alarmList);
++    void adjustAlarmOccurrence(const QOrganizerTodo &event, AlarmData &alarm);
      void loadAlarms();
      void saveAlarms();
 === modified file 'modules/Ubuntu/Components/plugin/alarmmanager_p.h'
 --- modules/Ubuntu/Components/plugin/alarmmanager_p.h	2013-09-12 05:27:40 +0000
 +++ modules/Ubuntu/Components/plugin/alarmmanager_p.h	2014-04-10 09:49:53 +0000
@@ -48,6 +48,7 @@
      AlarmData(const AlarmData &other)
          : changes(0)
          , cookie(other.cookie)
++        , originalDate(other.originalDate)
          , date(other.date)
          , message(other.message)
          , type(other.type)
@@ -104,6 +105,7 @@
      QVariant cookie;
      // data members
++    QDateTime originalDate;
      QDateTime date;
      QString message;
      QUrl sound;
 === modified file 'modules/Ubuntu/Components/plugin/ucalarm.cpp'
 --- modules/Ubuntu/Components/plugin/ucalarm.cpp	2013-09-18 10:25:18 +0000
 +++ modules/Ubuntu/Components/plugin/ucalarm.cpp	2014-04-10 09:49:53 +0000
@@ -102,15 +102,21 @@
  int UCAlarmPrivate::nextDayOfWeek(UCAlarm::DaysOfWeek days, int fromDay)
+ {
--    if (fromDay <= 0) {
++    if (fromDay <= 0 || fromDay >= Qt::Sunday) {
++        // start from the beginning of the week
          fromDay = Qt::Monday;
++    } else {
++        // start checking from the next day onwards
++        fromDay++;
+     }
      for (int d = fromDay; d <= Qt::Sunday; d++) {
          if ((1 << (d - 1)) & days) {
              return d;
+         }
+     }
--    return 0;
++
++    // none found for the rest of the week, return the fist day set
++    return firstDayOfWeek(days);
+ }
  // checks whether the given num has more than one bit set
@@ -147,23 +153,14 @@
      return UCAlarm::NoError;
+ }
--UCAlarm::Error UCAlarmPrivate::checkDow()
++// adjust dayOfWeek
++UCAlarm::Error UCAlarmPrivate::adjustDow()
+ {
      if (!rawData.days) {
          return UCAlarm::NoDaysOfWeek;
      } else if (rawData.days == UCAlarm::AutoDetect) {
          rawData.days = dayOfWeek(rawData.date);
          rawData.changes |= AlarmData::Days;
--    } else if (rawData.days != UCAlarm::Daily) {
--        int alarmDay = firstDayOfWeek(rawData.days);
--        int dayOfWeek = rawData.date.date().dayOfWeek();
--        if (alarmDay < dayOfWeek) {
--            rawData.date = rawData.date.addDays(7 - dayOfWeek + alarmDay);
--            rawData.changes |= AlarmData::Date;
--        } else if (alarmDay > dayOfWeek) {
--            rawData.date = rawData.date.addDays(alarmDay - dayOfWeek);
--            rawData.changes |= AlarmData::Date;
--        }
+     }
      return UCAlarm::NoError;
+ }
@@ -175,8 +172,7 @@
          return UCAlarm::OneTimeOnMoreDays;
+     }
--    // adjust start date and/or dayOfWeek according to their values
--    UCAlarm::Error result = checkDow();
++    UCAlarm::Error result = adjustDow();
      if (result != UCAlarm::NoError) {
          return result;
+     }
@@ -193,23 +189,25 @@
      // start date is adjusted depending on the days value;
      // start date can be set to be the current time, as scheduling will move
      // it to the first occurence.
--    UCAlarm::Error result = checkDow();
++    UCAlarm::Error result = adjustDow();
      if (result != UCAlarm::NoError) {
          return result;
+     }
--    // move start time to the first occurence if needed
++    // move start time of the first occurence if needed
      int dayOfWeek = rawData.date.date().dayOfWeek();
      if (!isDaySet(dayOfWeek, rawData.days) || (rawData.date <= QDateTime::currentDateTime())) {
          // check the next occurence of the alarm
--        int nextOccurence = nextDayOfWeek(rawData.days, dayOfWeek);
--        if (nextOccurence <= 0) {
--             // the starting date should be moved to the next week
--            nextOccurence = firstDayOfWeek(rawData.days);
--            rawData.date.addDays(7 - dayOfWeek + nextOccurence);
++        int nextOccurrence = nextDayOfWeek(rawData.days, dayOfWeek);
++        if (nextOccurrence == dayOfWeek) {
++            // move the date to the same day next week
++            rawData.date = rawData.date.addDays(7);
++        } else if (nextOccurrence < dayOfWeek) {
++             // the starting date should be moved to the next week's occurrence
++            rawData.date = rawData.date.addDays(7 - dayOfWeek + nextOccurrence);
          } else {
              // the starting date is still this week
--            rawData.date.addDays(nextOccurence - dayOfWeek);
++            rawData.date = rawData.date.addDays(nextOccurrence - dayOfWeek);
+         }
          rawData.changes |= AlarmData::Date;
+     }
@@ -304,7 +302,7 @@
      : QObject(parent)
      , d_ptr(new UCAlarmPrivate(this))
+ {
--    d_ptr->rawData.date = dt;
++    d_ptr->rawData.date = AlarmData::normalizeDate(dt);
      if (!message.isEmpty()) {
          d_ptr->rawData.message = message;
+     }
@@ -315,7 +313,7 @@
      : QObject(parent)
      , d_ptr(new UCAlarmPrivate(this))
+ {
--    d_ptr->rawData.date = dt;
++    d_ptr->rawData.date = AlarmData::normalizeDate(dt);
      d_ptr->rawData.type = Repeating;
      d_ptr->rawData.days = days;
      if (!message.isEmpty()) {
@@ -366,12 +364,16 @@
  void UCAlarm::setDate(const QDateTime &date)
+ {
      Q_D(UCAlarm);
--    if (d->rawData.date == date) {
++    if (d->rawData.date == AlarmData::normalizeDate(date)) {
          return;
+     }
--    d->rawData.date = date;
++    d->rawData.date = AlarmData::normalizeDate(date);
      d->rawData.changes |= AlarmData::Date;
      Q_EMIT dateChanged();
++    if (d->rawData.type == UCAlarm::OneTime) {
++        // adjust dayOfWeek as well
++        setDaysOfWeek(UCAlarm::AutoDetect);
++    }
+ }
  /*!
@@ -520,6 +522,8 @@
      Q_EMIT soundChanged();
+ }
++
++
  /*!
   * \qmlproperty Error Alarm::error
   * The property holds the error code occurred during the last performed operation.
@@ -670,6 +674,8 @@
      if (result != UCAlarm::NoError) {
          d->_q_syncStatus(Saving, Fail, result);
      } else {
++        // the alarm has been modified, therefore update the original date as well
++        d->rawData.originalDate = d->rawData.date;
          if (d->createRequest()) {
              d->request->save(d->rawData);
+         }
 === modified file 'modules/Ubuntu/Components/plugin/ucalarm_p.h'
 --- modules/Ubuntu/Components/plugin/ucalarm_p.h	2013-09-18 10:25:18 +0000
 +++ modules/Ubuntu/Components/plugin/ucalarm_p.h	2014-04-10 09:49:53 +0000
@@ -50,7 +50,7 @@
      static int nextDayOfWeek(UCAlarm::DaysOfWeek days, int fromDay);
      static bool multipleDaysSet(UCAlarm::DaysOfWeek days);
      UCAlarm::Error checkAlarm();
--    UCAlarm::Error checkDow();
++    UCAlarm::Error adjustDow();
      UCAlarm::Error checkOneTime();
      UCAlarm::Error checkRepeatingWeekly();
 === modified file 'modules/Ubuntu/Test/UbuntuTestCase.qml'
 --- modules/Ubuntu/Test/UbuntuTestCase.qml	2014-02-25 12:36:27 +0000
 +++ modules/Ubuntu/Test/UbuntuTestCase.qml	2014-04-10 09:49:53 +0000
@@ -87,7 +87,75 @@
+ 		}
+ 	}
--	/*!
++    /*!
++      \qmlmethod UbuntuTestCase::flick(item, x, y, dx, dy, pressTimeout = -1, steps = -1, button = Qt.LeftButton, modifiers = Qt.NoModifiers, delay = -1)
++
++      The function produces a flick event when executed on Flickables. When used
++      on other components it provides the same functionality as \l mouseDrag()
++      function. The optional \a pressTimeout parameter can be used to introduce
++      a small delay between the mouse press and the first mouse move. Setting a
++      negative or zero value will disable the timeout.
++
++      The default flick velocity is built up using 5 move points. This can be altered
++      by setting a positive value to \a steps parameter. The bigger the number the
++      longer the flick will be. When a negative or zero value is given, the default
++      of 5 move points will be used.
++
++      \note The function can be used to select a text in a TextField or TextArea by
++      specifying at least 400 millisecods to \a pressTimeout.
++      */
++    function flick(item, x, y, dx, dy, pressTimeout, steps, button, modifiers, delay) {
++        if (item === undefined || item.x === undefined || item.y === undefined)
++            return
++        if (button === undefined)
++            button = Qt.LeftButton
++        if (modifiers === undefined)
++            modifiers = Qt.NoModifier
++        if (steps === undefined || steps <= 0)
++            steps = 4;
++        // make sure we have at least two move steps so the flick will be sensed
++        steps += 1;
++        if (delay === undefined)
++            delay = -1;
++
++        var ddx = dx / steps;
++        var ddy = dy / steps;
++
++        mousePress(item, x, y, button, modifiers, delay);
++        if (pressTimeout !== undefined && pressTimeout > 0) {
++            wait(pressTimeout);
++        }
++        for (var i = 1; i <= steps; i++) {
++            // mouse moves are all processed immediately, without delay in between events
++            mouseMove(item, x + i * ddx, y + i * ddy, -1, button);
++        }
++        mouseRelease(item, x + dx, y + dy, button, modifiers, delay);
++        // empty event buffer
++        wait(200);
++    }
++
++    /*!
++        \qmlmethod UbuntuTestCase::mouseLongPress(item, x, y, button = Qt.LeftButton, modifiers = Qt.NoModifiers, delay = -1)
++
++        Simulates a long press on a mouse \a button with an optional \a modifier
++        on an \a item. The position is defined by \a x and \a y. If \a delay is
++        specified, the test will wait the specified amount of milliseconds before
++        the press.
++
++        The position given by \a x and \a y is transformed from the co-ordinate
++        system of \a item into window co-ordinates and then delivered.
++        If \a item is obscured by another item, or a child of \a item occupies
++        that position, then the event will be delivered to the other item instead.
++
++        \sa mouseRelease(), mouseClick(), mouseDoubleClick(), mouseMove(), mouseDrag(), mouseWheel()
++      */
++    function mouseLongPress(item, x, y, button, modifiers, delay) {
++        mousePress(item, x, y, button, modifiers, delay);
++        // the delay is taken from QQuickMouseArea
++        wait(800);
++    }
++
++    /*!
  		Keeps executing a given parameter-less function until it returns the given
  		expected result or the timemout is reached (in which case a test failure
  		is generated)
 === modified file 'modules/Ubuntu/Test/deployment.pri'
 --- modules/Ubuntu/Test/deployment.pri	2014-01-17 12:30:05 +0000
 +++ modules/Ubuntu/Test/deployment.pri	2014-04-10 09:49:53 +0000
@@ -7,9 +7,14 @@
  # make found deployables visible in Qt Creator
  OTHER_FILES += $$QMLDIR_FILE
++QML_FILES = $$system(ls *.qml)
++JS_FILES = $$system(ls *.js)
++
  # define deployment for found deployables
  qmldir_file.path = $$installPath
  qmldir_file.files = $$QMLDIR_FILE
++qml_files.path = $$installPath
++qml_files.files = $$QML_FILES
  js_files.path = $$installPath
  js_files.files = $$JS_FILES
@@ -20,4 +25,4 @@
  # https://bugreports.qt-project.org/browse/QTBUG-36243
  plugins_qmltypes.extra = $$[QT_INSTALL_BINS]/qmlplugindump -notrelocatable Ubuntu.Test 0.1 ../../ 2>/dev/null > $(INSTALL_ROOT)/$$installPath/plugins.qmltypes
--INSTALLS += qmldir_file plugins_qmltypes
++INSTALLS += qmldir_file plugins_qmltypes qml_files js_files
 === modified file 'tests/resources/alarm/Alarms.qml'
 --- tests/resources/alarm/Alarms.qml	2013-09-18 10:13:04 +0000
 +++ tests/resources/alarm/Alarms.qml	2014-04-10 09:49:53 +0000
@@ -21,7 +21,7 @@
  MainView {
      id: mainView
--    width: units.gu(40)
++    width: units.gu(80)
      height: units.gu(71)
      objectName: "mainView"
@@ -162,7 +162,11 @@
          clip: true
          model: alarmModel
          delegate: Standard {
--            text: message
++            text: message + recurring(model) + "\n" + model.date
++            function recurring(alarmData) {
++                return (alarmData.type === Alarm.Repeating) ? "[Repeating]" : "[Onetime]";
++            }
++
              removable: true
              control: Switch {
                  checked: model.enabled
 === modified file 'tests/unit/runtest.sh'
 --- tests/unit/runtest.sh	2014-03-31 18:26:46 +0000
 +++ tests/unit/runtest.sh	2014-04-10 09:49:53 +0000
@@ -33,7 +33,7 @@
    if [ $_TARGET != $_TESTFILE ]; then
        _CMD="$_CMD -input $_TESTFILE"
    fi
--  _CMD="$_CMD -maxwarnings 4"
++  _CMD="$_CMD -maxwarnings 40"
+ }
  function execute_test_cmd {
 === modified file 'tests/unit/tst_alarms/tst_alarms.cpp'
 --- tests/unit/tst_alarms/tst_alarms.cpp	2014-02-21 18:23:41 +0000
 +++ tests/unit/tst_alarms/tst_alarms.cpp	2014-04-10 09:49:53 +0000
@@ -25,6 +25,7 @@
  #include "adapters/alarmsadapter_p.h"
  #undef protected
++#include "uctestcase.h"
  #include <QtCore/QString>
  #include <QtCore/QTextCodec>
  #include <QtCore/QDebug>
@@ -64,11 +65,18 @@
          syncFetch();
+     }
--    bool containsAlarm(UCAlarm *alarm)
++    bool containsAlarm(UCAlarm *alarm, bool trace = false)
+     {
          UCAlarmPrivate *pAlarm = UCAlarmPrivate::get(alarm);
          QList<AlarmData> alarms = AlarmManager::instance().alarms();
          Q_FOREACH(AlarmData i, alarms) {
++            if (trace && (alarm->message() == i.message)) {
++                qDebug() << "----------------------";
++                qDebug() << "Alarm data:" << alarm->message();
++                qDebug() << alarm->date() << i.date;
++                qDebug() << alarm->type() << i.type;
++                qDebug() << alarm->daysOfWeek() << i.days;
++            }
              if (i == pAlarm->rawData) {
                  return true;
+             }
@@ -127,7 +135,7 @@
      void test_repeating_autoDetect()
+     {
--        UCAlarm alarm(QDateTime::currentDateTime(), UCAlarm::AutoDetect, "test_repeating_autoDetect");
++        UCAlarm alarm(QDateTime::currentDateTime().addSecs(20), UCAlarm::AutoDetect, "test_repeating_autoDetect");
          alarm.save();
          waitForRequest(&alarm);
@@ -137,28 +145,92 @@
      void test_repeating_daily()
+     {
--        UCAlarm alarm(QDateTime::currentDateTime(), UCAlarm::Daily, "test_repeating_daily");
--
--        alarm.save();
--        waitForRequest(&alarm);
--        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
--        QVERIFY(containsAlarm(&alarm));
--    }
--
--    void test_repeating_givenDay()
--    {
--        UCAlarm alarm(QDateTime::currentDateTime(), UCAlarm::Wednesday, "test_repeating_givenDay");
--
--        alarm.save();
--        waitForRequest(&alarm);
--        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
--        QVERIFY(containsAlarm(&alarm));
++        UCAlarm alarm(QDateTime::currentDateTime().addSecs(10), UCAlarm::Daily, "test_repeating_daily");
++
++        alarm.save();
++        waitForRequest(&alarm);
++        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&alarm));
++    }
++
++    void test_repeating_givenDay_exact_data()
++    {
++        QTest::addColumn<QString>("message");
++        QTest::addColumn<int>("day");
++
++        QTest::newRow("Monday") << "Monday" << (int)UCAlarm::Monday;
++        QTest::newRow("Tuesday") << "Tuesday" << (int)UCAlarm::Tuesday;
++        QTest::newRow("Wednesday") << "Wednesday" << (int)UCAlarm::Wednesday;
++        QTest::newRow("Thursday") << "Thursday" << (int)UCAlarm::Thursday;
++        QTest::newRow("Friday") << "Friday" << (int)UCAlarm::Friday;
++        QTest::newRow("Saturday") << "Saturday" << (int)UCAlarm::Saturday;
++        QTest::newRow("Sunday") << "Sunday" << (int)UCAlarm::Sunday;
++    }
++
++    void test_repeating_givenDay_exact()
++    {
++        QFETCH(QString, message);
++        QFETCH(int, day);
++        UCAlarm alarm(QDateTime::currentDateTime(), (UCAlarm::DaysOfWeek)day, "test_repeating_givenDay_exact_" + message);
++
++        alarm.save();
++        waitForRequest(&alarm);
++        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&alarm));
++    }
++
++    void test_repeating_moreDays_data()
++    {
++        QTest::addColumn<QString>("message");
++        QTest::addColumn<int>("days");
++
++        QTest::newRow("First on Monday") << "Monday" << (int)(UCAlarm::Monday | UCAlarm::Sunday);
++        QTest::newRow("First on Tuesday") << "Tuesday" << (int)(UCAlarm::Tuesday | UCAlarm::Monday);
++        QTest::newRow("First on Wednesday") << "Wednesday" << (int)(UCAlarm::Wednesday | UCAlarm::Tuesday);
++        QTest::newRow("First on Thursday") << "Thursday" << (int)(UCAlarm::Thursday | UCAlarm::Wednesday);
++        QTest::newRow("First on Friday") << "Friday" << (int)(UCAlarm::Friday | UCAlarm::Thursday);
++        QTest::newRow("First on Saturday") << "Saturday" << (int)(UCAlarm::Saturday | UCAlarm::Friday);
++        QTest::newRow("First on Sunday") << "Sunday" << (int)(UCAlarm::Sunday | UCAlarm::Saturday);
+     }
      void test_repeating_moreDays()
+     {
--        UCAlarm alarm(QDateTime::currentDateTime(), UCAlarm::Monday | UCAlarm::Wednesday, "test_repeating_moreDays");
--
++        QFETCH(QString, message);
++        QFETCH(int, days);
++
++        QDateTime currentDate(QDateTime::currentDateTime());
++
++        UCAlarm alarm(currentDate, (UCAlarm::DaysOfWeek)days, "test_repeating_moreDays" + message);
++        // the distance is always 6 days between the occurrences
++        UCAlarm firstOccurrence(currentDate, alarm.daysOfWeek(), alarm.message());
++        // make sure we have the same setup as the original one; checkAlarm() adjusts all alarm data
++        UCAlarmPrivate::get(&firstOccurrence)->checkAlarm();
++
++        alarm.save();
++        waitForRequest(&alarm);
++        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&alarm));
++        QVERIFY(containsAlarm(&firstOccurrence));
++    }
++
++    void test_repeating_weekly_data() {
++        QTest::addColumn<QString>("message");
++        QTest::addColumn<int>("dow");
++
++        QTest::newRow("Monday") << "Monday" << (int)UCAlarm::Monday;
++        QTest::newRow("Tuesday") << "Tuesday" << (int)UCAlarm::Tuesday;
++        QTest::newRow("Wednesday") << "Wednesday" << (int)UCAlarm::Wednesday;
++        QTest::newRow("Thursday") << "Thursday" << (int)UCAlarm::Thursday;
++        QTest::newRow("Friday") << "Friday" << (int)UCAlarm::Friday;
++        QTest::newRow("Saturday") << "Saturday" << (int)UCAlarm::Saturday;
++        QTest::newRow("Sunday") << "Sunday" << (int)UCAlarm::Sunday;
++    }
++    void test_repeating_weekly()
++    {
++        QFETCH(QString, message);
++        QFETCH(int, dow);
++
++        UCAlarm alarm(QDateTime::currentDateTime().addSecs(3600), (UCAlarm::DaysOfWeek)dow, "test_repeating_weekly_" + message);
          alarm.save();
          waitForRequest(&alarm);
          QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
@@ -273,6 +345,85 @@
          QVERIFY(!containsAlarm(&copy));
+     }
++    void test_updateAlarm_Repeating()
++    {
++        UCAlarm alarm(QDateTime::currentDateTime().addMSecs(5000), UCAlarm::AutoDetect, "test_updateAlarm_Repeating");
++
++        alarm.save();
++        waitForRequest(&alarm);
++        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&alarm));
++
++        alarm.setDate(alarm.date().addDays(1));
++        alarm.save();
++        waitForRequest(&alarm);
++        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&alarm));
++
++        alarm.setDaysOfWeek(UCAlarm::Daily);
++        alarm.save();
++        waitForRequest(&alarm);
++        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&alarm));
++    }
++
++    void test_fetchAlarmPlus7Days()
++    {
++        QDateTime dt = QDateTime::currentDateTime().addDays(10);
++        UCAlarm alarm(dt, "test_fetchAlarmPlus7Days");
++
++        alarm.save();
++        waitForRequest(&alarm);
++        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&alarm));
++
++        UCAlarm nextMonth(dt.addMonths(1), "test_fetchAlarmPlus1Month");
++        nextMonth.save();
++        waitForRequest(&nextMonth);
++        QCOMPARE(nextMonth.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&nextMonth));
++
++        UCAlarm nextYear(dt.addYears(1), "test_fetchAlarmPlus1Year");
++        nextYear.save();
++        waitForRequest(&nextYear);
++        QCOMPARE(nextYear.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&nextYear));
++    }
++
++    void test_correctAlarmOrderDaily()
++    {
++        QDate cd = QDate::currentDate();
++        QTime ct = QTime::currentTime();
++        QDateTime dt(cd, QTime(ct.hour(), ct.minute(), ct.second() + 2));
++        QDateTime nextDt(cd.addDays(1), QTime(ct.hour(), ct.minute(), ct.second() + 2));
++        UCAlarm alarm(dt, UCAlarm::Daily, "test_correctAlarmOrderDaily");
++        UCAlarm nextAlarm(nextDt, UCAlarm::Daily, "test_correctAlarmOrderDaily");
++
++        alarm.save();
++        waitForRequest(&alarm);
++        QTest::qWait(2000);
++        syncFetch();
++        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&nextAlarm));
++    }
++
++    void test_correctAlarmOrderWeekly()
++    {
++        QDate cd = QDate::currentDate();
++        QTime ct = QTime::currentTime();
++        QDateTime dt(cd, QTime(ct.hour(), ct.minute(), ct.second() + 1));
++        QDateTime nextDt(cd.addDays(7), QTime(ct.hour(), ct.minute(), ct.second() + 1));
++        UCAlarm alarm(dt, UCAlarm::AutoDetect, "test_correctAlarmOrderWeekly");
++        UCAlarm nextAlarm(nextDt, UCAlarm::AutoDetect, "test_correctAlarmOrderWeekly");
++
++        alarm.save();
++        waitForRequest(&alarm);
++        QTest::qWait(2000);
++        syncFetch();
++        QCOMPARE(alarm.error(), (int)UCAlarm::NoError);
++        QVERIFY(containsAlarm(&nextAlarm));
++    }
++
  };
  QTEST_MAIN(tst_UCAlarms)
 === modified file 'tests/unit_x11/tst_test/tst_ubuntutestcase.qml'
 --- tests/unit_x11/tst_test/tst_ubuntutestcase.qml	2014-02-13 10:27:14 +0000
 +++ tests/unit_x11/tst_test/tst_ubuntutestcase.qml	2014-04-10 09:49:53 +0000
@@ -23,30 +23,57 @@
   width: 800
   height: 600
-- MouseArea {
--    id: mouseArea
--    objectName: "myMouseArea"
-- 	anchors.fill: parent
-- 	hoverEnabled: true
--	property int testX : 0
--	property int testY : 0
--	property int steps : 0
++ Column {
++     anchors.fill: parent
++     MouseArea {
++        id: mouseArea
++        objectName: "myMouseArea"
++        width: parent.width
++        height: 300
++        hoverEnabled: true
++        acceptedButtons: Qt.LeftButton | Qt.MiddleButton | Qt.RightButton
++        property int testX : 0
++        property int testY : 0
++        property int steps : 0
-- 	onPositionChanged: {
-- 	   testX = mouseX;
--	   testY = mouseY;
--	   steps++;
-- 	}
++        onPositionChanged: {
++           testX = mouseX;
++           testY = mouseY;
++           steps++;
++        }
++     }
++     Flickable {
++         id: flicker
++         width: parent.width
++         height: 400
++         contentWidth: rect.width
++         contentHeight: rect.height
++         clip: true
++         Rectangle {
++             id: rect
++             color: "blue"
++             width: 1000
++             height: 1000
++         }
++     }
+  }
   UbuntuTestCase {
      name: "TestTheUbuntuTestCase"
      when: windowShown
++    function init() {
++        mouseArea.steps = 0;
++    }
++    function cleanup() {
++        movementSpy.clear();
++        longPressSpy.clear();
++    }
++
      function test_mouseMoveSlowly() {
--       mouseMoveSlowly(root,0,0,800,600,10,100);
++       mouseMoveSlowly(root,0,0,800,300,10,100);
         compare(mouseArea.testX,800);
--       compare(mouseArea.testY,600);
++       compare(mouseArea.testY,300);
         compare(mouseArea.steps,10);
+     }
@@ -58,5 +85,66 @@
          child = findChild(root,"NoSuchChildHere");
          compare(child===null,true,"When there is no child, function should return null");
+     }
++
++    SignalSpy {
++        id: longPressSpy
++        target: mouseArea
++        signalName: "onPressAndHold"
++    }
++
++    function test_longPress_left() {
++        longPressSpy.clear();
++        mouseLongPress(mouseArea, mouseArea.width / 2, mouseArea.height / 2);
++        longPressSpy.wait();
++        // cleanup
++        mouseRelease(mouseArea, mouseArea.width / 2, mouseArea.height / 2);
++    }
++
++    function test_longPress_right() {
++        longPressSpy.clear();
++        mouseLongPress(mouseArea, mouseArea.width / 2, mouseArea.height / 2, Qt.RightButton);
++        longPressSpy.wait();
++        // cleanup
++        mouseRelease(mouseArea, mouseArea.width / 2, mouseArea.height / 2, Qt.RightButton);
++    }
++
++    function test_longPress_middle() {
++        longPressSpy.clear();
++        mouseLongPress(mouseArea, mouseArea.width / 2, mouseArea.height / 2, Qt.MiddleButton);
++        longPressSpy.wait();
++        // cleanup
++        mouseRelease(mouseArea, mouseArea.width / 2, mouseArea.height / 2, Qt.MiddleButton);
++    }
++
++    SignalSpy {
++        id: movementSpy
++        target: flicker
++        signalName: "onMovementEnded"
++    }
++
++    function test_flick_default() {
++        flick(flicker, 0, 0, flicker.width, flicker.height);
++        movementSpy.wait();
++    }
++    function test_flick_long() {
++        flick(flicker, 0, 0, flicker.width, flicker.height, -1, 10);
++        movementSpy.wait();
++    }
++    function test_flick_short() {
++        flick(flicker, 0, 0, flicker.width, flicker.height, -1, 1);
++        movementSpy.wait();
++    }
++    function test_flick_pressTimeout() {
++        flick(flicker, 0, 0, flicker.width, flicker.height, 400);
++        movementSpy.wait();
++    }
++    function test_flick_pressTimeout_short() {
++        flick(flicker, flicker.width, flicker.height, -flicker.width, -flicker.height, 400, 1);
++        movementSpy.wait();
++    }
++    function test_flick_pressTimeout_long() {
++        flick(flicker, flicker.width, flicker.height, -flicker.width, -flicker.height, 400, 100);
++        movementSpy.wait();
++    }
+  }
+ }