Merge lp:~dandrader/geis/lp984069 into lp:geis

[Daniel d'Andrada]

GeisTouches from direct devices should be in window coordinates. Have this also documented in geis.h

The fix for bug #978378 in Unity depends on it.

This should be tested by someone with a touchscreen device along with the fix for bug #978378 (lp:~dandrader/unity/direct_device) to verify that those modifications indeed get bug #978378 fixed.

[Stephen M. Webb (bregma)]

The code change looks OK. I built and tested with a touchscreen, and nothing appears to be broken, but I don't think that's really a valid test of this change. Is there a better interactive test?

[Chase Douglas (chasedouglas)]

I tested the branch and everything seems to work appropriately. In the unity branch, the unity bug #978378 seems to be fixed.

We just need tests in geis now.

review: Needs Fixing

[lp:~dandrader/geis/lp984069]

253. By Stephen M. Webb on 2012-04-18

Added an API for setting and getting grail tuning properties.

254. By Stephen M. Webb on 2012-04-20

Added a compile-time sentinel check to variadic calls in the API.

[Daniel d'Andrada (dandrader)]

It now has a unit test.

[Daniel d'Andrada (dandrader)]

I would make it use Google Test istead of Check Framework but in utouch-geis GTest is quite entangled with xorg-gtest and integration tests (ENABLE_INTEGRATION_TESTS).

[Chase Douglas (chasedouglas)]

As far as I understand, the gtest issue is merely that we need to make the autotools stuff know about gtest for unit testing. I would prefer to fix that issue now and continue to use gtest.

Otherwise, I'm ok with this for now. I think we may want to split the mock out into a separate project in the future, maybe using a mock framework like google-mock to make things easier.

review: Needs Fixing

[lp:~dandrader/geis/lp984069]

255. By Chase Douglas on 2012-04-23

Merge fixes for radius and position delta calculations

256. By Chase Douglas on 2012-04-23

Merge fix for GeisSubscriptionFlags usage when compiling with g++

[Daniel d'Andrada (dandrader)]

Took libgtest.a out of libgtest_geis.a and made the regression test of this bug GTest based instead of Check based.

Ready for a new review.

[Chase Douglas (chasedouglas)]

* xorg-gtest.m4 shouldn't be modified. It comes from upstream xorg-gtest and may be replaced by a newer version from an updated xorg-gtest automatically by aclocal --install. IIRC, I think it may also be always replaced by our packaging since it uses aclocal --install --force.

Since _CHECK_GTEST is meant to be an internal implementation detail of xorg-gtest.m4, I suggest copying it to a new file m4/gtest.m4 and removing the leading underscore.

* libgtest_geis_a_CPPFLAGS still needs $(GTEST_CPPFLAGS). If the gtest headers are installed somewhere other than a standard location, GTEST_CPPFLAGS will have the -I<header path> option. This will be needed for building xorg-gtest too. Likewise for gtest_geis2_grail_backend_CPPFLAGS.

* libgtest_geis_a_LIBADD should add the libgtest.a file instead of an intermediate object file. I don't know if that will work, but the .o file is sort of an autotools implementation detail. This may also remove the need for libgtest_geis_a_DEPENDENCIES.

* libgtest doesn't need to be built with --std=c++0x. xorg-gtest doesn't need to built with it either. I also don't know why TEST_ROOT_DIR is defined for both gtest libs. I think it was a copy/paste error.

* PRINT_FAILURE_AND_RETURN isn't necessary. All you need is ADD_FAILURE() << [message]; The file and line will be printed automatically, and the function return automatically.

* I like the idea of MOCK_PRINT. I think it duplicates the geis logging, though. Why not use geis_debug()? I know this means you can't enable mock printouts without geis debug printouts, but I think that's ok. If you're debugging at this level you might be setting GEIS_DEBUG=3 anyway. If you have a standard format where something like "XMOCK: " is prepended to the message, it will be easy to grep or grep -v on it.

review: Needs Fixing

[Stephen M. Webb (bregma)]

(1) m4/xorg-gtest.m4 is actually a convenience copy of a source file belonging to another package and will likely be overwritten at build time. I would suggest the CHECK_GTEST macro be hoisted into its own .m4 file so it doesn't get trampled: it's already renamed so there shouldn't be a conflict.

(2) Not sure why you did all the fancy wrangling in testsuite/gtest/Makefile.am to provide multiple libraries instead of just including the xorg-gtest sources conditionally on ENABLE_INTEGRATION_TESTS. Could you make your reasoning explicit?

(3) Why reorganize testsuite/geis2/Makefile.am? Traditionally all the build targets go at the top (eg. *_PROGRAMS) and the detailed rules for building them come later, rather than the other way around. Granted, that tradition started because automake required it, but following convention makes it easier from someone who sees a lot of Makefile.ams to follow unfamiliar code. Could you make your reasoning for this explicit?

(4) If you're changing testsuite libraries around anyway, would it be possible to consolidate all support libraries used in the testsuite (gtest, mocks) into a single subdirectory? It would simplify the Makefile.ams used in the various test suites. Feel free to argue this.

review: Needs Fixing

[Stephen M. Webb (bregma)]

* I like the idea of MOCK_PRINT. I think it duplicates the geis logging, though. Why not use geis_debug()? I know this means you can't enable mock printouts without geis debug printouts, but I think that's ok. If you're debugging at this level you might be setting GEIS_DEBUG=3 anyway. If you have a standard format where something like "XMOCK: " is prepended to the message, it will be easy to grep or grep -v on it.

geis_debug() is not a public symbol exported from libutouch-geis.so. It is not available for any part of the testsuite except the libutouch tests (which are internal unit tests).

[Chase Douglas (chasedouglas)]

On 04/23/2012 02:17 PM, Stephen M. Webb wrote:
> * I like the idea of MOCK_PRINT. I think it duplicates the geis logging, though. Why not use geis_debug()? I know this means you can't enable mock printouts without geis debug printouts, but I think that's ok. If you're debugging at this level you might be setting GEIS_DEBUG=3 anyway. If you have a standard format where something like "XMOCK: " is prepended to the message, it will be easy to grep or grep -v on it.
>
> geis_debug() is not a public symbol exported from libutouch-geis.so. It is not available for any part of the testsuite except the libutouch tests (which are internal unit tests).

Ok. What about printing if an env var is set, like MOCK_DEBUG? I'm not a
big fan of preprocessor macros enabling optional functionality. It's not
easy to figure out whether something has been compiled with the
functionality or not.

[Stephen M. Webb (bregma)]

> Ok. What about printing if an env var is set, like MOCK_DEBUG? I'm not a
> big fan of preprocessor macros enabling optional functionality. It's not
> easy to figure out whether something has been compiled with the
> functionality or not.

+1

[Daniel d'Andrada (dandrader)]

> On 04/23/2012 02:17 PM, Stephen M. Webb wrote:
> > * I like the idea of MOCK_PRINT. I think it duplicates the geis logging,
> though. Why not use geis_debug()? I know this means you can't enable mock
> printouts without geis debug printouts, but I think that's ok. If you're
> debugging at this level you might be setting GEIS_DEBUG=3 anyway. If you have
> a standard format where something like "XMOCK: " is prepended to the message,
> it will be easy to grep or grep -v on it.
> >
> > geis_debug() is not a public symbol exported from libutouch-geis.so. It is
> not available for any part of the testsuite except the libutouch tests (which
> are internal unit tests).
>
> Ok. What about printing if an env var is set, like MOCK_DEBUG? I'm not a
> big fan of preprocessor macros enabling optional functionality. It's not
> easy to figure out whether something has been compiled with the
> functionality or not.

Me neither, but that was the easiest way and I didn't think it was worth to invest time into making a fully fledged solution.

[Daniel d'Andrada (dandrader)]

> (3) Why reorganize testsuite/geis2/Makefile.am? Traditionally all the build
> targets go at the top (eg. *_PROGRAMS) and the detailed rules for building
> them come later, rather than the other way around. Granted, that tradition
> started because automake required it, but following convention makes it easier
> from someone who sees a lot of Makefile.ams to follow unfamiliar code. Could
> you make your reasoning for this explicit?

I like when all code regarding a library/program is together in a single block instead of intertwined with code for other libraries/programs. I find that arrangement easier to read and maintain. But as with coding style, it's mostly a matter of personal taste.

[Daniel d'Andrada (dandrader)]

> (2) Not sure why you did all the fancy wrangling in
> testsuite/gtest/Makefile.am to provide multiple libraries instead of just
> including the xorg-gtest sources conditionally on ENABLE_INTEGRATION_TESTS.
> Could you make your reasoning explicit?

That's another way of doing it. But I prefer the separation method since "That way we can have tests that depend on gtest but not on xorg-gtest" and therefore tests can link against only what they are going to use. Tests that use xmock will use gtest but never xorg-gtest, evemu or the fixtures included in libgtest_geis.

[Daniel d'Andrada (dandrader)]

> (4) If you're changing testsuite libraries around anyway, would it be possible
> to consolidate all support libraries used in the testsuite (gtest, mocks) into
> a single subdirectory? It would simplify the Makefile.ams used in the various
> test suites. Feel free to argue this.

I personally find it a bit messy to have the sources of several separate, independent, binaries (programs of libraries) living together in the same directory. It can easily result in a cluttered directory listing and Makefile.am.

[Stephen M. Webb (bregma)]

On 04/24/2012 09:52 AM, Daniel d'Andrada wrote:
>> (2) Not sure why you did all the fancy wrangling in
>> testsuite/gtest/Makefile.am to provide multiple libraries instead of just
>> including the xorg-gtest sources conditionally on ENABLE_INTEGRATION_TESTS.
>> Could you make your reasoning explicit?
>
> That's another way of doing it. But I prefer the separation method since "That way we can have tests that depend on gtest but not on xorg-gtest" and therefore tests can link against only what they are going to use. Tests that use xmock will use gtest but never xorg-gtest, evemu or the fixtures included in libgtest_geis.

But you know that for the last 40 years or so linkers only pull objects out of archives if they're used, so the only
difference between using a single library and using multiple libraries is one of increased maintenance cost and
confusion about which library to use?

[Daniel d'Andrada (dandrader)]

> On 04/24/2012 09:52 AM, Daniel d'Andrada wrote:
> >> (2) Not sure why you did all the fancy wrangling in
> >> testsuite/gtest/Makefile.am to provide multiple libraries instead of just
> >> including the xorg-gtest sources conditionally on ENABLE_INTEGRATION_TESTS.
> >> Could you make your reasoning explicit?
> >
> > That's another way of doing it. But I prefer the separation method since
> "That way we can have tests that depend on gtest but not on xorg-gtest" and
> therefore tests can link against only what they are going to use. Tests that
> use xmock will use gtest but never xorg-gtest, evemu or the fixtures included
> in libgtest_geis.
>
> But you know that for the last 40 years or so linkers only pull objects out of
> archives if they're used, so the only
> difference between using a single library and using multiple libraries is one
> of increased maintenance cost and
> confusion about which library to use?

I can do single library approach, no problem.

[Daniel d'Andrada (dandrader)]

Updated according to comments.

Ready for a new review round.

[lp:~dandrader/geis/lp984069]

257. By Daniel d'Andrada on 2012-04-24

GeisTouches from direct devices should be in window coordinates

GeisTouches provided by gesture events (GEIS_EVENT_GESTURE_BEGIN,
GEIS_EVENT_GESTURE_UPDATE and GEIS_EVENT_GESTURE_END) should be in window
coordinates if they come from a direct device (e.g. touchscreens) and in
input device coordinates when from indirect devices (e.g. touchpads/trackpads).

Have this also documented in geis.h

They were coming always in device coordinates.

258. By Daniel d'Andrada on 2012-04-24

Make it possible to have gtest without integration tests and xorg-gtest

That way we can have unit and functional tests using gtest independently
of whether integration tests will be built or whether xorg-gtest is present.

259. By Daniel d'Andrada on 2012-04-24

Adding X11 mockups

260. By Daniel d'Andrada on 2012-04-24

Organize the Makefile a bit

Bring together the code for each binary in blocks instead of having them intertwined

261. By Daniel d'Andrada on 2012-04-24

Regression test for lp984069

[Chase Douglas (chasedouglas)]

* The --std=c++0x flags are still used.

* PRINT_FAILURE_AND_RETURN is still there.

I think everything else I commented on has been addressed.

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> * The --std=c++0x flags are still used.
>
> * PRINT_FAILURE_AND_RETURN is still there.
>
> I think everything else I commented on has been addressed.

Ah, yeah, I forgot those. Sorry for that.

[lp:~dandrader/geis/lp984069]

262. By Daniel d'Andrada on 2012-04-24

GTest doesn't need --std=c++0x

263. By Daniel d'Andrada on 2012-04-24

ADD_FAILURE() already prints the current file name and line number

264. By Daniel d'Andrada on 2012-04-24

Stop immediately if subscription creation fails

[Daniel d'Andrada (dandrader)]

Updated.

ADD_FAILURE() does print the file name and line number but it does *not* return. Therefore a wrapping macro is still needed. So I removed the printf() command and renamed the macro.

I've removed the --std=c++0x flag from gtest

[Chase Douglas (chasedouglas)]

On 04/24/2012 11:59 AM, Daniel d'Andrada wrote:
> ADD_FAILURE() does print the file name and line number but it does *not* return. Therefore a wrapping macro is still needed. So I removed the printf() command and renamed the macro.

Ahh, I remembered wrong. You want FAIL() << [message]; It's just like
ADD_FAILURE() except that it causes the function to return. It's
analogous to ASSERT_*() vs EXPECT_*().

http://code.google.com/p/googletest/wiki/AdvancedGuide#Explicit_Success_and_Failure

> I've removed the --std=c++0x flag from gtest

gtest_geis2_grail_backend_CPPFLAGS still has --std=c++0x.

[Stephen M. Webb (bregma)]

"make distcheck" fails (there should be no nodist_ prefix on the SOURCES variable in testsuite/x11_mocks/Makefile.am).

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> On 04/24/2012 11:59 AM, Daniel d'Andrada wrote:
> > ADD_FAILURE() does print the file name and line number but it does *not*
> return. Therefore a wrapping macro is still needed. So I removed the printf()
> command and renamed the macro.
>
> Ahh, I remembered wrong. You want FAIL() << [message]; It's just like
> ADD_FAILURE() except that it causes the function to return. It's
> analogous to ASSERT_*() vs EXPECT_*().
>
> http://code.google.com/p/googletest/wiki/AdvancedGuide#Explicit_Success_and_Failure

FAIL(), like ASSERT_*(), can only be used from within functions that return void. That's why I have to stick with ADD_FAILURE().

>
> > I've removed the --std=c++0x flag from gtest
>
> gtest_geis2_grail_backend_CPPFLAGS still has --std=c++0x.

I needs --std=c++0x because it uses c++0x stuff (like nullptr and range-based for loops)

[Daniel d'Andrada (dandrader)]

> "make distcheck" fails (there should be no nodist_ prefix on the SOURCES
> variable in testsuite/x11_mocks/Makefile.am).

Fixed.

[lp:~dandrader/geis/lp984069]

265. By Daniel d'Andrada on 2012-04-24

sources of x11_mocks are distributed

[Chase Douglas (chasedouglas)]

review: Approve

[Chase Douglas (chasedouglas)]

On 04/24/2012 12:31 PM, Daniel d'Andrada wrote:
>> On 04/24/2012 11:59 AM, Daniel d'Andrada wrote:
>>> ADD_FAILURE() does print the file name and line number but it does *not*
>> return. Therefore a wrapping macro is still needed. So I removed the printf()
>> command and renamed the macro.
>>
>> Ahh, I remembered wrong. You want FAIL() << [message]; It's just like
>> ADD_FAILURE() except that it causes the function to return. It's
>> analogous to ASSERT_*() vs EXPECT_*().
>>
>> http://code.google.com/p/googletest/wiki/AdvancedGuide#Explicit_Success_and_Failure
>
> FAIL(), like ASSERT_*(), can only be used from within functions that return void. That's why I have to stick with ADD_FAILURE().

Ahh, yes, that would be an issue.

This is a bit bike-shedding, but I would prefer to unroll the macro
since it's two simple lines. I think it would make the code easier to
read. However, I'm ok with it as is.

>>
>>> I've removed the --std=c++0x flag from gtest
>>
>> gtest_geis2_grail_backend_CPPFLAGS still has --std=c++0x.
>
> I needs --std=c++0x because it uses c++0x stuff (like nullptr and range-based for loops)

Ok, I didn't realize that.

[lp:~dandrader/geis/lp984069]

266. By Daniel d'Andrada on 2012-04-24

We don't need a macro anymore. Wrapped code is too simple

=== modified file '.bzrignore'
--- .bzrignore	2012-04-11 16:18:03 +0000
+++ .bzrignore	2012-04-24 19:38:21 +0000
@@ -48,4 +48,5 @@
 TAGS
 testsuite/geistest/geistest
 testsuite/libutouch-geis/*.xml
+testsuite/geis2/gtest_geis2_grail_backend
 tools/geis-server/geis-server
 
=== modified file 'configure.ac'
--- configure.ac	2012-04-12 17:13:41 +0000
+++ configure.ac	2012-04-24 19:38:21 +0000
@@ -97,6 +97,10 @@
               [enable_integration_tests=$enableval],
               [enable_integration_tests=auto])
 
+# Check for Google C++ Testing Framework
+CHECK_GTEST()
+AM_CONDITIONAL([HAVE_GTEST], [test "x$have_gtest" = xyes])
+
 have_xorg_gtest=no
 AS_IF([test "x$enable_integration_tests" != xno],
       [CHECK_XORG_GTEST(
@@ -132,6 +136,7 @@
                  testsuite/geis2/Makefile
                  testsuite/geis1/Makefile
                  testsuite/geistest/Makefile
+                 testsuite/x11_mocks/Makefile
                  examples/Makefile
                  python/Makefile
                  tools/Makefile
 
=== modified file 'include/geis/geis.h'
--- include/geis/geis.h	2012-04-20 19:14:59 +0000
+++ include/geis/geis.h	2012-04-24 19:38:21 +0000
@@ -2061,6 +2061,11 @@
  * is capable of reporting differing sets of touch attributes, so there is no
  * guarantee that any or all of the defined touch attributes will bre present.
  *
+ * If the touch comes from a direct device (see
+ * GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH) its position (x and y attributes) will
+ * be in window coordinates, otherwise it will be in the input device's own
+ * coordinate system.
+ *
  * @{
  *
  * @def GEIS_TOUCH_ATTRIBUTE_ID
 
=== modified file 'libutouch-geis/backend/grail/geis_grail_backend.c'
--- libutouch-geis/backend/grail/geis_grail_backend.c	2012-04-20 15:00:21 +0000
+++ libutouch-geis/backend/grail/geis_grail_backend.c	2012-04-24 19:38:21 +0000
@@ -635,19 +635,29 @@
           focus_y = frame_touch_get_window_y(uftouch);
         }
 
-        GeisFloat fval = frame_touch_get_device_x(uftouch);
-        bboxMinX = fmin(bboxMinX, fval);
-        bboxMaxX = fmax(bboxMaxX, fval);
+        GeisFloat touch_x, touch_y;
+        if (is_touchscreen)
+        {
+          touch_x = frame_touch_get_window_x(uftouch);
+          touch_y = frame_touch_get_window_y(uftouch);
+        }
+        else
+        {
+          touch_x = frame_touch_get_device_x(uftouch);
+          touch_y = frame_touch_get_device_y(uftouch);
+        }
+
+        bboxMinX = fmin(bboxMinX, touch_x);
+        bboxMaxX = fmax(bboxMaxX, touch_x);
         geis_touch_add_attr(touch, geis_attr_new(GEIS_TOUCH_ATTRIBUTE_X,
                                                  GEIS_ATTR_TYPE_FLOAT,
-                                                 &fval));
+                                                 &touch_x));
 
-        fval = frame_touch_get_device_y(uftouch);
-        bboxMinY = fmin(bboxMinY, fval);
-        bboxMaxY = fmax(bboxMaxY, fval);
+        bboxMinY = fmin(bboxMinY, touch_y);
+        bboxMaxY = fmax(bboxMaxY, touch_y);
         geis_touch_add_attr(touch, geis_attr_new(GEIS_TOUCH_ATTRIBUTE_Y,
                                                  GEIS_ATTR_TYPE_FLOAT,
-                                                 &fval));
+                                                 &touch_y));
 
         geis_touchset_insert(touchset, touch);
         geis_frame_add_touchid(frame, geis_touch_id(touch));
 
=== added file 'm4/gtest.m4'
--- m4/gtest.m4	1970-01-01 00:00:00 +0000
+++ m4/gtest.m4	2012-04-24 19:38:21 +0000
@@ -0,0 +1,51 @@
+# serial 1
+
+# Copyright (C) 2012 Canonical, Ltd.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice (including the next
+# paragraph) shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# Checks whether the gtest source is available on the system. Allows for
+# adjusting the include and source path. Sets have_gtest=yes if the source is
+# present. Sets GTEST_CPPFLAGS and GTEST_SOURCE to the preprocessor flags and
+# source location respectively.
+AC_DEFUN([CHECK_GTEST],
+[
+  AC_ARG_WITH([gtest-include-path],
+              [AS_HELP_STRING([--with-gtest-include-path],
+                              [location of the Google test headers])],
+              [GTEST_CPPFLAGS="-I$withval"])
+
+  AC_ARG_WITH([gtest-source-path],
+              [AS_HELP_STRING([--with-gtest-source-path],
+                              [location of the Google test sources, defaults to /usr/src/gtest])],
+              [GTEST_SOURCE="$withval"],
+              [GTEST_SOURCE="/usr/src/gtest"])
+
+  GTEST_CPPFLAGS="$GTEST_CPPFLAGS -I$GTEST_SOURCE"
+
+  AC_CHECK_FILES([$GTEST_SOURCE/src/gtest-all.cc]
+                 [$GTEST_SOURCE/src/gtest_main.cc],
+                 [have_gtest=yes],
+                 [have_gtest=no])
+
+  AS_IF([test "x$have_gtest_source" = xyes],
+        [AC_SUBST(GTEST_CPPFLAGS)]
+        [AC_SUBST(GTEST_SOURCE)])
+]) # CHECK_GTEST
 
=== modified file 'testsuite/Makefile.am'
--- testsuite/Makefile.am	2012-03-28 16:54:23 +0000
+++ testsuite/Makefile.am	2012-04-24 19:38:21 +0000
@@ -20,6 +20,6 @@
 # 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 #
 
-SUBDIRS = gtest geis-util libutouch-geis geis2 geis1 geistest
+SUBDIRS = gtest x11_mocks geis-util libutouch-geis geis2 geis1 geistest 
 
 EXTRA_DIST = recordings
 
=== modified file 'testsuite/geis2/Makefile.am'
--- testsuite/geis2/Makefile.am	2012-04-16 19:12:46 +0000
+++ testsuite/geis2/Makefile.am	2012-04-24 19:38:21 +0000
@@ -1,19 +1,15 @@
 #
-# @file testsuite/geis1/Makefile.am 
-# @brief automake recipe for the geis v1.0 testsuite unit testing directory
+# @file testsuite/geis2/Makefile.am 
+# @brief automake recipe for the geis v2.0 testsuite testing directory
 #
 
 test_targets = 
+
+##### check_geis2_api - Tests using Check C testing framework #####
+
 if HAVE_CHECK
   test_targets += check_geis2_api
 endif
-if ENABLE_INTEGRATION_TESTS
-  test_targets += gtest_geis2_api
-endif
-
-TESTS = $(test_targets)
-
-check_PROGRAMS = $(test_targets)
 
 check_geis2_api_SOURCES = \
 	check_attr.c \
@@ -42,6 +38,38 @@
 	$(top_builddir)/libutouch-geis/libutouch-geis.la \
 	$(CHECK_LIBS)
 
+#### gtest_geis2_grail_backend - Test for the GRAIL backend of Geis v2 API #####
+####                             using gtest                               #####
+
+if HAVE_GTEST
+  test_targets += gtest_geis2_grail_backend
+endif
+
+gtest_geis2_grail_backend_SOURCES = \
+	gtest_grail_backend.cpp \
+	gtest_gbe_direct_touch_coords.cpp
+
+gtest_geis2_grail_backend_CPPFLAGS = \
+	--std=c++0x \
+	-I$(top_srcdir) \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/libutouch-geis \
+	-I$(top_srcdir)/testsuite/gtest \
+	-I$(top_srcdir)/testsuite/x11_mocks \
+	-DTEST_ROOT_DIR=\"$(abs_top_srcdir)/testsuite/\"
+	$(GTEST_CFLAGS)
+
+gtest_geis2_grail_backend_LDADD = \
+	$(top_builddir)/testsuite/gtest/libgtest_geis.a \
+	$(top_builddir)/testsuite/x11_mocks/libx11_mocks.a \
+	$(top_builddir)/libutouch-geis/libutouch-geis.la
+
+#### gtest_geis2_api - Integration tests using xorg-gest and evemu #####
+
+if ENABLE_INTEGRATION_TESTS
+  test_targets += gtest_geis2_api
+endif
+
 gtest_geis2_api_SOURCES = \
 	gtest_attrs.cpp \
 	gtest_config.cpp \
@@ -73,3 +101,5 @@
 	geis2_api.log \
 	geis2_api.xml
 
+TESTS = $(test_targets)
+check_PROGRAMS = $(test_targets)
 
=== added file 'testsuite/geis2/gtest_gbe_direct_touch_coords.cpp'
--- testsuite/geis2/gtest_gbe_direct_touch_coords.cpp	1970-01-01 00:00:00 +0000
+++ testsuite/geis2/gtest_gbe_direct_touch_coords.cpp	2012-04-24 19:38:21 +0000
@@ -0,0 +1,295 @@
+#include "gtest_grail_backend.h"
+#include "x11_mocks.h"
+
+/*
+  Check that when a direct device (e.g. a touchscreen) is being used, the
+  position of a GeisTouch will be in window coordinates instead of input
+  device coordinates.
+
+  This means that the x an y values of a GeisTouch should come from
+  XIDeviceEvent::event_x and XIDeviceEvent::event_y and not from
+  XIDeviceEvent::valuators.values[0] and XIDeviceEvent::valuators.values[1],
+  like it's the case for indirect devices (such as trackpads).
+
+  Regression test for https://bugs.launchpad.net/bugs/984069
+ */
+
+class Geis2GrailBackend : public Geis2GrailBackendBase
+{
+ protected:
+  Geis2GrailBackend() : _subscription(nullptr) {}
+
+  void CreateXMockDevices();
+  void DestroyXMockDevices();
+  void SendXInput2Events();
+
+  virtual void OnEventInitComplete(GeisEvent event);
+  virtual void OnEventGestureBegin(GeisEvent event);
+
+  GeisSubscription _subscription;
+};
+
+void Geis2GrailBackend::CreateXMockDevices()
+{
+  xmock_devices_count = 1;
+  xmock_devices = (XIDeviceInfo*) calloc(xmock_devices_count,
+                                         sizeof(XIDeviceInfo));
+
+  XITouchClassInfo *touch_info = (XITouchClassInfo*) malloc(sizeof(XITouchClassInfo));
+  touch_info->type = XITouchClass;
+  touch_info->sourceid = 0;
+  touch_info->mode = XIDirectTouch;
+  touch_info->num_touches = 5;
+
+  XIValuatorClassInfo *x_axis_info = (XIValuatorClassInfo*) malloc(sizeof(XIValuatorClassInfo));
+  x_axis_info->type = XIValuatorClass;
+  x_axis_info->sourceid = 0;
+  x_axis_info->number = 0; /* identifies it as being the X axis */
+  x_axis_info->min = -500.0;
+  x_axis_info->max = 500.0;
+  x_axis_info->resolution = 3000; /* counts/meter */
+
+  XIValuatorClassInfo *y_axis_info = (XIValuatorClassInfo*) malloc(sizeof(XIValuatorClassInfo));
+  y_axis_info->type = XIValuatorClass;
+  y_axis_info->sourceid = 0;
+  y_axis_info->number = 1; /* identifies it as being the Y axis */
+  y_axis_info->min = -500.0;
+  y_axis_info->max = 500.0;
+  y_axis_info->resolution = 3000;
+
+  XIAnyClassInfo **classes = (XIAnyClassInfo**) malloc(sizeof(XIAnyClassInfo*)*3);
+  classes[0] = (XIAnyClassInfo*) touch_info;
+  classes[1] = (XIAnyClassInfo*) x_axis_info;
+  classes[2] = (XIAnyClassInfo*) y_axis_info;
+
+  xmock_devices[0].deviceid = 0;
+  xmock_devices[0].name = const_cast<char *>("Fake Touch Screen");
+  xmock_devices[0].use = XISlavePointer;
+  xmock_devices[0].attachment = 1;
+  xmock_devices[0].enabled = True;
+  xmock_devices[0].num_classes = 3;
+  xmock_devices[0].classes = classes;
+}
+
+void Geis2GrailBackend::DestroyXMockDevices()
+{
+  for (int i = 0; i < xmock_devices_count; ++i)
+  {
+    for (int j = 0; j < xmock_devices[i].num_classes; ++j)
+      free(xmock_devices[i].classes[j]);
+    free(xmock_devices[i].classes);
+  }
+  free(xmock_devices);
+}
+
+void Geis2GrailBackend::SendXInput2Events()
+{
+  XEvent event;
+  XGenericEventCookie *xcookie = 0;
+  XIDeviceEvent *device_event = 0;
+  XITouchOwnershipEvent *ownership_event = 0;
+  int serial = 0;
+
+  event.type = GenericEvent;
+  device_event = (XIDeviceEvent*)calloc(1, sizeof(XIDeviceEvent));
+  device_event->serial = serial++;
+  device_event->display = xmock_display;
+  device_event->extension = xmock_xi2_opcode;
+  device_event->evtype = XI_TouchBegin;
+  device_event->time = xmock_server_time;
+  device_event->deviceid = 0;
+  /* The source device that originally generated the event. */
+  device_event->sourceid = device_event->deviceid;
+  device_event->detail = 0; /* touch id */
+  device_event->root = DefaultRootWindow(xmock_display);
+  device_event->event = DefaultRootWindow(xmock_display);
+  device_event->child = 0;
+  device_event->root_x = 123.0f;
+  device_event->root_y = 456.0f;
+  device_event->event_x = device_event->root_x;
+  device_event->event_y = device_event->root_y;
+  device_event->valuators.mask_len = 2; /* two bytes */
+  device_event->valuators.mask = (unsigned char*) malloc(2);
+  XISetMask(device_event->valuators.mask, 0); /* X axis is present */
+  XISetMask(device_event->valuators.mask, 1); /* Y axis is present */
+  device_event->valuators.values = (double*) malloc(sizeof(double)*2);
+  device_event->valuators.values[0] = -200.0;
+  device_event->valuators.values[1] = -100.0;
+  xcookie = &event.xcookie;
+  xcookie->extension = xmock_xi2_opcode;
+  xcookie->evtype = XI_TouchBegin;
+  xcookie->data = device_event;
+  xmock_add_to_event_queue(&event);
+
+  event.type = GenericEvent;
+  device_event = (XIDeviceEvent*)calloc(1, sizeof(XIDeviceEvent));
+  device_event->serial = serial++;
+  device_event->display = xmock_display;
+  device_event->extension = xmock_xi2_opcode;
+  device_event->evtype = XI_TouchBegin;
+  device_event->time = xmock_server_time;
+  device_event->deviceid = 0;
+  device_event->sourceid = device_event->deviceid;
+  device_event->detail = 1; /* touch id */
+  device_event->root = DefaultRootWindow(xmock_display);
+  device_event->event = DefaultRootWindow(xmock_display);
+  device_event->child = 0;
+  device_event->root_x = 222.0f;
+  device_event->root_y = 456.0f;
+  device_event->event_x = device_event->root_x;
+  device_event->event_y = device_event->root_y;
+  device_event->valuators.mask_len = 2;
+  device_event->valuators.mask = (unsigned char*) malloc(2);
+  XISetMask(device_event->valuators.mask, 0);
+  XISetMask(device_event->valuators.mask, 1);
+  device_event->valuators.values = (double*) malloc(sizeof(double)*2);
+  device_event->valuators.values[0] = -150.0;
+  device_event->valuators.values[1] = -100.0;
+  xcookie = &event.xcookie;
+  xcookie->extension = xmock_xi2_opcode;
+  xcookie->evtype = XI_TouchBegin;
+  xcookie->data = device_event;
+  xmock_add_to_event_queue(&event);
+
+  xmock_server_time += 5;
+
+  event.type = GenericEvent;
+  ownership_event = (XITouchOwnershipEvent*)calloc(1, sizeof(XITouchOwnershipEvent));
+  ownership_event->type = GenericEvent;
+  ownership_event->serial = serial++;
+  ownership_event->display = xmock_display;
+  ownership_event->extension = xmock_xi2_opcode;
+  ownership_event->evtype = XI_TouchOwnership;
+  ownership_event->time = xmock_server_time;
+  ownership_event->deviceid = 0;
+  ownership_event->sourceid = ownership_event->deviceid;
+  ownership_event->touchid = 0;
+  ownership_event->root = DefaultRootWindow(xmock_display);
+  ownership_event->event = DefaultRootWindow(xmock_display);
+  ownership_event->child = 0;
+  xcookie = &event.xcookie;
+  xcookie->extension = xmock_xi2_opcode;
+  xcookie->evtype = XI_TouchOwnership;
+  xcookie->data = ownership_event;
+  xmock_add_to_event_queue(&event);
+
+  event.type = GenericEvent;
+  ownership_event = (XITouchOwnershipEvent*)calloc(1, sizeof(XITouchOwnershipEvent));
+  ownership_event->type = GenericEvent;
+  ownership_event->serial = serial++;
+  ownership_event->display = xmock_display;
+  ownership_event->extension = xmock_xi2_opcode;
+  ownership_event->evtype = XI_TouchOwnership;
+  ownership_event->time = xmock_server_time;
+  ownership_event->deviceid = 0;
+  ownership_event->sourceid = ownership_event->deviceid;
+  ownership_event->touchid = 1;
+  ownership_event->root = DefaultRootWindow(xmock_display);
+  ownership_event->event = DefaultRootWindow(xmock_display);
+  ownership_event->child = 0;
+  xcookie = &event.xcookie;
+  xcookie->extension = xmock_xi2_opcode;
+  xcookie->evtype = XI_TouchOwnership;
+  xcookie->data = ownership_event;
+  xmock_add_to_event_queue(&event);
+
+  event.type = GenericEvent;
+  device_event = (XIDeviceEvent*)calloc(1, sizeof(XIDeviceEvent));
+  device_event->serial = serial++;
+  device_event->display = xmock_display;
+  device_event->extension = xmock_xi2_opcode;
+  device_event->evtype = XI_TouchUpdate;
+  device_event->time = xmock_server_time;
+  device_event->deviceid = 0;
+  device_event->sourceid = device_event->deviceid;
+  device_event->detail = 0;
+  device_event->root = DefaultRootWindow(xmock_display);
+  device_event->event = DefaultRootWindow(xmock_display);
+  device_event->child = 0;
+  device_event->root_x = 123.0f;
+  device_event->root_y = 466.0f;
+  device_event->event_x = device_event->root_x;
+  device_event->event_y = device_event->root_y;
+  device_event->valuators.mask_len = 2; /* two bytes */
+  device_event->valuators.mask = (unsigned char*) malloc(2);
+  XISetMask(device_event->valuators.mask, 0);
+  XISetMask(device_event->valuators.mask, 1);
+  device_event->valuators.values = (double*) malloc(sizeof(double)*2);
+  device_event->valuators.values[0] = -200.0;
+  device_event->valuators.values[1] = -90.0;
+  xcookie = &event.xcookie;
+  xcookie->extension = xmock_xi2_opcode;
+  xcookie->evtype = XI_TouchUpdate;
+  xcookie->data = device_event;
+  xmock_add_to_event_queue(&event);
+
+  event.type = GenericEvent;
+  device_event = (XIDeviceEvent*)calloc(1, sizeof(XIDeviceEvent));
+  device_event->serial = serial++;
+  device_event->display = xmock_display;
+  device_event->extension = xmock_xi2_opcode;
+  device_event->evtype = XI_TouchUpdate;
+  device_event->time = xmock_server_time;
+  device_event->deviceid = 0;
+  device_event->sourceid = device_event->deviceid;
+  device_event->detail = 1; /* touch id */
+  device_event->root = DefaultRootWindow(xmock_display);
+  device_event->event = DefaultRootWindow(xmock_display);
+  device_event->child = 0;
+  device_event->root_x = 222.0f;
+  device_event->root_y = 466.0f;
+  device_event->event_x = device_event->root_x;
+  device_event->event_y = device_event->root_y;
+  device_event->valuators.mask_len = 2;
+  device_event->valuators.mask = (unsigned char*) malloc(2);
+  XISetMask(device_event->valuators.mask, 0);
+  XISetMask(device_event->valuators.mask, 1);
+  device_event->valuators.values = (double*) malloc(sizeof(double)*2);
+  device_event->valuators.values[0] = -150.0;
+  device_event->valuators.values[1] = -90.0;
+  xcookie = &event.xcookie;
+  xcookie->extension = xmock_xi2_opcode;
+  xcookie->evtype = XI_TouchUpdate;
+  xcookie->data = device_event;
+  xmock_add_to_event_queue(&event);
+}
+
+void Geis2GrailBackend::OnEventInitComplete(GeisEvent event)
+{
+  _subscription = CreateFilteredSubscription(
+      "My 2-touches Touch", 2, GEIS_GESTURE_TOUCH);
+  ASSERT_NE(nullptr, _subscription);
+
+  SendXInput2Events();
+}
+
+void Geis2GrailBackend::OnEventGestureBegin(GeisEvent event)
+{
+  GeisAttr attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_TOUCHSET);
+  GeisTouchSet geis_touch_set = (GeisTouchSet) geis_attr_value_to_pointer(attr);
+
+  TouchSet touch_set(geis_touch_set);
+
+  /* check that there are two touch points and that they are in window coordinates
+     (instead of input device coordinates) */
+  ASSERT_EQ(2, touch_set.size());
+  ASSERT_TRUE(touch_set.contains(123.0f, 456.0f));
+  ASSERT_TRUE(touch_set.contains(222.0f, 456.0f));
+}
+
+TEST_F(Geis2GrailBackend, DirectDeviceTouchCoords)
+{
+  CreateXMockDevices();
+
+  Geis geis = geis_new(GEIS_INIT_UTOUCH_GRAIL_BACKEND,
+                       nullptr);
+  ASSERT_NE(nullptr, geis);
+
+  Run(geis);
+
+  if (_subscription)
+    geis_subscription_delete(_subscription);
+  geis_delete(geis);
+
+  DestroyXMockDevices();
+}
 
=== added file 'testsuite/geis2/gtest_grail_backend.cpp'
--- testsuite/geis2/gtest_grail_backend.cpp	1970-01-01 00:00:00 +0000
+++ testsuite/geis2/gtest_grail_backend.cpp	2012-04-24 19:38:21 +0000
@@ -0,0 +1,134 @@
+#include "gtest_grail_backend.h"
+#include "x11_mocks.h"
+#include <iostream>
+
+#define ADD_FAILURE_AND_RETURN(ret) \
+  {\
+    ADD_FAILURE();\
+    return ret;\
+  }\
+
+Touch::Touch(GeisTouch geis_touch)
+{
+  GeisAttr attr = geis_touch_attr_by_name(geis_touch, GEIS_TOUCH_ATTRIBUTE_X);
+  x = geis_attr_value_to_float(attr);
+
+  attr = geis_touch_attr_by_name(geis_touch, GEIS_TOUCH_ATTRIBUTE_Y);
+  y = geis_attr_value_to_float(attr);
+
+  attr = geis_touch_attr_by_name(geis_touch, GEIS_TOUCH_ATTRIBUTE_ID);
+  id = geis_attr_value_to_integer(attr);
+}
+
+TouchSet::TouchSet(GeisTouchSet geis_touch_set)
+{
+  int count = geis_touchset_touch_count(geis_touch_set);
+  for (int i = 0; i < count; ++i)
+    push_back(Touch(geis_touchset_touch(geis_touch_set, i)));
+}
+
+bool TouchSet::contains(float x, float y)
+{
+  for (auto touch : *this)
+  {
+    if (touch.x == x && touch.y == y)
+      return true;
+  }
+  return false;
+}
+
+GeisSubscription Geis2GrailBackendBase::CreateFilteredSubscription(
+    GeisString name, GeisSize num_touches, GeisString gesture_class)
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  GeisFilter filter = nullptr;
+  GeisSubscription sub = nullptr;
+
+  sub = geis_subscription_new(_geis, name, GEIS_SUBSCRIPTION_NONE);
+
+  filter = geis_filter_new(_geis, "filter");
+  if (filter == nullptr) ADD_FAILURE_AND_RETURN(nullptr);
+
+  status = geis_filter_add_term(filter,
+      GEIS_FILTER_CLASS,
+      GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, gesture_class,
+      GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, num_touches,
+      nullptr);
+  if (status != GEIS_STATUS_SUCCESS) ADD_FAILURE_AND_RETURN(nullptr);
+
+  status = geis_filter_add_term(filter,
+      GEIS_FILTER_REGION,
+      GEIS_REGION_ATTRIBUTE_WINDOWID, GEIS_FILTER_OP_EQ,
+      DefaultRootWindow(xmock_display),
+      nullptr);
+  if (status != GEIS_STATUS_SUCCESS) ADD_FAILURE_AND_RETURN(nullptr);
+
+  status = geis_subscription_add_filter(sub, filter);
+  if (status != GEIS_STATUS_SUCCESS) ADD_FAILURE_AND_RETURN(nullptr);
+
+  status = geis_subscription_activate(sub);
+  if (status != GEIS_STATUS_SUCCESS) ADD_FAILURE_AND_RETURN(nullptr);
+
+  return sub;
+}
+
+bool Geis2GrailBackendBase::DispatchAndProcessEvents()
+{
+  bool got_events = false;
+  GeisEvent event;
+  GeisStatus status;
+
+  status = geis_dispatch_events(_geis);
+  if (status != GEIS_STATUS_SUCCESS) ADD_FAILURE_AND_RETURN(false);
+
+  status = geis_next_event(_geis, &event);
+  if (status != GEIS_STATUS_SUCCESS
+      && status != GEIS_STATUS_CONTINUE
+      && status != GEIS_STATUS_EMPTY)
+    ADD_FAILURE_AND_RETURN(false);
+
+  if (status == GEIS_STATUS_SUCCESS || status == GEIS_STATUS_CONTINUE)
+    got_events = true;
+
+  while (status == GEIS_STATUS_CONTINUE || status == GEIS_STATUS_SUCCESS)
+  {
+    switch (geis_event_type(event))
+    {
+      case GEIS_EVENT_INIT_COMPLETE:
+        OnEventInitComplete(event);
+        break;
+      case GEIS_EVENT_GESTURE_BEGIN:
+        OnEventGestureBegin(event);
+        break;
+      case GEIS_EVENT_GESTURE_UPDATE:
+        OnEventGestureUpdate(event);
+        break;
+      case GEIS_EVENT_GESTURE_END:
+        OnEventGestureEnd(event);
+        break;
+      default:
+        break;
+    }
+    geis_event_delete(event);
+    status = geis_next_event(_geis, &event);
+  }
+
+  return got_events;
+}
+
+void Geis2GrailBackendBase::Run(Geis geis)
+{
+  _geis = geis;
+
+  bool got_events;
+  do
+  {
+    got_events = DispatchAndProcessEvents();
+  } while (got_events);
+}
+
+int main(int argc, char **argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
 
=== added file 'testsuite/geis2/gtest_grail_backend.h'
--- testsuite/geis2/gtest_grail_backend.h	1970-01-01 00:00:00 +0000
+++ testsuite/geis2/gtest_grail_backend.h	2012-04-24 19:38:21 +0000
@@ -0,0 +1,52 @@
+#ifndef GTEST_GRAIL_BACKEND_H
+#define GTEST_GRAIL_BACKEND_H
+
+#include <gtest/gtest.h>
+#include <geis/geis.h>
+#include <vector>
+
+class Touch
+{
+ public:
+  Touch(GeisTouch geis_touch);
+
+  int id;
+  float x;
+  float y;
+};
+
+class TouchSet : public std::vector<Touch>
+{
+ public:
+  TouchSet(GeisTouchSet geis_touch_set);
+  bool contains(float x, float y);
+};
+
+class Geis2GrailBackendBase : public ::testing::Test
+{
+ protected:
+  Geis2GrailBackendBase() : _geis(nullptr) {}
+  virtual ~Geis2GrailBackendBase() {}
+
+  /* Dispatch and process Geis events in a loop until there are no more
+     events. */
+  void Run(Geis geis);
+
+
+  /* Creates (and activates) a GeisSubscription with the given name
+     and with filters for the given number of touches and gesture class. */
+  GeisSubscription CreateFilteredSubscription(GeisString name,
+                                              GeisSize num_touches,
+                                              GeisString gesture_class);
+
+  virtual void OnEventInitComplete(GeisEvent event) {}
+  virtual void OnEventGestureBegin(GeisEvent event) {}
+  virtual void OnEventGestureUpdate(GeisEvent event) {}
+  virtual void OnEventGestureEnd(GeisEvent event) {}
+
+ private:
+  Geis _geis;
+  bool DispatchAndProcessEvents();
+};
+
+#endif // GTEST_GRAIL_BACKEND_H
 
=== modified file 'testsuite/gtest/Makefile.am'
--- testsuite/gtest/Makefile.am	2012-03-30 11:51:09 +0000
+++ testsuite/gtest/Makefile.am	2012-04-24 19:38:21 +0000
@@ -3,26 +3,31 @@
 # @brief automake recipe for the geis gtest testsuite harness directory
 #
 
-if ENABLE_INTEGRATION_TESTS
+if HAVE_GTEST
   check_LIBRARIES = libgtest_geis.a
 endif
 
-libgtest_geis_a_SOURCES = \
-	gtest_evemu_device.h   gtest_evemu_device.cpp \
-	gtest_geis_fixture.h   gtest_geis_fixture.cpp \
-	gtest_geis1_fixture.h   gtest_geis1_fixture.cpp 
-
 nodist_libgtest_geis_a_SOURCES = \
-	$(XORG_GTEST_SOURCE)/src/xorg-gtest-all.cpp \
 	$(GTEST_SOURCE)/src/gtest-all.cc
 
 libgtest_geis_a_CPPFLAGS = \
-	--std=c++0x \
 	-I$(top_srcdir) \
 	-I$(top_srcdir)/include \
 	-I$(top_srcdir)/libutouch-geis \
 	-DTEST_ROOT_DIR=\"$(abs_top_srcdir)/testsuite/\" \
+	$(GTEST_CPPFLAGS)
+
+if ENABLE_INTEGRATION_TESTS
+libgtest_geis_a_SOURCES = \
+	gtest_evemu_device.h   gtest_evemu_device.cpp \
+	gtest_geis_fixture.h   gtest_geis_fixture.cpp \
+	gtest_geis1_fixture.h   gtest_geis1_fixture.cpp 
+
+nodist_libgtest_geis_a_SOURCES += \
+	$(XORG_GTEST_SOURCE)/src/xorg-gtest-all.cpp
+
+libgtest_geis_a_CPPFLAGS += \
 	$(XORG_GTEST_CPPFLAGS) \
-	$(GTEST_CPPFLAGS) \
 	$(EVEMU_CFLAGS) \
 	$(XORG_GTEST_CFLAGS)
+endif
 
=== added directory 'testsuite/x11_mocks'
=== added file 'testsuite/x11_mocks/Makefile.am'
--- testsuite/x11_mocks/Makefile.am	1970-01-01 00:00:00 +0000
+++ testsuite/x11_mocks/Makefile.am	2012-04-24 19:38:21 +0000
@@ -0,0 +1,13 @@
+#
+# @file testsuite/x11_mocks/Makefile.am 
+# @brief automake recipe for the X11 mockups
+#
+
+check_LIBRARIES = libx11_mocks.a
+
+libx11_mocks_a_SOURCES = \
+	x11_mocks.c
+
+libx11_mocks_a_CFLAGS = \
+	--std=c99
+
 
=== added file 'testsuite/x11_mocks/x11_mocks.c'
--- testsuite/x11_mocks/x11_mocks.c	1970-01-01 00:00:00 +0000
+++ testsuite/x11_mocks/x11_mocks.c	2012-04-24 19:38:21 +0000
@@ -0,0 +1,406 @@
+/* needed to break into 'Display' struct internals. */
+#define XLIB_ILLEGAL_ACCESS
+#include <X11/Xlib.h>
+
+#include <geis/geis.h>
+
+#include "x11_mocks.h"
+
+#include <sys/eventfd.h>
+#include <stdio.h>
+#include <unistd.h>
+
+int xmock_xi2_opcode = 42;
+int xmock_xi2_event_base = 40000;
+int xmock_xi2_error_base = 40000;
+int xmock_xsync_event_base = 50000;
+int xmock_xsync_error_base = 50000;
+Display *xmock_display = NULL;
+uint64_t xmock_server_time = 0;
+
+XIDeviceInfo *xmock_devices = NULL;
+int xmock_devices_count = 0;
+
+/* id to be used for the next alarm that gets created */
+XSyncAlarm _xmock_next_alarm = 1;
+
+struct EventQueueItem
+{
+  XEvent event;
+  struct EventQueueItem *next;
+} *xmock_event_queue = NULL;
+
+#define XMOCK_PRINT_FUNCTION _xmock_print_function(__func__)
+void _xmock_print_function(const char *function)
+{
+  static int debug_enabled = -1;
+  if (debug_enabled == -1)
+  {
+    if (getenv("XMOCK_DEBUG"))
+      debug_enabled = 1;
+    else
+      debug_enabled = 0;
+  }
+
+  if (debug_enabled)
+    printf("XMOCK: %s mock called.\n", function);
+}
+
+void xmock_add_to_event_queue(const XEvent *event)
+{
+  struct EventQueueItem *new_item = malloc(sizeof(struct EventQueueItem));
+  new_item->event = *event;
+  new_item->next = NULL;
+
+  if (!xmock_event_queue)
+  {
+    xmock_event_queue = new_item;
+  }
+  else
+  {
+    struct EventQueueItem *last_item = xmock_event_queue;
+    while (last_item->next)
+    {
+      last_item = last_item->next;
+    }
+    last_item->next = new_item;
+  }
+
+  static const uint64_t num = 1;
+  if (write(xmock_display->fd, &num, sizeof(num)) != sizeof(num))
+  {
+    fprintf(stderr, "ERROR: failed to update eventfd instance,\n");
+    exit(1);
+  }
+}
+
+Display *XOpenDisplay(_Xconst char *display_name)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display_name;
+
+  Display *display = (Display*)calloc(1, sizeof(Display));
+  display->fd = eventfd(0, EFD_NONBLOCK);
+  display->default_screen = 0;
+  display->nscreens = 1;
+  display->screens = (Screen*)calloc(1, sizeof(Screen));
+  display->screens[0].root = 1;
+
+  xmock_display = display;
+
+  return display;
+}
+
+int XCloseDisplay(Display *display)
+{
+  XMOCK_PRINT_FUNCTION;
+
+  close(display->fd);
+  free(display->screens);
+  free(display);
+
+  xmock_display = NULL;
+
+  return 0;
+}
+
+int XSync(Display *display, Bool discard)
+{
+  (void)display;
+  (void)discard;
+  return 0;
+}
+
+int XFlush(Display *display)
+{
+  (void)display;
+  return 0;
+}
+
+Bool XQueryExtension(Display *display, const char *name,
+    int *major_opcode_return, int *first_event_return, int *first_error_return)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+  (void)name; /* assuming name == "XInputExtension" */
+
+  *major_opcode_return = xmock_xi2_opcode;
+  *first_event_return = xmock_xi2_event_base;
+  *first_error_return = xmock_xi2_error_base;
+
+  return True;
+}
+
+int XPending(Display *display)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+
+  int pending_events_count = 0;
+  struct EventQueueItem *item = xmock_event_queue;
+  while (item != NULL)
+  {
+    ++pending_events_count;
+    item = item->next;
+  }
+  return pending_events_count;
+}
+
+int XNextEvent(Display *display, XEvent *event_return)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+
+
+  if (xmock_event_queue)
+  {
+    uint64_t num = 1;
+    ssize_t bytes_read = read(xmock_display->fd, &num, sizeof(num));
+    (void)bytes_read;
+
+    *event_return = xmock_event_queue->event;
+
+    struct EventQueueItem *removed_item = xmock_event_queue;
+    xmock_event_queue = xmock_event_queue->next;
+    free(removed_item);
+  }
+  else
+  {
+    /* not going to block... */
+  }
+
+  return 0;
+}
+
+Bool XGetEventData(Display *display, XGenericEventCookie *cookie)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+  (void)cookie;
+  return True;
+}
+
+void XFreeEventData(Display *display, XGenericEventCookie *cookie)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+
+  if (cookie->data && cookie->extension == xmock_xi2_opcode)
+  {
+    if (cookie->evtype == XI_TouchBegin
+        || cookie->evtype == XI_TouchUpdate
+        || cookie->evtype == XI_TouchEnd)
+    {
+      XIDeviceEvent *device_event = (XIDeviceEvent*) cookie->data;
+      free(device_event->valuators.mask);
+      free(device_event->valuators.values);
+    }
+    free(cookie->data);
+  }
+}
+
+XIDeviceInfo* XIQueryDevice(Display * display,
+                            int deviceid,
+                            int * ndevices_return)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+  (void)deviceid; /* assuming XIAllDevices */
+
+  XIDeviceInfo *devices;
+
+  devices = calloc(xmock_devices_count, sizeof(XIDeviceInfo));
+
+  for (int i = 0; i < xmock_devices_count; ++i) {
+    devices[i] = xmock_devices[i];
+  }
+
+  *ndevices_return = xmock_devices_count;
+
+  return devices;
+}
+
+void XIFreeDeviceInfo(XIDeviceInfo *info)
+{
+  XMOCK_PRINT_FUNCTION;
+  free(info);
+}
+
+Status XIQueryVersion(Display *display,
+                      int *major_version_inout,
+                      int *minor_version_inout)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+  *major_version_inout = 2;
+  *minor_version_inout = 2;
+  return Success;
+}
+
+Status XISelectEvents(Display *display,
+                      Window win,
+                      XIEventMask *masks,
+                      int num_masks)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+  (void)win;
+  (void)masks;
+  (void)num_masks;
+  return Success;
+}
+
+int XIGrabTouchBegin(
+    Display*            display,
+    int                 deviceid,
+    Window              grab_window,
+    int                 owner_events,
+    XIEventMask         *mask,
+    int                 num_modifiers,
+    XIGrabModifiers     *modifiers_inout)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+  (void)deviceid;
+  (void)grab_window;
+  (void)owner_events;
+  (void)mask;
+
+  for (int i = 0; i < num_modifiers; ++i)
+  {
+    modifiers_inout[i].status = XIGrabSuccess;
+  }
+
+  return 0;
+}
+
+Status XIUngrabTouchBegin(
+    Display*            display,
+    int                 deviceid,
+    Window              grab_window,
+    int                 num_modifiers,
+    XIGrabModifiers     *modifiers)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+  (void)deviceid;
+  (void)grab_window;
+  (void)num_modifiers;
+  (void)modifiers;
+  return Success;
+}
+
+Status XIAllowTouchEvents(
+    Display*            display,
+    int                 deviceid,
+    unsigned int        touchid,
+    Window              grab_window,
+    int                 event_mode)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)display;
+  (void)deviceid;
+  (void)touchid;
+  (void)grab_window;
+  (void)event_mode;
+  return Success;
+}
+
+Status XSyncQueryExtension(
+    Display* dpy,
+    int* event_base_return,
+    int* error_base_return)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)dpy;
+  *event_base_return = xmock_xsync_event_base;
+  *error_base_return = xmock_xsync_error_base;
+  return True;
+}
+
+Status XSyncInitialize(
+    Display* dpy,
+    int* major_version_return,
+    int* minor_version_return)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)dpy;
+  *major_version_return = 1;
+  *minor_version_return = 0;
+  return True;
+}
+
+XSyncSystemCounter *XSyncListSystemCounters(
+    Display* dpy,
+    int* n_counters_return)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)dpy;
+  *n_counters_return = 1;
+
+  XSyncSystemCounter *sys_counter = malloc(sizeof(XSyncSystemCounter));
+  sys_counter->name = "SERVERTIME";
+  sys_counter->counter = 1;
+  sys_counter->resolution.hi = 1;
+  sys_counter->resolution.lo = 0;
+  return sys_counter;
+}
+
+void XSyncFreeSystemCounterList(XSyncSystemCounter* list)
+{
+  XMOCK_PRINT_FUNCTION;
+  free(list);
+}
+
+XSyncAlarm XSyncCreateAlarm(
+    Display* dpy,
+    unsigned long values_mask,
+    XSyncAlarmAttributes* values)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)dpy;
+
+  XSyncAlarmNotifyEvent alarm_notify;
+  alarm_notify.type = xmock_xsync_event_base + XSyncAlarmNotify;
+  alarm_notify.alarm = _xmock_next_alarm;
+  alarm_notify.counter_value = values->trigger.wait_value;
+  xmock_add_to_event_queue((XEvent*)&alarm_notify);
+
+  XSyncValue time = values->trigger.wait_value;
+  uint64_t timeout = (uint64_t)XSyncValueHigh32(time) << 32
+                   | (uint64_t)XSyncValueLow32(time);
+  xmock_server_time = timeout + 1;
+
+  return _xmock_next_alarm++;
+}
+
+Status XSyncDestroyAlarm(
+    Display* dpy,
+    XSyncAlarm alarm)
+{
+  XMOCK_PRINT_FUNCTION;
+  (void)dpy;
+  (void)alarm;
+}
+
+void XSyncIntsToValue(
+    XSyncValue* pv,
+    unsigned int l,
+    int h)
+{
+  XMOCK_PRINT_FUNCTION;
+  pv->hi = h;
+  pv->lo = l;
+}
+
+int XSyncValueHigh32(XSyncValue v)
+{
+  XMOCK_PRINT_FUNCTION;
+  return v.hi;
+}
+
+unsigned int XSyncValueLow32(XSyncValue v)
+{
+  XMOCK_PRINT_FUNCTION;
+  return v.lo;
+}
 
=== added file 'testsuite/x11_mocks/x11_mocks.h'
--- testsuite/x11_mocks/x11_mocks.h	1970-01-01 00:00:00 +0000
+++ testsuite/x11_mocks/x11_mocks.h	2012-04-24 19:38:21 +0000
@@ -0,0 +1,34 @@
+#ifndef X11_MOCKS_H
+#define X11_MOCKS_H
+
+#include <X11/Xlib.h>
+#include <X11/extensions/XInput2.h>
+#include <X11/extensions/sync.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int xmock_xi2_opcode;
+extern int xmock_xi2_event_base;
+extern int xmock_xi2_error_base;
+extern int xmock_xsync_event_base;
+extern int xmock_xsync_error_base;
+extern Display *xmock_display;
+extern uint64_t xmock_server_time;
+
+/* to be filled by user. A copy of it will be returned by each
+   XIQueryDevice call  */
+extern XIDeviceInfo *xmock_devices;
+extern int xmock_devices_count;
+
+/* Adds the given XEvent to the xmock event queue.
+   The Diplay connection will signal that there are
+   pending events */
+extern void xmock_add_to_event_queue(const XEvent* event);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif