Merge lp:~bregma/geis/lp-944822 into lp:geis

[Stephen M. Webb]

Adds handling of device additon and removal after subscriptions have been activated (lp: #944822).

[Chase Douglas (chasedouglas)]

* In the integration test, you have "EXPECT_EQ(gesture_events_received, device_has_been_created);". If the device hasn't been created and no events are received we have failed, but this will pass. We need to be using EXPECT_TRUE on each individually.

* GTest test names shouldn't include underscores, according to: http://code.google.com/p/googletest/wiki/FAQ#Why_should_not_test_case_names_and_test_names_contain_underscore

Everything else looks good to me.

review: Needs Fixing

[lp:~bregma/geis/lp-944822]

230. By Stephen M. Webb on 2012-03-29

Fixed test case names and conditions.

231. By Stephen M. Webb on 2012-03-29

Fixed problems with integration tests failing after GeisDeviceTests.removeDeviceSubscription was run.

[Stephen M. Webb (bregma)]

Test condition fixed, names changed, and test failures remedied.

[Chase Douglas (chasedouglas)]

Looks good.

review: Approve

=== modified file 'libutouch-geis/backend/grail/geis_grail_backend.c'
--- libutouch-geis/backend/grail/geis_grail_backend.c	2012-03-28 21:31:54 +0000
+++ libutouch-geis/backend/grail/geis_grail_backend.c	2012-03-29 18:37:22 +0000
@@ -32,6 +32,7 @@
 #include "geis_group.h"
 #include "geis_logging.h"
 #include "geis_private.h"
+#include "geis_subscription.h"
 #include "geis_test_api.h"
 #include "geis_touch.h"
 #include "geis_ugsubscription_store.h"
@@ -89,6 +90,7 @@
   GeisBag                   devices;      /**< The list of known devices. */
   GeisGrailWindowGrabStore  window_grabs; /**< A collection of window inputs */
   GeisBag                   slice_states; /**< Gesture slice states */
+  GeisSubBag                subscription_bag;
 
   GeisGestureClass          drag_class;
   GeisGestureClass          pinch_class;
@@ -101,6 +103,12 @@
 };
 
 
+static GeisStatus
+_grail_be_activate_for_device(GeisGrailBackend gbe,
+                              GeisFilter       filter,
+                              GeisDevice       device,
+                              GeisSubscription subscription);
+
 /**
  * Hashes an ID from a UFDevice.
  *
@@ -640,6 +648,61 @@
 
 
 /**
+ * Activates active subscriptions for a newly-seen device.
+ */
+static void
+_grail_be_subscribe_new_device(GeisGrailBackend gbe, GeisDevice device)
+{
+  for (GeisSubBagIterator it = geis_subscription_bag_begin(gbe->subscription_bag);
+       it != geis_subscription_bag_end(gbe->subscription_bag);
+       it = geis_subscription_bag_iterator_next(gbe->subscription_bag, it))
+  {
+    for (GeisFilterIterator fit = geis_subscription_filter_begin(*it);
+         fit != geis_subscription_filter_end(*it);
+         fit = geis_subscription_filter_next(*it, fit))
+    {
+      GeisBoolean device_applies = GEIS_TRUE;
+      for (GeisSize tindex = 0; tindex < geis_filter_term_count(*fit); ++tindex)
+      {
+        if (!geis_filter_term_match_device(geis_filter_term(*fit, tindex),
+                                           device))
+        {
+          device_applies = GEIS_FALSE;
+          break;
+        }
+      }
+
+      if (device_applies)
+      {
+        _grail_be_activate_for_device(gbe, *fit, device, *it);
+      }
+    }
+  }
+}
+
+
+/**
+ * Removes active subscriptions for recently-removed devices.
+ */
+static void
+_grail_be_unsubscribe_removed_device(GeisGrailBackend gbe, UFDevice device)
+{
+  for (GeisSubBagIterator it = geis_subscription_bag_begin(gbe->subscription_bag);
+       it != geis_subscription_bag_end(gbe->subscription_bag);
+       it = geis_subscription_bag_iterator_next(gbe->subscription_bag, it))
+  {
+   GeisUGSubscriptionStore ugstore = geis_subscription_pdata(*it);
+   for (GeisFilterIterator fit = geis_subscription_filter_begin(*it);
+         fit != geis_subscription_filter_end(*it);
+         fit = geis_subscription_filter_next(*it, fit))
+    {
+      geis_ugsubscription_release_for_device(ugstore, *fit, device, gbe->window_grabs);
+    }
+  }
+}
+
+
+/**
  * Reports an X11 device to the front end as a GEIS device.
  */
 static void
@@ -738,7 +801,7 @@
                              / sizeof(struct GeisFilterableAttribute);
 
   geis_register_device(gbe->geis, geis_device, attr_count, attrs);
-  goto final_exit;
+  _grail_be_subscribe_new_device(gbe, geis_device);
 
 final_exit:
   return;
@@ -758,6 +821,8 @@
     return;
   }
 
+  _grail_be_unsubscribe_removed_device(gbe, frame_device);
+
   for (GeisSize i = 0; i < geis_bag_count(gbe->devices); ++i)
   {
     UFDevice *device = geis_bag_at(gbe->devices, i);
@@ -1204,6 +1269,12 @@
       goto unwind_grabs;
     }
 
+    gbe->subscription_bag = geis_subscription_bag_new(1);
+    if (!gbe->subscription_bag)
+    {
+      goto unwind_slice_states;
+    }
+
     geis_get_configuration(gbe->geis,
                            GEIS_CONFIG_SEND_TENTATIVE_EVENTS,
                            &gbe->send_tentative_events);
@@ -1217,6 +1288,8 @@
     _geis_grail_report_init_complete(gbe);
     goto final_exit;
 
+unwind_slice_states:
+    geis_bag_delete(gbe->slice_states);
 unwind_grabs:
     geis_grail_window_grab_store_delete(gbe->window_grabs);
 unwind_devices:
@@ -1238,10 +1311,12 @@
 
 
 static int
-_grail_be_x_error_handler(Display*     display GEIS_UNUSED,
-                          XErrorEvent* event GEIS_UNUSED)
+_grail_be_x_error_handler(Display*     display,
+                          XErrorEvent* event)
 {
-  geis_error("error in X detected");
+  char buffer[512];
+  XGetErrorText(display, (int)event->error_code, buffer, 511);
+  geis_error("error %u in X detected: %s", (unsigned)event->error_code, buffer);
   return 0;
 }
 
@@ -1255,6 +1330,7 @@
 _geis_grail_backend_finalize(GeisBackend be)
 {
   GeisGrailBackend gbe = (GeisGrailBackend)be;
+  geis_subscription_bag_delete(gbe->subscription_bag);
   geis_bag_delete(gbe->slice_states);
   geis_grail_window_grab_store_delete(gbe->window_grabs);
   geis_bag_delete(gbe->devices);
@@ -1630,51 +1706,44 @@
 }
 
 
-/**
- * Activates a subscription for a list of devices.
- */
 static GeisStatus
-_geis_grail_activate_for_devices(GeisGrailBackend gbe,
-                                 GeisFilter       filter,
-                                 GeisDeviceBag    device_bag,
-                                 GeisSubscription subscription)
+_grail_be_activate_for_device(GeisGrailBackend gbe,
+                              GeisFilter       filter,
+                              GeisDevice       device,
+                              GeisSubscription subscription)
 {
   GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
-  for (GeisSize d = 0; d < geis_device_bag_count(device_bag); ++d)
+  GeisBoolean has_region_term = GEIS_FALSE;
+  if (filter)
   {
-    GeisDevice device = geis_device_bag_device(device_bag, d);
-    GeisBoolean has_region_term = GEIS_FALSE;
-    if (filter)
+    for (GeisSize i = 0; i < geis_filter_term_count(filter); ++i)
     {
-      for (GeisSize i = 0; i < geis_filter_term_count(filter); ++i)
+      GeisFilterTerm term = geis_filter_term(filter, i);
+      if (GEIS_FILTER_REGION == geis_filter_term_facility(term))
       {
-        GeisFilterTerm term = geis_filter_term(filter, i);
-        if (GEIS_FILTER_REGION == geis_filter_term_facility(term))
-        {
-          GeisInteger         window_id = 0;
-          GeisAttr            attr      = geis_filter_term_attr(term);
-          GeisString          name      = geis_attr_name(attr);
-          GeisFilterOperation operation = geis_filter_term_operation(term);
+        GeisInteger         window_id = 0;
+        GeisAttr            attr      = geis_filter_term_attr(term);
+        GeisString          name      = geis_attr_name(attr);
+        GeisFilterOperation operation = geis_filter_term_operation(term);
 
-          if (0 == strcmp(name, GEIS_REGION_ATTRIBUTE_WINDOWID)
-              && operation == GEIS_FILTER_OP_EQ)
-          {
-            window_id = geis_attr_value_to_integer(attr);
-            has_region_term = GEIS_TRUE;
-            status = _geis_grail_activate_for_device_region(gbe,
-                filter,
-                device,
-                window_id,
-                subscription);
-            if (status != GEIS_STATUS_SUCCESS)
-            {
-              goto final_exit;
-            }
-          }
-          else
-          {
-            geis_warning("unhandled region filter term");
-          }
+        if (0 == strcmp(name, GEIS_REGION_ATTRIBUTE_WINDOWID)
+            && operation == GEIS_FILTER_OP_EQ)
+        {
+          window_id = geis_attr_value_to_integer(attr);
+          has_region_term = GEIS_TRUE;
+          status = _geis_grail_activate_for_device_region(gbe,
+              filter,
+              device,
+              window_id,
+              subscription);
+          if (status != GEIS_STATUS_SUCCESS)
+          {
+            goto final_exit;
+          }
+        }
+        else
+        {
+          geis_warning("unhandled region filter term");
         }
       }
     }
@@ -1695,6 +1764,28 @@
   return status;
 }
 
+
+/**
+ * Activates a subscription for a list of devices.
+ */
+static GeisStatus
+_geis_grail_activate_for_devices(GeisGrailBackend gbe,
+                                 GeisFilter       filter,
+                                 GeisDeviceBag    device_bag,
+                                 GeisSubscription subscription)
+{
+  GeisStatus status = GEIS_STATUS_SUCCESS;
+  for (GeisSize d = 0; d < geis_device_bag_count(device_bag); ++d)
+  {
+    GeisDevice device = geis_device_bag_device(device_bag, d);
+    status = _grail_be_activate_for_device(gbe, filter, device, subscription);
+    if (status != GEIS_STATUS_SUCCESS)
+      break;
+  }
+
+  return status;
+}
+
 static GeisStatus
 _geis_grail_activate_with_filters(GeisGrailBackend gbe,
                                   GeisSubscription subscription)
@@ -1760,6 +1851,13 @@
 {
   GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
 
+  if (geis_subscription_bag_find(gbe->subscription_bag,
+                                 geis_subscription_id(subscription)))
+  {
+    geis_warning("subscription is already activated");
+    goto final_exit;
+  }
+
   GeisUGSubscriptionStore ugstore = geis_subscription_pdata(subscription);
   if (ugstore == NULL)
   {
@@ -1784,6 +1882,8 @@
         subscription);
   }
 
+  geis_subscription_bag_insert(gbe->subscription_bag, subscription);
+
 final_exit:
   return status;
 }
@@ -1800,6 +1900,13 @@
 {
   GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
 
+  if (!geis_subscription_bag_find(gbe->subscription_bag,
+                                 geis_subscription_id(subscription)))
+  {
+    geis_warning("deactivating a subscription that is not active");
+    goto final_exit;
+  }
+
   GeisUGSubscriptionStore ugstore = geis_subscription_pdata(subscription);
   if (ugstore)
   {
@@ -1824,9 +1931,11 @@
       }
 
       grail_subscription_deactivate(gbe->grail, ugsub);
+      geis_subscription_bag_remove(gbe->subscription_bag, subscription);
     }
   }
 
+final_exit:
   return status;
 }
 

=== modified file 'libutouch-geis/backend/grail/geis_ugsubscription_store.c'
--- libutouch-geis/backend/grail/geis_ugsubscription_store.c	2012-02-13 17:23:34 +0000
+++ libutouch-geis/backend/grail/geis_ugsubscription_store.c	2012-03-29 18:37:22 +0000
@@ -83,7 +83,7 @@
                                           GeisSize                index)
 {
   assert(index < geis_bag_count(store));
-  return *(UGSubscription*)geis_bag_at(store, index);
+  return ((GeisUGSubscription)geis_bag_at(store, index))->ugsub;
 }
 
 
@@ -147,6 +147,44 @@
 }
 
 
+void
+geis_ugsubscription_release_for_device(GeisUGSubscriptionStore  store,
+                                       GeisFilter               filter,
+                                       UFDevice                 device,
+                                       GeisGrailWindowGrabStore window_grabs)
+{
+  GeisSize i = 0;
+  while (i < geis_bag_count(store))
+  {
+    GeisUGSubscription s = (GeisUGSubscription)geis_bag_at(store, i);
+    if (s->filter == filter && s->device == device)
+    {
+      UFWindowId ufwindow;
+      UGStatus ugstatus;
+      ugstatus = grail_subscription_get_property(s->ugsub,
+                                                 UGSubscriptionPropertyWindow,
+                                                 &ufwindow);
+      if (ugstatus != UGStatusSuccess)
+      {
+        geis_warning("error %d getting subscription window", ugstatus);
+      }
+      else
+      {
+        Window window_id = frame_x11_get_window_id(ufwindow);
+        geis_grail_window_grab_store_ungrab(window_grabs, window_id);
+      }
+
+      grail_subscription_delete(s->ugsub);
+      geis_bag_remove(store, i);
+    }
+    else
+    {
+      ++i;
+    }
+  }
+}
+
+
 /*
  * Releses a UGSubscription from the store.
  */

=== modified file 'libutouch-geis/backend/grail/geis_ugsubscription_store.h'
--- libutouch-geis/backend/grail/geis_ugsubscription_store.h	2012-02-10 04:26:23 +0000
+++ libutouch-geis/backend/grail/geis_ugsubscription_store.h	2012-03-29 18:37:22 +0000
@@ -22,6 +22,7 @@
 
 #include "geis/geis.h"
 #include "geis_bag.h"
+#include "geis_grail_window_grab.h"
 #include <utouch/grail.h>
 
 
@@ -95,6 +96,19 @@
                                        GeisInteger             region_id);
 
 /**
+ * Releases all UGSubscriptions for a (filter, device).
+ * @param[in] store        The grail subscription store.
+ * @param[in] filter       Identifies a filter.
+ * @param[in] device       Identifies a device.
+ * @param[in] window_grabs A window grab collection.
+ */
+void
+geis_ugsubscription_release_for_device(GeisUGSubscriptionStore  store,
+                                       GeisFilter               filter,
+                                       UFDevice                 device,
+                                       GeisGrailWindowGrabStore window_grabs);
+
+/**
  * Releses a UGSubscription from the store.
  * @param[in] store  The grail subscription store.
  * @param[in] ugsub  The UGSubscription to release.

=== modified file 'libutouch-geis/geis_filter_term.c'
--- libutouch-geis/geis_filter_term.c	2011-10-18 18:41:30 +0000
+++ libutouch-geis/geis_filter_term.c	2012-03-29 18:37:22 +0000
@@ -369,3 +369,126 @@
 }
 
 
+/**
+ * Indicates if an attr string value matches a given string and condition.
+ *
+ * @param[in] attr   The attr with a string value.
+ * @param[in] op     A match condition.
+ * @param[in] svalue A target string value to match.
+ *
+ * @returns GEIS_TRUE if the attr string value matches the target string and
+ * condition, GEIS_FALSE otherwise.
+ */
+static GeisBoolean
+_filter_matches_attr_string(GeisAttr            attr,
+                            GeisFilterOperation op,
+                            GeisString          svalue)
+{
+  GeisBoolean strings_match = GEIS_FALSE;
+  GeisString attr_value = geis_attr_value_to_string(attr);
+  if (attr_value)
+  {
+    strings_match = (0 == strcmp(attr_value, svalue));
+  }
+  return (op == GEIS_FILTER_OP_EQ && strings_match)
+      || (op == GEIS_FILTER_OP_NE && !strings_match);
+}
+
+
+/**
+ * Indicates if an attr boolean value matches a given value and condition.
+ *
+ * @param[in] attr   The attr with a string value.
+ * @param[in] op     A match condition.
+ * @param[in] bvalue A target boolean value to match.
+ *
+ * @returns GEIS_TRUE if the attr boolean value matches the target value and
+ * condition, GEIS_FALSE otherwise.
+ */
+static GeisBoolean
+_filter_matches_attr_boolean(GeisAttr            attr,
+                             GeisFilterOperation op,
+                             GeisBoolean         bvalue)
+{
+  GeisBoolean attr_value = geis_attr_value_to_boolean(attr);
+  return (op == GEIS_FILTER_OP_EQ && attr_value == bvalue)
+      || (op == GEIS_FILTER_OP_NE && attr_value != bvalue);
+}
+
+
+/**
+ * Indicates if an attr integer value matches a given value and condition.
+ *
+ * @param[in] attr   The attr with a string value.
+ * @param[in] op     A match condition.
+ * @param[in] ivalue A target integer value to match.
+ *
+ * @returns GEIS_TRUE if the attr integer value matches the target value and
+ * condition, GEIS_FALSE otherwise.
+ */
+static GeisBoolean
+_filter_matches_attr_integer(GeisAttr            attr,
+                             GeisFilterOperation op,
+                             GeisInteger         ivalue)
+{
+  GeisInteger attr_value = geis_attr_value_to_integer(attr);
+  return (op == GEIS_FILTER_OP_EQ && attr_value == ivalue)
+      || (op == GEIS_FILTER_OP_NE && attr_value != ivalue)
+      || (op == GEIS_FILTER_OP_GT && attr_value > ivalue)
+      || (op == GEIS_FILTER_OP_GE && attr_value >= ivalue)
+      || (op == GEIS_FILTER_OP_LE && attr_value <= ivalue)
+      || (op == GEIS_FILTER_OP_LT && attr_value < ivalue);
+}
+
+
+/*
+ * Indicates a filter passes a device.
+ */
+GeisBoolean
+geis_filter_term_match_device(GeisFilterTerm term, GeisDevice device)
+{
+  if (geis_filter_term_facility(term) != GEIS_FILTER_DEVICE)
+  {
+    return GEIS_TRUE;
+  }
+
+  GeisAttr            filter_attr = geis_filter_term_attr(term);
+  GeisString          attr_name   = geis_attr_name(filter_attr);
+  GeisFilterOperation op          = geis_filter_term_operation(term);
+
+  if (0 == strcmp(attr_name, GEIS_DEVICE_ATTRIBUTE_NAME))
+  {
+    GeisString device_name = geis_device_name(device);
+    if (device_name)
+    {
+      return _filter_matches_attr_string(filter_attr, op, device_name);
+    }
+  }
+  else if (0 == strcmp(attr_name, GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH)
+        || 0 == strcmp(attr_name, GEIS_DEVICE_ATTRIBUTE_INDEPENDENT_TOUCH))
+  {
+    GeisAttr device_attr = geis_device_attr_by_name(device, attr_name);
+    if (device_attr)
+    {
+      GeisBoolean device_value = geis_attr_value_to_boolean(device_attr);
+      return _filter_matches_attr_boolean(filter_attr, op, device_value);
+    }
+  }
+  else if (0 == strcmp(attr_name, GEIS_DEVICE_ATTRIBUTE_ID)
+        || 0 == strcmp(attr_name, GEIS_DEVICE_ATTRIBUTE_TOUCHES))
+  {
+    GeisAttr device_attr = geis_device_attr_by_name(device, attr_name);
+    if (device_attr)
+    {
+      GeisInteger device_value = geis_attr_value_to_integer(device_attr);
+      /* legacy special case for device ID == 0:  means ALL devices in v1 */
+      if (device_value == 0)
+      {
+        return GEIS_TRUE;
+      }
+      return _filter_matches_attr_integer(filter_attr, op, device_value);
+    }
+  }
+  return GEIS_FALSE;
+}
+

=== modified file 'libutouch-geis/geis_filter_term.h'
--- libutouch-geis/geis_filter_term.h	2011-10-13 17:49:59 +0000
+++ libutouch-geis/geis_filter_term.h	2012-03-29 18:37:22 +0000
@@ -93,6 +93,17 @@
  */
 GeisBoolean geis_filter_term_match_event(GeisFilterTerm term, GeisEvent event);
 
+/**
+ * Indicates a filter passes a device.
+ *
+ * @param[in] term   The filter term.
+ * @param[in] device A GEIS device.
+ *
+ * @returns GEIS_TRUE if the device is passed by the filter, GEIS_FALSE
+ * otherwise.
+ */
+GeisBoolean geis_filter_term_match_device(GeisFilterTerm term, GeisDevice device);
+
 /** @} */
 
 /**

=== modified file 'testsuite/geis2/gtest_devices.cpp'
--- testsuite/geis2/gtest_devices.cpp	2012-03-22 18:44:56 +0000
+++ testsuite/geis2/gtest_devices.cpp	2012-03-29 18:37:22 +0000
@@ -4,13 +4,20 @@
  * Copyright 2012 Canonical Ltd.
  */
 #include "geis/geis.h"
+#include "gtest_evemu_device.h"
+#include "gtest_geis_fixture.h"
 #include "libutouch-geis/geis_test_api.h"
-#include "gtest_geis_fixture.h"
+#include <memory>
+#include <sys/select.h>
+#include <sys/time.h>
 
 
 namespace
 {
 
+static const std::string TEST_DEVICE_PROP_FILE("touchscreen_a.prop");
+static const std::string TEST_DEVICE_EVENTS_FILE("touchscreen_a_rotate90.events");
+
 /**
  * Fixture for testing device handling.
  * This is a separate class because gtest uses Java reflection.
@@ -29,7 +36,7 @@
 };
 
 
-TEST_F(GeisDeviceTests, filter_with_no_devices)
+TEST_F(GeisDeviceTests, filterWithNoDevices)
 {
   GeisSubscription sub = geis_subscription_new(geis_,
                                                "no devices",
@@ -48,4 +55,177 @@
   geis_subscription_delete(sub);
 }
 
+
+/*
+ * Test case 1 for lp:944822 -- device added after subscription activated.
+ *
+ * Creates a subscriptions with a device filter (there are no devices present in
+ * the system).  When initializatiom signalled as complete, device events are
+ * reenabled in the geis instance and a new device is added.  When the
+ * device-added event is received, a recording is run through the device.
+ * Gesture events should be detected.
+ */
+TEST_F(GeisDeviceTests, addDeviceSubscription)
+{
+  std::unique_ptr<Testsuite::EvemuDevice> new_device;
+  GeisBoolean device_has_been_created = GEIS_FALSE;
+  GeisBoolean gesture_events_received = GEIS_FALSE;
+
+  GeisSubscription sub = geis_subscription_new(geis_,
+                                               "no devices",
+                                               GEIS_SUBSCRIPTION_NONE);
+  EXPECT_TRUE(sub != NULL) << "can not create subscription";
+  GeisFilter filter = geis_filter_new(geis_, "rotate");
+  EXPECT_TRUE(filter != NULL) << "can not create filter";
+  GeisStatus fs = geis_filter_add_term(filter,
+            GEIS_FILTER_DEVICE,
+            GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH, GEIS_FILTER_OP_EQ, GEIS_TRUE,
+            NULL);
+  EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not add device term";
+  fs = geis_subscription_add_filter(sub, filter);
+  EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not add device term";
+
+  GeisStatus dispatch_status= geis_dispatch_events(geis_);
+  while (dispatch_status == GEIS_STATUS_CONTINUE
+      || dispatch_status == GEIS_STATUS_SUCCESS)
+  {
+   GeisEvent  event;
+    GeisStatus event_status = geis_next_event(geis_, &event);
+    while (event_status == GEIS_STATUS_CONTINUE
+        || event_status == GEIS_STATUS_SUCCESS)
+    {
+      switch (geis_event_type(event))
+      {
+        case GEIS_EVENT_INIT_COMPLETE:
+        {
+          EXPECT_EQ(GEIS_STATUS_SUCCESS, geis_subscription_activate(sub))
+                      << "can not activate subscription";
+
+          GeisBoolean off = GEIS_FALSE;
+          geis_set_configuration(geis_,
+                                 GEIS_CONFIG_DISCARD_DEVICE_MESSAGES,
+                                 &off);
+          new_device.reset(new Testsuite::EvemuDevice(TEST_DEVICE_PROP_FILE));
+          device_has_been_created = GEIS_TRUE;
+          break;
+        }
+
+       case GEIS_EVENT_DEVICE_AVAILABLE:
+         new_device->play(TEST_DEVICE_EVENTS_FILE);
+         break;
+
+       case GEIS_EVENT_GESTURE_BEGIN:
+       case GEIS_EVENT_GESTURE_UPDATE:
+       {
+         EXPECT_EQ(device_has_been_created, GEIS_TRUE)
+           << "gesture events without device";
+         gesture_events_received = device_has_been_created;
+       }
+
+       default:
+          break;
+      }
+
+      geis_event_delete(event);
+      event_status = geis_next_event(geis_, &event);
+    }
+
+    fd_set read_fds;
+    FD_ZERO(&read_fds);
+    FD_SET(geis_fd(), &read_fds);
+    timeval tmo = { 5, 0 };
+    int sstat = select(geis_fd() + 1, &read_fds, NULL, NULL, &tmo);
+    EXPECT_GT(sstat, -1) << "error in select";
+    if (sstat == 0)
+      break;
+    dispatch_status = geis_dispatch_events(geis_);
+  }
+
+  EXPECT_TRUE(gesture_events_received) << "no gesture events received";
+  EXPECT_TRUE(device_has_been_created) << "no device created";
+  geis_filter_delete(filter);
+  geis_subscription_delete(sub);
+}
+
+
+/*
+ * Test case 2 for lp:944822 -- device removed after subscription activated.
+ *
+ * This test really just makes sure nothing segfaults on device removal.
+ */
+TEST_F(GeisDeviceTests, removeDeviceSubscription)
+{
+  std::unique_ptr<Testsuite::EvemuDevice> new_device;
+
+  GeisSubscription sub = geis_subscription_new(geis_,
+                                               "remove devices",
+                                               GEIS_SUBSCRIPTION_NONE);
+  EXPECT_TRUE(sub != NULL) << "can not create subscription";
+  GeisFilter filter = geis_filter_new(geis_, "rotate");
+  EXPECT_TRUE(filter != NULL) << "can not create filter";
+  GeisStatus fs = geis_filter_add_term(filter,
+            GEIS_FILTER_DEVICE,
+            GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH, GEIS_FILTER_OP_EQ, GEIS_TRUE,
+            NULL);
+  EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not add device term";
+  fs = geis_subscription_add_filter(sub, filter);
+  EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not add device term";
+
+  GeisStatus dispatch_status= geis_dispatch_events(geis_);
+  while (dispatch_status == GEIS_STATUS_CONTINUE
+      || dispatch_status == GEIS_STATUS_SUCCESS)
+  {
+   GeisEvent  event;
+    GeisStatus event_status = geis_next_event(geis_, &event);
+    while (event_status == GEIS_STATUS_CONTINUE
+        || event_status == GEIS_STATUS_SUCCESS)
+    {
+      switch (geis_event_type(event))
+      {
+        case GEIS_EVENT_INIT_COMPLETE:
+        {
+          GeisBoolean off = GEIS_FALSE;
+          geis_set_configuration(geis_,
+                                 GEIS_CONFIG_DISCARD_DEVICE_MESSAGES,
+                                 &off);
+          new_device.reset(new Testsuite::EvemuDevice(TEST_DEVICE_PROP_FILE));
+          break;
+        }
+
+       case GEIS_EVENT_DEVICE_AVAILABLE:
+       {
+         EXPECT_EQ(GEIS_STATUS_SUCCESS, geis_subscription_activate(sub))
+                      << "can not activate subscription";
+         new_device.reset();
+         break;
+       }
+
+       case GEIS_EVENT_GESTURE_BEGIN:
+       case GEIS_EVENT_GESTURE_UPDATE:
+       {
+       }
+
+       default:
+          break;
+      }
+
+      geis_event_delete(event);
+      event_status = geis_next_event(geis_, &event);
+    }
+
+    fd_set read_fds;
+    FD_ZERO(&read_fds);
+    FD_SET(geis_fd(), &read_fds);
+    timeval tmo = { 5, 0 };
+    int sstat = select(geis_fd() + 1, &read_fds, NULL, NULL, &tmo);
+    EXPECT_GT(sstat, -1) << "error in select";
+    if (sstat == 0)
+      break;
+    dispatch_status = geis_dispatch_events(geis_);
+  }
+  geis_filter_delete(filter);
+  geis_subscription_delete(sub);
+}
+
+
 } // anonymous namespace

=== modified file 'testsuite/libutouch-geis/Makefile.am'
--- testsuite/libutouch-geis/Makefile.am	2012-03-07 03:44:00 +0000
+++ testsuite/libutouch-geis/Makefile.am	2012-03-29 18:37:22 +0000
@@ -53,6 +53,7 @@
 	check_error_reporting.c \
 	check_event_queue.c \
 	check_filter.c \
+	check_filter_term.c \
 	check_geis_private.c \
 	check_region.c \
 	check_subscription.c \

=== added file 'testsuite/libutouch-geis/check_filter_term.c'
--- testsuite/libutouch-geis/check_filter_term.c	1970-01-01 00:00:00 +0000
+++ testsuite/libutouch-geis/check_filter_term.c	2012-03-29 18:37:22 +0000
@@ -0,0 +1,107 @@
+/**
+ * @file check_filter_term.c
+ * @brief unit tests for GEIS filter terms
+ *
+ * Copyright 2012 Canonical Ltd.
+ */
+#include <check.h>
+#include "libutouch-geis/geis_attr.h"
+#include "libutouch-geis/geis_device.h"
+#include "libutouch-geis/geis_filter_term.h"
+
+/* verify filter term construction/destruction */
+START_TEST(construct)
+{
+  GeisInteger ival = 0;
+  GeisAttr attr = geis_attr_new("dummy", GEIS_ATTR_TYPE_INTEGER, &ival);
+  fail_unless(attr != NULL, "failed to create filter term attr");
+
+  GeisFilterTerm term = geis_filter_term_new(GEIS_FILTER_SPECIAL,
+                                             GEIS_FILTER_OP_NE,
+                                             attr);
+  fail_unless(term != NULL, "failed to create filter term");
+
+  geis_filter_term_unref(term);
+}
+END_TEST
+
+
+/* verify device filtering capability */
+START_TEST(device_filter)
+{
+  GeisString device_name = "direct";
+  GeisAttr name_attr = geis_attr_new(GEIS_DEVICE_ATTRIBUTE_NAME,
+                                     GEIS_ATTR_TYPE_STRING,
+                                     (void *)device_name);
+  fail_unless(name_attr != NULL, "failed to create name filter term attr");
+  GeisFilterTerm name_term = geis_filter_term_new(GEIS_FILTER_DEVICE,
+                                                  GEIS_FILTER_OP_NE,
+                                                  name_attr);
+  fail_unless(name_term != NULL, "failed to create id filter term");
+
+  GeisBoolean is_direct = GEIS_TRUE;
+  GeisAttr direct_attr = geis_attr_new(GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH,
+                                       GEIS_ATTR_TYPE_BOOLEAN,
+                                       &is_direct);
+  fail_unless(direct_attr != NULL, "failed to create direct filter term attr");
+  GeisFilterTerm direct_term = geis_filter_term_new(GEIS_FILTER_DEVICE,
+                                                    GEIS_FILTER_OP_EQ,
+                                                    direct_attr);
+  fail_unless(direct_term != NULL, "failed to create direct filter term");
+
+  GeisInteger id = 1;
+  GeisAttr id_attr = geis_attr_new(GEIS_DEVICE_ATTRIBUTE_ID,
+                                   GEIS_ATTR_TYPE_INTEGER,
+                                   &id);
+  fail_unless(id_attr != NULL, "failed to create id filter term attr");
+  GeisFilterTerm id_term = geis_filter_term_new(GEIS_FILTER_DEVICE,
+                                                GEIS_FILTER_OP_EQ,
+                                                id_attr);
+  fail_unless(id_term != NULL, "failed to create id filter term");
+
+  GeisDevice direct_device = geis_device_new(device_name, id);
+  GeisAttr device_attr = geis_attr_new(GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH,
+                                       GEIS_ATTR_TYPE_BOOLEAN,
+                                       &is_direct);
+  fail_unless(device_attr != NULL, "failed to create direct filter term attr");
+  geis_device_add_attr(direct_device, device_attr);
+  GeisDevice indirect_device = geis_device_new("indirect", id + 1);
+
+  GeisBoolean passed = GEIS_FALSE;
+  passed = geis_filter_term_match_device(name_term, direct_device);
+  fail_unless(passed != GEIS_TRUE, "direct device was passed by name term");
+  passed = geis_filter_term_match_device(name_term, indirect_device);
+  fail_unless(passed == GEIS_TRUE, "indirect device was not passed by name term");
+  passed = geis_filter_term_match_device(direct_term, direct_device);
+  fail_unless(passed == GEIS_TRUE, "direct device was not passed by direct term");
+  passed = geis_filter_term_match_device(direct_term, indirect_device);
+  fail_unless(passed != GEIS_TRUE, "indirect device was passed by direct term");
+  passed = geis_filter_term_match_device(id_term, direct_device);
+  fail_unless(passed == GEIS_TRUE, "direct device was not passed by id term");
+  passed = geis_filter_term_match_device(id_term, indirect_device);
+  fail_unless(passed != GEIS_TRUE, "indirect device was passed by id term");
+
+  geis_device_unref(direct_device);
+  geis_device_unref(indirect_device);
+  geis_filter_term_unref(name_term);
+  geis_filter_term_unref(direct_term);
+  geis_filter_term_unref(id_term);
+}
+END_TEST
+
+/* boilerplate */
+Suite *
+make_filter_term_suite()
+{
+  Suite *s = suite_create("utouch-geis2-filter-term");
+
+  TCase *create = tcase_create("filter-term-creation");
+  tcase_add_test(create, construct);
+  suite_add_tcase(s, create);
+
+  TCase *usage = tcase_create("filter-term-usage");
+  tcase_add_test(usage, device_filter);
+  suite_add_tcase(s, usage);
+
+  return s;
+}

=== modified file 'testsuite/libutouch-geis/check_geis2_internals.c'
--- testsuite/libutouch-geis/check_geis2_internals.c	2011-12-21 04:14:05 +0000
+++ testsuite/libutouch-geis/check_geis2_internals.c	2012-03-29 18:37:22 +0000
@@ -13,6 +13,7 @@
 extern Suite *make_error_reporting_suite();
 extern Suite *make_event_queue_suite();
 extern Suite *make_filter_suite();
+extern Suite *make_filter_term_suite();
 extern Suite *make_gesture_class_suite();
 extern Suite *make_region_suite();
 extern Suite *make_select_devices_suite();
@@ -38,6 +39,7 @@
   srunner_add_suite(sr, make_gesture_class_suite());
   srunner_add_suite(sr, make_region_suite());
   srunner_add_suite(sr, make_filter_suite());
+  srunner_add_suite(sr, make_filter_term_suite());
   srunner_add_suite(sr, make_select_devices_suite());
   srunner_add_suite(sr, make_subscription_suite());
   srunner_add_suite(sr, make_timer_suite());