Merge lp:~chasedouglas/grail/atomic-timeout-test into lp:grail

[Chase Douglas]

Add atomic tap timeout test. This test checks for two issues:

* Tap gesture events are generated
* The correct events are generated

The first issue will fail if the atomic gesture timeout is not calculated
properly. The second issue is just a general check that the right events
are generated.

[Daniel d'Andrada (dandrader)]

Looks good.

review: Approve

=== modified file 'test/Makefile.am'
--- test/Makefile.am	2012-03-14 19:25:27 +0000
+++ test/Makefile.am	2012-03-16 23:19:22 +0000
@@ -33,7 +33,8 @@
 	x11/no-tap-after-drag.cpp \
 	x11/twodrag.cpp \
 	x11/dragthresh.cpp \
-	x11/timeout.cpp
+	x11/timeout.cpp \
+	x11/atomic-timeout.cpp
 endif
 
 CXXFLAGS += \

=== added file 'test/recordings/ntrig_dell_xt2/2_tap.record'
--- test/recordings/ntrig_dell_xt2/2_tap.record	1970-01-01 00:00:00 +0000
+++ test/recordings/ntrig_dell_xt2/2_tap.record	2012-03-16 23:19:22 +0000
@@ -0,0 +1,20 @@
+E: 1327542640.244087 0003 0000 2745
+E: 1327542640.244089 0003 0001 1639
+E: 1327542640.244090 0003 0035 2745
+E: 1327542640.244091 0003 0036 1639
+E: 1327542640.244092 0003 0034 0
+E: 1327542640.244093 0003 0030 468
+E: 1327542640.244094 0003 0031 306
+E: 1327542640.244095 0000 0002 0
+E: 1327542640.244090 0003 0035 2845
+E: 1327542640.244091 0003 0036 1639
+E: 1327542640.244092 0003 0034 0
+E: 1327542640.244093 0003 0030 468
+E: 1327542640.244094 0003 0031 306
+E: 1327542640.244095 0000 0002 0
+E: 1327542640.244251 0001 014d 1
+E: 1327542640.244251 0001 014a 1
+E: 1327542640.244253 0000 0000 0
+E: 1327542640.244253 0001 014d 0
+E: 1327542640.244253 0001 014a 0
+E: 1327542640.244253 0000 0000 0

=== added file 'test/x11/atomic-timeout.cpp'
--- test/x11/atomic-timeout.cpp	1970-01-01 00:00:00 +0000
+++ test/x11/atomic-timeout.cpp	2012-03-16 23:19:22 +0000
@@ -0,0 +1,285 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+/**
+ * @internal
+ * @file Atomic Timout Test
+ *
+ * This test plays a two-touch tap and checks that the appropriate events are
+ * generated for a two-touch atomic tap subscription.
+ *
+ * Regression test for lp:949855 and lp:957437.
+ */
+
+#include <cmath>
+#include <map>
+#include <memory>
+#include <stdexcept>
+#include <future>
+
+#include <gtest/gtest.h>
+
+#include "device.h"
+#include "events.h"
+#include "recording.h"
+#include "x11/fixture.h"
+#include "utouch/frame_x11.h"
+
+using namespace utouch::grail::x11::testing;
+
+class AtomicTap : public Test {
+ public:
+  AtomicTap() : device_(NULL), step_(0) {}
+
+ protected:
+  static utouch::grail::testing::Events events_;
+
+  virtual void ProcessFrameEvents();
+  virtual void ProcessGrailEvents();
+  void Subscribe();
+  void CheckSlice(UGSlice);
+
+  UFDevice device_;
+  unsigned int step_;
+};
+
+void AtomicTap::ProcessFrameEvents() {
+  UFEvent event;
+
+  UFStatus status;
+  while ((status = frame_get_event(frame_handle(), &event)) == UFStatusSuccess) {
+    grail_process_frame_event(grail_handle(), event);
+
+    if (frame_event_get_type(event) == UFEventTypeDeviceAdded) {
+      UFDevice device;
+      ASSERT_EQ(UFStatusSuccess,
+                frame_event_get_property(event, UFEventPropertyDevice,
+                                         &device));
+
+      const char* name;
+      ASSERT_EQ(UFStatusSuccess,
+                frame_device_get_property(device, UFDevicePropertyName, &name));
+      if (strcmp(name, "N-Trig MultiTouch (Virtual Test Device)") == 0) {
+        EXPECT_EQ(NULL, device_);
+        device_ = device;
+        Subscribe();
+      }
+    }
+
+    frame_event_unref(event);
+  }
+
+  EXPECT_EQ(UFStatusErrorNoEvent, status);
+}
+
+void AtomicTap::ProcessGrailEvents() {
+  UGEvent event;
+
+  UGStatus status;
+  while ((status = grail_get_event(grail_handle(), &event)) == UGStatusSuccess) {
+    ASSERT_EQ(UGEventTypeSlice, grail_event_get_type(event));
+
+    UGSlice slice;
+    status = grail_event_get_property(event, UGEventPropertySlice, &slice);
+    ASSERT_EQ(UGStatusSuccess, status);
+
+    CheckSlice(slice);
+
+    grail_event_unref(event);
+  }
+
+  EXPECT_EQ(UGStatusErrorNoEvent, status);
+}
+
+void AtomicTap::Subscribe() {
+  UGSubscription subscription;
+  UGStatus status = grail_subscription_new(&subscription);
+  ASSERT_EQ(UGStatusSuccess, status);
+
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyDevice,
+                                           &device_);
+  ASSERT_EQ(UGStatusSuccess, status);
+
+  const UFWindowId window_id =
+      frame_x11_create_window_id(DefaultRootWindow(Display()));
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyWindow,
+                                           &window_id);
+  ASSERT_EQ(UGStatusSuccess, status);
+
+  const UGGestureTypeMask mask = UGGestureTypeTap;
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyMask,
+                                           &mask);
+  ASSERT_EQ(UGStatusSuccess, status);
+
+  const int atomic = true;
+  status = grail_subscription_set_property(subscription,
+                                           UGSubscriptionPropertyAtomicGestures,
+                                           &atomic);
+
+  status = grail_subscription_activate(grail_handle(), subscription);
+  ASSERT_EQ(UGStatusSuccess, status);
+}
+
+void AtomicTap::CheckSlice(UGSlice slice) {
+  ASSERT_LT(step_, events_.size()) << "Received too many frame events";
+
+  /* Ensure we got a device addition event first */
+  if (step_ == 0)
+    EXPECT_NE(nullptr, device_);
+
+  if (!events_[step_].skip) {
+    EXPECT_EQ(events_[step_].id, grail_slice_get_id(slice)) << "step " << step_;
+    EXPECT_EQ(events_[step_].state, grail_slice_get_state(slice)) << "step "
+                                                                  << step_;
+    EXPECT_EQ(events_[step_].recognized, grail_slice_get_recognized(slice))
+        << "step " << step_;
+    EXPECT_EQ(events_[step_].num_touches, grail_slice_get_num_touches(slice))
+        << "step " << step_;
+  }
+
+  if (grail_slice_get_state(slice) == UGGestureStateEnd) {
+    UGSubscription subscription = grail_slice_get_subscription(slice);
+    grail_subscription_deactivate(grail_handle(), subscription);
+    grail_subscription_delete(subscription);
+  }
+
+  ++step_;
+}
+
+TEST_F(AtomicTap, Recording) {
+  utouch::evemu::Device device("recordings/ntrig_dell_xt2/device.prop");
+
+  /* Pump once to ensure the X server has initialized the device */
+  PumpEvents();
+  ASSERT_NE(nullptr, device_) << "X server failed to initialize touchscreen";
+
+  utouch::evemu::Recording recording(device,
+                                     "recordings/ntrig_dell_xt2/2_tap.record");
+
+  /* We use the c++11 future module so any exceptions thrown by the thread can
+   * be caught later on. If we used the thread module, exceptions would take the
+   * whole thing down. */
+  std::future<void> future = std::async(std::launch::async,
+                                        &utouch::evemu::Recording::Play,
+                                        &recording);
+
+  PumpEvents();
+
+  future.wait();
+
+  EXPECT_EQ(events_.size(), step_) << "Failed to receive all frame events for "
+                                      "touchscreen";
+}
+
+/* Construct the expected events */
+namespace {
+
+using namespace utouch::grail::testing;
+
+const Events ConstructEvents() {
+  Events events;
+
+  {
+    Slice slice = {
+      false, /* skip */
+      0, /* UGSlicePropertyID */
+      UGGestureStateBegin, /* UGSlicePropertyState */
+      0, /* UGSlicePropertyRecognized */
+      2, /* UGSlicePropertyNumTouches */
+      0, /* UGSlicePropertyOriginalCenterX */
+      0, /* UGSlicePropertyOriginalCenterY */
+      0, /* UGSlicePropertyOriginalRadius */
+      {}, /* UGSlicePropertyTransform */
+      {}, /* UGSlicePropertyCumulativeTransform */
+      0, /* UGSlicePropertyCenterOfRotationX */
+      0, /* UGSlicePropertyCenterOfRotationY */
+      false, /* UGSlicePropertyConstructionFinished */
+    };
+    events.push_back(slice);
+  }
+
+  {
+    Slice slice = {
+      false, /* skip */
+      0, /* UGSlicePropertyID */
+      UGGestureStateUpdate, /* UGSlicePropertyState */
+      0, /* UGSlicePropertyRecognized */
+      2, /* UGSlicePropertyNumTouches */
+      0, /* UGSlicePropertyOriginalCenterX */
+      0, /* UGSlicePropertyOriginalCenterY */
+      0, /* UGSlicePropertyOriginalRadius */
+      {}, /* UGSlicePropertyTransform */
+      {}, /* UGSlicePropertyCumulativeTransform */
+      0, /* UGSlicePropertyCenterOfRotationX */
+      0, /* UGSlicePropertyCenterOfRotationY */
+      false, /* UGSlicePropertyConstructionFinished */
+    };
+    events.push_back(slice);
+  }
+
+  {
+    Slice slice = {
+      false, /* skip */
+      0, /* UGSlicePropertyID */
+      UGGestureStateUpdate, /* UGSlicePropertyState */
+      UGGestureTypeTap, /* UGSlicePropertyRecognized */
+      2, /* UGSlicePropertyNumTouches */
+      0, /* UGSlicePropertyOriginalCenterX */
+      0, /* UGSlicePropertyOriginalCenterY */
+      0, /* UGSlicePropertyOriginalRadius */
+      {}, /* UGSlicePropertyTransform */
+      {}, /* UGSlicePropertyCumulativeTransform */
+      0, /* UGSlicePropertyCenterOfRotationX */
+      0, /* UGSlicePropertyCenterOfRotationY */
+      false, /* UGSlicePropertyConstructionFinished */
+    };
+    events.push_back(slice);
+  }
+
+  {
+    Slice slice = {
+      false, /* skip */
+      0, /* UGSlicePropertyID */
+      UGGestureStateEnd, /* UGSlicePropertyState */
+      UGGestureTypeTap, /* UGSlicePropertyRecognized */
+      2, /* UGSlicePropertyNumTouches */
+      0, /* UGSlicePropertyOriginalCenterX */
+      0, /* UGSlicePropertyOriginalCenterY */
+      0, /* UGSlicePropertyOriginalRadius */
+      {}, /* UGSlicePropertyTransform */
+      {}, /* UGSlicePropertyCumulativeTransform */
+      0, /* UGSlicePropertyCenterOfRotationX */
+      0, /* UGSlicePropertyCenterOfRotationY */
+      true, /* UGSlicePropertyConstructionFinished */
+    };
+    events.push_back(slice);
+  }
+
+  return events;
+}
+
+} // namespace
+
+/* Now initialize the static test fixture member */
+utouch::grail::testing::Events AtomicTap::events_(ConstructEvents());