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

[Stephen M. Webb]

Exposes gesture accept and reject functionality if available in back end. Closes lp:934207.

Includes unit tests for both reject and accept.

[Chase Douglas (chasedouglas)]

* Typo:

geis_warning("error %d gettubg subscription window", ugstatus);

* Does geis have a queue of gesture events, or when you call geis_next_event(), does it only then go get an event from grail? If geis has a queue of grail events, reject needs to remove all matching gesture events from the geis queue.

To go along with this, I would like to see the reject test expanded so that it checks if any further gesture events are received for a rejected gesture.

* The accept test case should accept on the begin event, and check if an end event for the gesture is received. This will ensure that the gesture is actually accepted and not rejected.

* These tests don't check whether a gesture and its touches are really accepted or rejected. To do this, we need a test that has a subwindow that would receive the touch events if the gesture is rejected, and does not receive touch events if the gesture is accepted. I think this is getting into more testing than this specific functionality requires, but if we hit any bugs where geis accept/reject is not being propagated properly we will need to make these tests.

review: Needs Fixing

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

215. By Stephen M. Webb on 2012-03-13

Added remove_if function to GEIS event queues.

216. By Stephen M. Webb on 2012-03-13

Added geis_remove_matching_event() function.

217. By Stephen M. Webb on 2012-03-13

Updated integration test to check for rejected events.

218. By Stephen M. Webb on 2012-03-13

Added queued event removal on gesture reject.

219. By Stephen M. Webb on 2012-03-13

fixed typo in warning message

220. By Stephen M. Webb on 2012-03-13

 Added check got GESTURE_END in gesture-accept test case.

221. By Stephen M. Webb on 2012-03-13

Fixed an edge case in queued events removal.

[Stephen M. Webb (bregma)]

* Typo:

Fixed.

* reject needs to remove all matching gesture events from the geis queue.

Since it's impossible to guarantee at the API level that no further event for a rejected gesture will ever come through (event generation is asynchronous over possibly several processes), I figured the application needs to handle this anyway. However, since it is not a big effort to remove these events from the internal GEIS queues, I added this and extended the test case accordingly.

* The accept test case should accept on the begin event, and check if an end event for the gesture is received. This will ensure that the gesture is actually accepted and not rejected.

Sure. Done.

* These tests don't check whether a gesture and its touches are really accepted or rejected. To do this, we need a test that has a subwindow that would receive the touch events if the gesture is rejected, and does not receive touch events if the gesture is accepted. I think this is getting into more testing than this specific functionality requires, but if we hit any bugs where geis accept/reject is not being propagated properly we will need to make these tests.

Yes, I think testing how clients interact with the X server is a little beyond the scope of unit tests for the GEIS API.

[Chase Douglas (chasedouglas)]

> * reject needs to remove all matching gesture events from the geis queue.
>
> Since it's impossible to guarantee at the API level that no further event for
> a rejected gesture will ever come through (event generation is asynchronous
> over possibly several processes), I figured the application needs to handle
> this anyway. However, since it is not a big effort to remove these events
> from the internal GEIS queues, I added this and extended the test case
> accordingly.

Grail does guarantee this. It does the same queued event removal that you implemented for geis. This ensures that no further events may propagate up the stack after a rejection.

If we implemented things right, the application should not receive any events after a reject call.

Everything looks good to me now. Let's get this merged and released!

review: Approve

[Stephen M. Webb (bregma)]

GEIS is not grail. GEIS was designed to be able to wrap the native gestures on Windows and MacOS (and other targets). GEIS could be used in a client-server mode to comply with the original requirements established last year, and events could be on the wire. It's possible that a future input server could operate in an asynchronous mode.

GEIS was also designed to be extensible through client-programmable recognizers (long term) that could mutate events.

There is no way for the API to guarantee synchronous removal of asynchronous events on gesture rejection unless some sort of complex blacklisting or ongoing detection of events, at considerable cost.

Yes, this particular implementation of the grail back end can minimize outstanding events on a rejected gesture, assuming it is used in client-embedded mode.

[Chase Douglas (chasedouglas)]

That's a valid point. In light of that, it's nice that we clean things up :). You're right that we might not be able to guarantee this functionality in all circumstances.

=== modified file 'configure.ac'
--- configure.ac	2012-03-06 16:38:03 +0000
+++ configure.ac	2012-03-13 20:56:18 +0000
@@ -101,9 +101,9 @@
 AC_MSG_RESULT([$with_integration_tests])
 AS_IF([test "x$with_integration_tests" != xno],
       [AC_LANG_PUSH(C++)
-       AC_CHECK_LIB([gtest], [main], [have_gtest=yes])
-       AS_IF([test "x$have_gtest" = xyes],
-             [PKG_CHECK_MODULES([XORG_GTEST],
+       AC_CHECK_HEADER([gtest/gtest.h],
+             [AC_SUBST([GTEST_CFLAGS], [-I/usr/src/gtest])
+              PKG_CHECK_MODULES([XORG_GTEST],
                                 [xorg-gtest],
                                 [have_xorg_gtest=yes],
                          [AC_MSG_WARN([package 'xorg-gtest' not found: related
@@ -111,7 +111,7 @@
               PKG_CHECK_MODULES([EVEMU],[utouch-evemu >= 1.0.5])
              ])
        AC_LANG_POP
-       XORG_GTEST_LIBS="$XORG_GTEST_LIBS -lgtest -lpthread"])
+       XORG_GTEST_LIBS="$XORG_GTEST_LIBS -lpthread"])
 AM_CONDITIONAL([HAVE_XORG_GTEST],[test "x$have_xorg_gtest" = xyes])
 
 AC_CONFIG_FILES([Makefile

=== modified file 'include/geis/geis.h'
--- include/geis/geis.h	2012-02-28 15:15:42 +0000
+++ include/geis/geis.h	2012-03-13 20:56:18 +0000
@@ -2086,16 +2086,32 @@
 GEIS_API GeisTouchId geis_frame_touchid(GeisFrame frame, GeisSize index);
 
 /**
+ * Marks a gesture as accepted.
+ *
+ * @param[in] geis        The GEIS instance.
+ * @param[in] group       The gesture group containing the accepted gesture.
+ * @param[in] gesture_id  Identifies the gesture.
+ *
+ * @sa geis_frame_id
+ */
+GEIS_API GeisStatus geis_gesture_accept(Geis          geis,
+                                        GeisGroup     group,
+                                        GeisGestureId gesture_id);
+
+/**
  * Marks a gesture as rejected.
- * @memberof GeisFrame
  *
+ * @param[in] geis        The GEIS instance.
+ * @param[in] group       The gesture group containing the rejected gesture.
  * @param[in] gesture_id  Identifies the gesture.
  *
  * After you reject a gesture you no longer get its frames.
  *
  * @sa geis_frame_id
  */
-GEIS_API void geis_gesture_reject(GeisGestureId gesture_id);
+GEIS_API GeisStatus geis_gesture_reject(Geis          geis,
+                                        GeisGroup     group,
+                                        GeisGestureId gesture_id);
 
 /* @} */
 

=== modified file 'libutouch-geis/backend/dbus/geis_dbus_backend.c'
--- libutouch-geis/backend/dbus/geis_dbus_backend.c	2011-10-18 19:30:57 +0000
+++ libutouch-geis/backend/dbus/geis_dbus_backend.c	2012-03-13 20:56:18 +0000
@@ -221,10 +221,33 @@
 }
 
 
+static GeisStatus
+_geis_dbus_accept_gesture(GeisBackend   be,
+                          GeisGroup     group,
+                          GeisGestureId gesture_id)
+{
+  GeisDBusBackend gdb = (GeisDBusBackend)be;
+  return geis_dbus_client_accept_gesture(gdb->dbus_client, group, gesture_id);
+}
+
+
+static GeisStatus
+_geis_dbus_reject_gesture(GeisBackend   be,
+                          GeisGroup     group,
+                          GeisGestureId gesture_id)
+{
+  GeisDBusBackend gdb = (GeisDBusBackend)be;
+  return geis_dbus_client_reject_gesture(gdb->dbus_client, group, gesture_id);
+}
+
+
+
 static struct GeisBackendVtable gdb_vtbl = {
   _geis_dbus_backend_construct,
   _geis_dbus_backend_finalize,
   _geis_dbus_backend_create_token,
+  _geis_dbus_accept_gesture,
+  _geis_dbus_reject_gesture,
 };
 
 

=== modified file 'libutouch-geis/backend/dbus/geis_dbus_client.c'
--- libutouch-geis/backend/dbus/geis_dbus_client.c	2011-10-18 18:41:30 +0000
+++ libutouch-geis/backend/dbus/geis_dbus_client.c	2012-03-13 20:56:18 +0000
@@ -681,5 +681,29 @@
 }
 
 
+/*
+ * Asks the remote server to accept a gesture.
+ */
+GeisStatus
+geis_dbus_client_accept_gesture(GeisDBusClient client GEIS_UNUSED,
+                                GeisGroup      group GEIS_UNUSED,
+                                GeisGestureId  gesture_id GEIS_UNUSED)
+{
+  return GEIS_STATUS_SUCCESS;
+}
+
+
+/*
+ * Asks the remote server to reject a gesture.
+ */
+GeisStatus
+geis_dbus_client_reject_gesture(GeisDBusClient client GEIS_UNUSED,
+                                GeisGroup      group GEIS_UNUSED,
+                                GeisGestureId  gesture_id GEIS_UNUSED)
+{
+  return GEIS_STATUS_SUCCESS;
+}
+
+
 
 

=== modified file 'libutouch-geis/backend/dbus/geis_dbus_client.h'
--- libutouch-geis/backend/dbus/geis_dbus_client.h	2011-09-08 17:54:35 +0000
+++ libutouch-geis/backend/dbus/geis_dbus_client.h	2012-03-13 20:56:18 +0000
@@ -93,5 +93,32 @@
 geis_dbus_client_unsubscribe(GeisDBusClient   client,
                              GeisSubscription subscription);
 
+/**
+ * Asks the remote server to accept a gesture.
+ *
+ * @param[in] client     The client side of the DBus connection.
+ * @param[in] group      The gesture group to which the gesture belongs.
+ * @param[in] gesture_id The gesture to accept.
+ *
+ * @returns GEIS_STATUS_SUCCESS on success, some other value otherwise.
+ */
+GeisStatus
+geis_dbus_client_accept_gesture(GeisDBusClient client,
+                                GeisGroup      group,
+                                GeisGestureId  gesture_id);
+
+/**
+ * Asks the remote server to reject a gesture.
+ *
+ * @param[in] client     The client side of the DBus connection.
+ * @param[in] group      The gesture group to which the gesture belongs.
+ * @param[in] gesture_id The gesture to reject.
+ *
+ * @returns GEIS_STATUS_SUCCESS on success, some other value otherwise.
+ */
+GeisStatus
+geis_dbus_client_reject_gesture(GeisDBusClient client,
+                                GeisGroup      group,
+                                GeisGestureId  gesture_id);
 
 #endif /* GEIS_DBUS_CLIENT_H_ */

=== modified file 'libutouch-geis/backend/grail/geis_grail_backend.c'
--- libutouch-geis/backend/grail/geis_grail_backend.c	2012-02-27 19:35:04 +0000
+++ libutouch-geis/backend/grail/geis_grail_backend.c	2012-03-13 20:56:18 +0000
@@ -1188,6 +1188,15 @@
 }
 
 
+static int
+_grail_be_x_error_handler(Display*     display GEIS_UNUSED,
+                          XErrorEvent* event GEIS_UNUSED)
+{
+  geis_error("error in X detected");
+  return 0;
+}
+
+
 /**
  * Deconstructs a Grail back end.
  *
@@ -1205,14 +1214,117 @@
   geis_demultiplex_fd(gbe->geis, frame_get_fd(gbe->frame));
   frame_x11_delete(gbe->frame);
   geis_demultiplex_fd(gbe->geis, ConnectionNumber(gbe->display));
+
+  XErrorHandler old_x_handler = XSetErrorHandler(_grail_be_x_error_handler);
   XCloseDisplay(gbe->display);
-}
-
+  XSetErrorHandler(old_x_handler);
+}
+
+
+/*
+ * Asks grail to accept an identified gesture.
+ */
+GeisStatus
+_grail_be_accept_gesture(GeisBackend   be,
+                         GeisGroup     group GEIS_UNUSED,
+                         GeisGestureId gesture_id)
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  GeisGrailBackend gbe = (GeisGrailBackend)be;
+  unsigned id = gesture_id;
+  UGStatus ugstatus = grail_accept_gesture(gbe->grail, id);
+  if (ugstatus != UGStatusSuccess)
+  {
+    geis_error("accept failed for gesture %u", id);
+  }
+  else
+  {
+    geis_debug("gesture %u accepted", id);
+    status = GEIS_STATUS_SUCCESS;
+  }
+  return status;
+}
+
+
+/*
+ * Predicate to identify events to remove on rejection.
+ */
+static GeisBoolean
+_grail_be_match_gesture_event(GeisEvent event, void *context)
+{
+  GeisGestureId gesture_id = *(GeisGestureId *)context;
+  GeisEventType event_type = geis_event_type(event);
+  if (event_type == GEIS_EVENT_GESTURE_BEGIN
+   || event_type == GEIS_EVENT_GESTURE_UPDATE
+   || event_type == GEIS_EVENT_GESTURE_END)
+  {
+    GeisAttr attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_GROUPSET);
+    if (!attr)
+    {
+      geis_error("can not get groupset from event");
+      return GEIS_FALSE;
+    }
+    GeisGroupSet groupset = (GeisGroupSet)geis_attr_value_to_pointer(attr);
+    for (GeisSize i = 0; i < geis_groupset_group_count(groupset); ++i)
+    {
+      GeisGroup group = geis_groupset_group(groupset, i);
+      if (!group)
+      {
+        geis_error("can not get group %zu in groupset of event", i);
+        return GEIS_FALSE;
+      }
+
+      for (GeisSize j = 0; j < geis_group_frame_count(group); ++j)
+      {
+        GeisFrame frame = geis_group_frame(group, j);
+        if (!frame)
+        {
+          geis_error("can not get frame %zu in group %zu of event", j, i);
+          return GEIS_FALSE;
+        }
+
+        return gesture_id == geis_frame_id(frame);
+      }
+    }
+  }
+  return GEIS_FALSE;
+}
+
+
+/*
+ * Asks grail to reject an identified gesture.
+ */
+GeisStatus
+_grail_be_reject_gesture(GeisBackend   be,
+                         GeisGroup     group GEIS_UNUSED,
+                         GeisGestureId gesture_id)
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  GeisGrailBackend gbe = (GeisGrailBackend)be;
+  unsigned id = gesture_id;
+  UGStatus ugstatus = grail_reject_gesture(gbe->grail, id);
+  if (ugstatus != UGStatusSuccess)
+  {
+    geis_error("rejection failed for gesture %u", id);
+  }
+  else
+  {
+    geis_debug("gesture %u rejected", id);
+    status = GEIS_STATUS_SUCCESS;
+  }
+
+  geis_remove_matching_events(gbe->geis,
+                              _grail_be_match_gesture_event,
+                              &gesture_id);
+  return status;
+}
 
 static struct GeisBackendVtable gbe_vtbl = {
   _geis_grail_backend_construct,
   _geis_grail_backend_finalize,
-  geis_grail_token_new
+  geis_grail_token_new,
+  _grail_be_accept_gesture,
+  _grail_be_reject_gesture,
 };
 
 
@@ -1397,7 +1509,6 @@
   }
 
   UGStatus ugstatus = UGStatusErrorGeneric;
-
   GeisBoolean geis_use_atomic_gestures = GEIS_FALSE;
   geis_get_configuration(gbe->geis,
                          GEIS_CONFIG_ATOMIC_GESTURES,
@@ -1633,6 +1744,22 @@
     {
       UGSubscription ugsub = geis_ugsubscription_get_ugsubscription_at(ugstore,
                                                                        i);
+
+      UFWindowId ufwindow;
+      UGStatus ugstatus;
+      ugstatus = grail_subscription_get_property(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(gbe->window_grabs, window_id);
+      }
+
       grail_subscription_deactivate(gbe->grail, ugsub);
     }
   }

=== modified file 'libutouch-geis/backend/grail/geis_grail_window_grab.c'
--- libutouch-geis/backend/grail/geis_grail_window_grab.c	2012-03-06 15:27:17 +0000
+++ libutouch-geis/backend/grail/geis_grail_window_grab.c	2012-03-13 20:56:18 +0000
@@ -185,7 +185,19 @@
     --grab->grab_count;
     if (0 == grab->grab_count)
     {
-      /* @todo: ungrab */
+      XIGrabModifiers mods = { XIAnyModifier, 0 };
+      Status xstat = XIUngrabTouchBegin(wgs->display,
+                                        XIAllMasterDevices,
+                                        window_id,
+                                        1, &mods);
+      if (xstat)
+      {
+        geis_error("error %d returned from XIUngrabTouchBegin()", xstat);
+      }
+      else if (mods.status != XIGrabSuccess)
+      {
+        geis_error("status %d returned from XIUnrabTouchBegin()", mods.status);
+      }
     }
   }
 }

=== modified file 'libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c'
--- libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c	2011-11-20 13:40:43 +0000
+++ libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c	2012-03-13 20:56:18 +0000
@@ -228,10 +228,30 @@
 }
 
 
+GeisStatus
+_gmock_accept_gesture(GeisBackend   be GEIS_UNUSED,
+                      GeisGroup     group GEIS_UNUSED,
+                      GeisGestureId gesture_ID GEIS_UNUSED)
+{
+  return GEIS_STATUS_SUCCESS;
+}
+
+
+GeisStatus
+_gmock_reject_gesture(GeisBackend   be GEIS_UNUSED,
+                      GeisGroup     group GEIS_UNUSED,
+                      GeisGestureId gesture_ID GEIS_UNUSED)
+{
+  return GEIS_STATUS_SUCCESS;
+}
+
+
 static struct GeisBackendVtable tf_vtbl = {
   _construct,
   _finalize,
   _create_token,
+  _gmock_accept_gesture,
+  _gmock_reject_gesture
 };
 
 

=== modified file 'libutouch-geis/backend/xcb/geis_xcb_backend.c'
--- libutouch-geis/backend/xcb/geis_xcb_backend.c	2012-01-13 10:06:14 +0000
+++ libutouch-geis/backend/xcb/geis_xcb_backend.c	2012-03-13 20:56:18 +0000
@@ -105,13 +105,17 @@
 static void _construct(void *mem, Geis geis);
 static void _finalize(GeisBackend g);
 static GeisBackendToken _create_token(GeisBackend be, GeisBackendTokenInitState);
+static GeisStatus _gxcb_accept_gesture(GeisBackend, GeisGroup, GeisGestureId);
+static GeisStatus _gxcb_reject_gesture(GeisBackend, GeisGroup, GeisGestureId);
 static void _fd_callback(int fd, GeisBackendMultiplexorActivity ev, void *ctx);
 
 
 static struct GeisBackendVtable be_vtbl = {
   _construct,
   _finalize,
-  _create_token
+  _create_token,
+  _gxcb_accept_gesture,
+  _gxcb_reject_gesture
 };
 
 
@@ -1040,3 +1044,21 @@
 {
 }
 
+
+GeisStatus
+_gxcb_accept_gesture(GeisBackend   be GEIS_UNUSED,
+                     GeisGroup     group GEIS_UNUSED,
+                     GeisGestureId gesture_id GEIS_UNUSED)
+{
+  return GEIS_STATUS_UNKNOWN_ERROR;
+}
+
+
+GeisStatus
+_gxcb_reject_gesture(GeisBackend   be GEIS_UNUSED,
+                     GeisGroup     group GEIS_UNUSED,
+                     GeisGestureId gesture_id GEIS_UNUSED)
+{
+  return GEIS_STATUS_UNKNOWN_ERROR;
+}
+

=== modified file 'libutouch-geis/geis.c'
--- libutouch-geis/geis.c	2012-02-23 19:42:24 +0000
+++ libutouch-geis/geis.c	2012-03-13 20:56:18 +0000
@@ -950,6 +950,19 @@
 
 
 /*
+ * Removes all matching events from all event queues.
+ */
+void
+geis_remove_matching_events(Geis            geis,
+                            GeisEventMatch  matching,
+                            void           *context)
+{
+  geis_event_queue_remove_if(geis->input_event_queue, matching, context);
+  geis_event_queue_remove_if(geis->output_event_queue, matching, context);
+}
+
+
+/*
  * Registers an application-supplied event callback.
  */
 void 
@@ -1512,3 +1525,23 @@
   return device;
 }
 
+
+/*
+ * Marks a gesture as accepted.
+ */
+GeisStatus
+geis_gesture_accept(Geis geis, GeisGroup group, GeisGestureId gesture_id)
+{
+  return geis_backend_gesture_accept(geis->backend, group, gesture_id);
+}
+
+
+/*
+ * Marks a gesture as rejected.
+ */
+GeisStatus
+geis_gesture_reject(Geis geis, GeisGroup group, GeisGestureId gesture_id)
+{
+  return geis_backend_gesture_reject(geis->backend, group, gesture_id);
+}
+

=== modified file 'libutouch-geis/geis_backend.c'
--- libutouch-geis/geis_backend.c	2011-12-19 22:14:48 +0000
+++ libutouch-geis/geis_backend.c	2012-03-13 20:56:18 +0000
@@ -177,3 +177,25 @@
 }
 
 
+GeisStatus
+geis_backend_gesture_accept(GeisBackend   be,
+                            GeisGroup     group,
+                            GeisGestureId gesture_id)
+{
+  GeisStatus status = be->be_class->vtbl->accept_gesture(_data_from_be(be),
+                                                         group,
+                                                         gesture_id);
+  return status;
+}
+
+
+GeisStatus
+geis_backend_gesture_reject(GeisBackend   be,
+                            GeisGroup     group,
+                            GeisGestureId gesture_id)
+{
+  GeisStatus status = be->be_class->vtbl->reject_gesture(_data_from_be(be),
+                                                         group,
+                                                         gesture_id);
+  return status;
+}

=== modified file 'libutouch-geis/geis_backend.h'
--- libutouch-geis/geis_backend.h	2011-06-29 14:40:25 +0000
+++ libutouch-geis/geis_backend.h	2012-03-13 20:56:18 +0000
@@ -66,4 +66,28 @@
 GeisBackendToken geis_backend_create_token(GeisBackend be,
                                            GeisBackendTokenInitState);
 
+/**
+ * Marks a gesture as accepted by the back end.
+ *
+ * @param[in] be          The GEIS back end.
+ * @param[in] group       The gesture group containing the accepted gesture.
+ * @param[in] gesture_id  Identifies the gesture.
+ */
+GeisStatus
+geis_backend_gesture_accept(GeisBackend   be,
+                            GeisGroup     group,
+                            GeisGestureId gesture_id);
+
+/**
+ * Marks a gesture as rejected by the back end.
+ *
+ * @param[in] be          The GEIS back end.
+ * @param[in] group       The gesture group containing the rejected gesture.
+ * @param[in] gesture_id  Identifies the gesture.
+ */
+GeisStatus
+geis_backend_gesture_reject(GeisBackend   be,
+                            GeisGroup     group,
+                            GeisGestureId gesture_id);
+
 #endif /* GEIS_BACKEND_H_ */

=== modified file 'libutouch-geis/geis_backend_protected.h'
--- libutouch-geis/geis_backend_protected.h	2011-10-17 16:52:22 +0000
+++ libutouch-geis/geis_backend_protected.h	2012-03-13 20:56:18 +0000
@@ -38,6 +38,8 @@
   void             (* construct)(void *mem, Geis geis);
   void             (* finalize)(GeisBackend);
   GeisBackendToken (* create_token)(GeisBackend, GeisBackendTokenInitState);
+  GeisStatus       (* accept_gesture)(GeisBackend, GeisGroup, GeisGestureId);
+  GeisStatus       (* reject_gesture)(GeisBackend, GeisGroup, GeisGestureId);
 } *GeisBackendVtable;
 
 

=== modified file 'libutouch-geis/geis_event_queue.c'
--- libutouch-geis/geis_event_queue.c	2011-02-05 13:49:54 +0000
+++ libutouch-geis/geis_event_queue.c	2012-03-13 20:56:18 +0000
@@ -1,8 +1,8 @@
 /**
  * @file geis_event_queue.c
  * @brief internal uTouch Geis event queue implementation
- *
- * Copyright 2010 Canonical Ltd.
+ */
+/* Copyright 2010, 2012 Canonical Ltd.
  *
  * This library is free software; you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License as published by the Free
@@ -26,12 +26,19 @@
 
 typedef struct _GeisEventQueueNode *GeisEventQueueNode;
 
+/**
+ * A node in a GEIS event queue.  The event queue is a singly-linked list.
+ */
 struct _GeisEventQueueNode
 {
   GeisEventQueueNode eq_next;
   GeisEvent          eq_event;
 };
 
+/**
+ * A GEIS event queue.  The event queue is a singly linked list with a pool of
+ * free nodes.
+ */
 struct _GeisEventQueue
 {
   GeisEventQueueNode eq_front;
@@ -135,6 +142,18 @@
 
 
 /*
+ * Pushes a node into the front of the free pool for a queue.
+ */
+static void
+_geis_event_queue_add_node_to_pool(GeisEventQueue     queue,
+                                   GeisEventQueueNode node)
+{
+  node->eq_next = queue->eq_pool;
+  queue->eq_pool = node;
+}
+
+
+/*
  * Pops the event off the front of the event queue.
  */
 GeisEvent
@@ -147,11 +166,51 @@
 
     GeisEventQueueNode node = queue->eq_front;
     queue->eq_front = node->eq_next;
-    node->eq_next = queue->eq_pool;
-    queue->eq_pool = node;
+    _geis_event_queue_add_node_to_pool(queue, node);
     if (!queue->eq_front)
       queue->eq_back = NULL;
   }
   return event;
 }
 
+
+/*
+ * Removes events from a queue of they match a condition.
+ */
+void
+geis_event_queue_remove_if(GeisEventQueue  queue,
+                           GeisEventMatch  matching,
+                           void           *context)
+{
+  GeisEventQueueNode prev = NULL;
+  GeisEventQueueNode node = queue->eq_front;
+  while (node)
+  {
+    if (matching(node->eq_event, context))
+    {
+      GeisEventQueueNode matching_node = node;
+      node = node->eq_next;
+
+      if (matching_node == queue->eq_front)
+      {
+        queue->eq_front = matching_node->eq_next;
+      }
+      else
+      {
+        prev->eq_next = matching_node->eq_next;
+      }
+      if (matching_node == queue->eq_back)
+      {
+        queue->eq_back = prev;
+      }
+      geis_event_delete(matching_node->eq_event);
+      _geis_event_queue_add_node_to_pool(queue, matching_node);
+    }
+    else
+    {
+      prev = node;
+      node = node->eq_next;
+    }
+  }
+}
+

=== modified file 'libutouch-geis/geis_event_queue.h'
--- libutouch-geis/geis_event_queue.h	2010-12-14 17:11:24 +0000
+++ libutouch-geis/geis_event_queue.h	2012-03-13 20:56:18 +0000
@@ -83,4 +83,22 @@
  */
 GeisEvent geis_event_queue_dequeue(GeisEventQueue queue);
 
+/**
+ * Prototype for GEIS event matching predicate functions.
+ */
+typedef GeisBoolean (*GeisEventMatch)(GeisEvent event, void *context);
+
+/**
+ * Removes events from a queue of they match a condition.
+ *
+ * @param[in] queue     The event queue.
+ * @param[in] matching  A unary predicate function to indicate the events to be
+ *                      removed.
+ * @param[in] context   An application-specific context value to be passed to
+ *                      the matching function.
+ */
+void geis_event_queue_remove_if(GeisEventQueue  queue,
+                                GeisEventMatch  matching,
+                                void           *context);
+
 #endif /* GEIS_EVENT_QUEUE_H_ */

=== modified file 'libutouch-geis/geis_frame.c'
--- libutouch-geis/geis_frame.c	2012-02-09 18:13:15 +0000
+++ libutouch-geis/geis_frame.c	2012-03-13 20:56:18 +0000
@@ -381,11 +381,3 @@
 }
 
 
-/*
- * Marks a gesture as rejected.
- */
-void
-geis_gesture_reject(GeisGestureId gesture_id GEIS_UNUSED)
-{
-}
-

=== modified file 'libutouch-geis/geis_private.h'
--- libutouch-geis/geis_private.h	2012-02-11 00:30:17 +0000
+++ libutouch-geis/geis_private.h	2012-03-13 20:56:18 +0000
@@ -34,6 +34,7 @@
 #include "geis_backend_multiplexor.h"
 #include "geis_class.h"
 #include "geis_device.h"
+#include "geis_event_queue.h"
 #include "geis_filterable.h"
 #include "geis_region.h"
 #include "geis_subscription.h"
@@ -146,6 +147,24 @@
                                        void                   *context);
 
 /**
+ * Removes all matching events from all event queues.
+ *
+ * @param[in] geis      The API instance.
+ * @param[in] matching  A unary predicate function to indicate the events to be
+ *                      removed.
+ * @param[in] context   An application-specific context value to be passed to
+ *                      the matching function.
+ *
+ * Removes any and all queued events that are indicated by the passed matching
+ * function.
+ */
+void geis_remove_matching_events(Geis            geis,
+                                 GeisEventMatch  matching,
+                                 void           *context);
+
+
+
+/**
  * @defgroup geis_v2_plugin Plugin Interfaces
  * @ingroup geis_v2
  * Interfaces for plugin implementors.

=== modified file 'libutouch-geis/libutouch-geis.ver'
--- libutouch-geis/libutouch-geis.ver	2011-11-23 15:17:53 +0000
+++ libutouch-geis/libutouch-geis.ver	2012-03-13 20:56:18 +0000
@@ -49,6 +49,7 @@
     geis_frame_matrix;
     geis_frame_touchid;
     geis_frame_touchid_count;
+    geis_gesture_accept;
     geis_gesture_class_attr;
     geis_gesture_class_attr_count;
     geis_gesture_class_id;

=== modified file 'testsuite/geis2/Makefile.am'
--- testsuite/geis2/Makefile.am	2012-03-06 17:30:02 +0000
+++ testsuite/geis2/Makefile.am	2012-03-13 20:56:18 +0000
@@ -46,12 +46,15 @@
 	gtest_attrs.cpp \
 	gtest_subscriptions.cpp \
 	gtest_evemu_device.h   gtest_evemu_device.cpp \
-	gtest_geis_fixture.h   gtest_geis_fixture.cpp
+	gtest_geis_fixture.h   gtest_geis_fixture.cpp 
+
+nodist_gtest_geis2_api_SOURCES = /usr/src/gtest/src/gtest-all.cc
 
 gtest_geis2_api_CPPFLAGS = \
 	--std=c++0x \
 	-I$(top_srcdir) \
 	-I$(top_srcdir)/include \
+	$(GTEST_CFLAGS) \
 	$(EVEMU_CFLAGS) \
 	$(XORG_GTEST_CFLAGS)
 

=== modified file 'testsuite/geis2/gtest_subscriptions.cpp'
--- testsuite/geis2/gtest_subscriptions.cpp	2012-03-07 18:12:01 +0000
+++ testsuite/geis2/gtest_subscriptions.cpp	2012-03-13 20:56:18 +0000
@@ -6,10 +6,12 @@
 
 #include "gtest_evemu_device.h"
 #include "gtest_geis_fixture.h"
+#include <sys/select.h>
+#include <sys/time.h>
 
 
 static const std::string TEST_DEVICE_PROP_FILE("touchscreen_a.prop");
-
+static const std::string TEST_DEVICE_EVENTS_FILE("touchscreen_a_rotate90.events");
 
 /**
  * Tests need to make sure at least one multi-touch device is available.
@@ -22,7 +24,7 @@
   : evemu_device_(TEST_DEVICE_PROP_FILE)
   { }
 
-private:
+protected:
   Testsuite::EvemuDevice evemu_device_;
 };
 
@@ -67,8 +69,11 @@
                GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_GT, 1,
                NULL);
   EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not add class to filter 1";
+  fs = geis_subscription_add_filter(sub1, filter1);
+  EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not subscribe filter 1";
+  geis_filter_delete(filter1);
 
-  GeisFilter filter2 = geis_filter_new(geis_, "root window 2");
+  GeisFilter filter2 = geis_filter_new(geis2, "root window 2");
   EXPECT_TRUE(filter2 != NULL) << "can not create filter 2";
 
   fs = geis_filter_add_term(filter2,
@@ -77,11 +82,9 @@
                GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_GT, 1,
                NULL);
   EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not add class to filter 2";
-
-  fs = geis_subscription_add_filter(sub1, filter1);
-  EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not subscribe filter 1";
   fs = geis_subscription_add_filter(sub2, filter2);
   EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not subscribe filter 2";
+  geis_filter_delete(filter2);
 
   EXPECT_EQ(GEIS_STATUS_SUCCESS, geis_subscription_activate(sub1))
               << "can not activate subscription 1";
@@ -93,3 +96,258 @@
   geis_delete(geis2);
 }
 
+/**
+ * Regression test 1 for lp:934207: gesture rejection
+ */
+TEST_F(GeisSubscriptionTests, reject_gesture)
+{
+  GeisGestureClass rotate_class = NULL;
+  GeisGestureId    rejected_gesture_id = 0;
+  bool             gesture_rejected = false;
+  GeisSubscription sub = geis_subscription_new(geis_,
+                                               "subscription",
+                                               GEIS_SUBSCRIPTION_NONE);
+  EXPECT_TRUE(sub != NULL) << "can not create subscription";
+  GeisFilter filter = geis_filter_new(geis_, "root window");
+  EXPECT_TRUE(filter != NULL) << "can not create filter";
+  GeisStatus fs = geis_filter_add_term(filter,
+               GEIS_FILTER_CLASS,
+               GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, GEIS_GESTURE_ROTATE,
+               GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_GT, 1,
+               NULL);
+  EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not add class to filter";
+  fs = geis_subscription_add_filter(sub, filter);
+  EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not subscribe filter";
+  geis_filter_delete(filter);
+  EXPECT_EQ(GEIS_STATUS_SUCCESS, geis_subscription_activate(sub))
+              << "can not activate subscription";
+
+  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:
+          evemu_device_.play(TEST_DEVICE_EVENTS_FILE);
+          break;
+
+        case GEIS_EVENT_CLASS_AVAILABLE:
+        {
+          GeisAttr attr = geis_event_attr_by_name(event,
+                                                  GEIS_EVENT_ATTRIBUTE_CLASS);
+          EXPECT_TRUE(attr != NULL) << "event is missing class attr";
+          GeisGestureClass gesture_class = (GeisGestureClass)geis_attr_value_to_pointer(attr);
+          for (GeisSize i = 0; i < geis_gesture_class_attr_count(gesture_class); ++i)
+          {
+            GeisAttr attr2 = geis_gesture_class_attr(gesture_class, i);
+            if (0 == strcmp(geis_attr_name(attr2), GEIS_CLASS_ATTRIBUTE_NAME))
+            {
+              if (0 == strcmp(geis_attr_value_to_string(attr2),
+                              GEIS_GESTURE_ROTATE))
+              {
+                rotate_class = gesture_class;
+              }
+            }
+          }
+          break;
+        }
+
+        case GEIS_EVENT_GESTURE_BEGIN:
+        case GEIS_EVENT_GESTURE_UPDATE:
+        {
+          GeisAttr attr = geis_event_attr_by_name(event,
+                                                  GEIS_EVENT_ATTRIBUTE_GROUPSET);
+          EXPECT_TRUE(attr != NULL) << "event is missing groupset attr";
+          GeisGroupSet groupset = (GeisGroupSet)geis_attr_value_to_pointer(attr);
+          EXPECT_TRUE(groupset != NULL) << "event is missing groupset";
+          for (GeisSize i = 0; i < geis_groupset_group_count(groupset); ++i)
+          {
+            GeisGroup group = geis_groupset_group(groupset, i);
+            EXPECT_TRUE(group != NULL) << "group " << i
+                                       << " not found in groupset";
+
+            for (GeisSize j = 0; j < geis_group_frame_count(group); ++j)
+            {
+              GeisFrame frame = geis_group_frame(group, j);
+              EXPECT_TRUE(frame != NULL) << "frame " << j
+                                         << " not found in group";
+
+              if (geis_frame_is_class(frame, rotate_class))
+              {
+                if (!gesture_rejected)
+                {
+                  rejected_gesture_id = geis_frame_id(frame);
+                  GeisStatus gs = geis_gesture_reject(geis_,
+                                                      group,
+                                                      rejected_gesture_id);
+                  EXPECT_EQ(gs, GEIS_STATUS_SUCCESS) << "rejection failed";
+                  gesture_rejected = true;
+                }
+                else
+                {
+                  EXPECT_NE(geis_frame_id(frame), rejected_gesture_id)
+                            << "gesture events after gesture rejected";
+                }
+              }
+            }
+          }
+          break;
+        }
+
+        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_EQ(gesture_rejected, true) << "gesture was never rejected";
+  geis_subscription_delete(sub);
+}
+
+
+/**
+ * Regression test 2 for lp:934207: gesture acceptance
+ */
+TEST_F(GeisSubscriptionTests, accept_gesture)
+{
+  GeisGestureClass rotate_class = NULL;
+  bool gesture_accepted = false;
+  bool gesture_ended = false;
+  GeisSubscription sub = geis_subscription_new(geis_,
+                                               "subscription",
+                                               GEIS_SUBSCRIPTION_NONE);
+  EXPECT_TRUE(sub != NULL) << "can not create subscription";
+  GeisFilter filter = geis_filter_new(geis_, "root window");
+  EXPECT_TRUE(filter != NULL) << "can not create filter";
+  GeisStatus fs = geis_filter_add_term(filter,
+               GEIS_FILTER_CLASS,
+               GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, GEIS_GESTURE_ROTATE,
+               GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_GT, 1,
+               NULL);
+  EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not add class to filter";
+  fs = geis_subscription_add_filter(sub, filter);
+  EXPECT_EQ(fs, GEIS_STATUS_SUCCESS) << "can not subscribe filter";
+  geis_filter_delete(filter);
+  EXPECT_EQ(GEIS_STATUS_SUCCESS, geis_subscription_activate(sub))
+              << "can not activate subscription";
+
+  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:
+          evemu_device_.play(TEST_DEVICE_EVENTS_FILE);
+          break;
+
+        case GEIS_EVENT_CLASS_AVAILABLE:
+        {
+          GeisAttr attr = geis_event_attr_by_name(event,
+                                                  GEIS_EVENT_ATTRIBUTE_CLASS);
+          EXPECT_TRUE(attr != NULL) << "event is missing class attr";
+          GeisGestureClass gesture_class = (GeisGestureClass)geis_attr_value_to_pointer(attr);
+          for (GeisSize i = 0; i < geis_gesture_class_attr_count(gesture_class); ++i)
+          {
+            GeisAttr attr2 = geis_gesture_class_attr(gesture_class, i);
+            if (0 == strcmp(geis_attr_name(attr2), GEIS_CLASS_ATTRIBUTE_NAME))
+            {
+              if (0 == strcmp(geis_attr_value_to_string(attr2),
+                              GEIS_GESTURE_ROTATE))
+              {
+                rotate_class = gesture_class;
+              }
+            }
+          }
+          break;
+        }
+
+        case GEIS_EVENT_GESTURE_BEGIN:
+        case GEIS_EVENT_GESTURE_UPDATE:
+        {
+          GeisAttr attr = geis_event_attr_by_name(event,
+                                                  GEIS_EVENT_ATTRIBUTE_GROUPSET);
+          EXPECT_TRUE(attr != NULL) << "event is missing groupset attr";
+          GeisGroupSet groupset = (GeisGroupSet)geis_attr_value_to_pointer(attr);
+          EXPECT_TRUE(groupset != NULL) << "event is missing groupset";
+          for (GeisSize i = 0; i < geis_groupset_group_count(groupset); ++i)
+          {
+            GeisGroup group = geis_groupset_group(groupset, i);
+            EXPECT_TRUE(group != NULL) << "group " << i
+                                       << " not found in groupset";
+
+            for (GeisSize j = 0; j < geis_group_frame_count(group); ++j)
+            {
+              GeisFrame frame = geis_group_frame(group, j);
+              EXPECT_TRUE(frame != NULL) << "frame " << j
+                                         << " not found in group";
+
+              if (!gesture_accepted && geis_frame_is_class(frame, rotate_class))
+              {
+                GeisStatus gs = geis_gesture_accept(geis_,
+                                                    group,
+                                                    geis_frame_id(frame));
+                EXPECT_EQ(gs, GEIS_STATUS_SUCCESS) << "aceptance failed";
+                gesture_accepted = true;
+              }
+            }
+          }
+          break;
+        }
+
+        case GEIS_EVENT_GESTURE_END:
+          gesture_ended = true;
+          goto end_of_outer_loop;
+          break;
+
+        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_);
+  }
+end_of_outer_loop:
+
+  EXPECT_EQ(gesture_accepted, true) << "gesture was never accepted";
+  EXPECT_EQ(gesture_ended, true) << "gesture did not end";
+  geis_subscription_delete(sub);
+}
+

=== modified file 'testsuite/libutouch-geis/check_event_queue.c'
--- testsuite/libutouch-geis/check_event_queue.c	2010-12-20 18:06:36 +0000
+++ testsuite/libutouch-geis/check_event_queue.c	2012-03-13 20:56:18 +0000
@@ -68,6 +68,42 @@
 }
 END_TEST
 
+/* verify event_queue remove_if */
+static GeisBoolean
+_is_event_type(GeisEvent event, void* context)
+{
+  GeisEventType event_type = *(GeisEventType*)context;
+  return geis_event_type(event) == event_type;
+}
+
+START_TEST(remove_if)
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  GeisEvent event1 = geis_event_new(GEIS_EVENT_GESTURE_BEGIN);
+  status = geis_event_queue_enqueue(g_queue, event1);
+  fail_unless(status == GEIS_STATUS_SUCCESS, "failure at enqueue(event1)");
+
+  GeisEvent event2 = geis_event_new(GEIS_EVENT_USER_DEFINED);
+  status = geis_event_queue_enqueue(g_queue, event2);
+  fail_unless(status == GEIS_STATUS_SUCCESS, "failure at enqueue(event2)");
+
+  GeisEvent event3 = geis_event_new(GEIS_EVENT_GESTURE_END);
+  status = geis_event_queue_enqueue(g_queue, event3);
+  fail_unless(status == GEIS_STATUS_SUCCESS, "failure at enqueue(event3)");
+
+  GeisEventType event_type = GEIS_EVENT_USER_DEFINED;
+  geis_event_queue_remove_if(g_queue, _is_event_type, &event_type);
+
+  event_type = GEIS_EVENT_GESTURE_BEGIN;
+  geis_event_queue_remove_if(g_queue, _is_event_type, &event_type);
+
+  event_type = GEIS_EVENT_GESTURE_END;
+  geis_event_queue_remove_if(g_queue, _is_event_type, &event_type);
+
+  fail_unless(geis_event_queue_is_empty(g_queue), "queue is not empty");
+}
+END_TEST
+
 /* boilerplate */
 Suite *
 make_event_queue_suite()
@@ -81,6 +117,7 @@
   TCase *usage = tcase_create("event-queue-operation");
   tcase_add_checked_fixture(usage, construct_event_queue, destroy_event_queue);
   tcase_add_test(usage, enqueue_dequeue);
+  tcase_add_test(usage, remove_if);
   suite_add_tcase(s, usage);
 
   return s;

=== modified file 'testsuite/libutouch-geis/check_geis_private.c'
--- testsuite/libutouch-geis/check_geis_private.c	2011-09-02 02:04:05 +0000
+++ testsuite/libutouch-geis/check_geis_private.c	2012-03-13 20:56:18 +0000
@@ -79,6 +79,53 @@
 }
 END_TEST
 
+/* Check selective queue removal. */
+static GeisBoolean
+_is_event_type(GeisEvent event, void* context)
+{
+  GeisEventType event_type = *(GeisEventType*)context;
+  return geis_event_type(event) == event_type;
+}
+
+START_TEST(remove_matching)
+{
+  GeisStatus status;
+
+  /* empty the event queue */
+  while (GEIS_STATUS_CONTINUE == geis_dispatch_events(g_geis))
+    ;
+  GeisEvent event_out;
+  while (GEIS_STATUS_CONTINUE == geis_next_event(g_geis, &event_out))
+    geis_event_delete(event_out);
+
+  /* push 3 controlled events into the queue */
+  GeisEvent event_in_1 = geis_event_new(GEIS_EVENT_GESTURE_BEGIN);
+  geis_post_event(g_geis, event_in_1);
+  GeisEvent event_in_2 = geis_event_new(GEIS_EVENT_USER_DEFINED);
+  geis_post_event(g_geis, event_in_2);
+  GeisEvent event_in_3 = geis_event_new(GEIS_EVENT_GESTURE_END);
+  geis_post_event(g_geis, event_in_3);
+
+  /* remove the middle event */
+  GeisEventType event_type = GEIS_EVENT_USER_DEFINED;
+  geis_remove_matching_events(g_geis, _is_event_type, &event_type);
+
+  /* verify it's no longer in the queue */
+  status = geis_dispatch_events(g_geis);
+  fail_unless(status == GEIS_STATUS_SUCCESS,
+              "unexpected status from geis_dispatch_events");
+  for (status = geis_next_event(g_geis, &event_out);
+       status != GEIS_STATUS_EMPTY;
+       status = geis_next_event(g_geis, &event_out))
+  {
+    fail_if(GEIS_EVENT_USER_DEFINED == geis_event_type(event_out),
+                "event was not successfully removed");
+    geis_event_delete(event_out);
+  }
+
+}
+END_TEST
+
 START_TEST(multiplex_fd)
 {
   int pfd[2];
@@ -151,6 +198,7 @@
   TCase *usage = tcase_create("backend-event-posting");
   tcase_add_checked_fixture(usage, construct_geis, destroy_geis);
   tcase_add_test(usage, backend_post);
+  tcase_add_test(usage, remove_matching);
   tcase_add_test(usage, multiplex_fd);
   suite_add_tcase(s, usage);