Merge lp:~dandrader/frame/lp1025297 into lp:frame

[Daniel d'Andrada]

Fixes bug 1025297.

Patch is big because it's adding all the infrastructure needed for mocks-based tests.

[Chase Douglas (chasedouglas)]

* The added gtest.m4 file shouldn't have a serial number since it's not distributed anywhere. The serial number implies that it was copied in from some other distribution.

* The Makefile-xorg-gtest.am removal should be reverted. I think you removed it because of issues with the wrong files being included when compiling xorg-gtest itself. This has been fixed in the Makefile-xorg-gtest.am shipped upstream. It has not been fixed in Ubuntu yet, but you can download the change from here:

http://cgit.freedesktop.org/xorg/test/xorg-gtest/commit/?id=3fefcde53f8b69b37baeec61265f2e0190713fe6

Everything else looks good!

review: Needs Fixing

[lp:~dandrader/frame/lp1025297]

86. By Daniel d'Andrada on 2012-07-18

Remove serial number from m4/gtest.m4

The serial number implies that it was copied in from some other distribution,
but it's not the case here.

87. By Daniel d'Andrada on 2012-07-18

Use Makefile-xorg-gtest.am from latest upstream xorg-gtest

[Daniel d'Andrada (dandrader)]

> * The added gtest.m4 file shouldn't have a serial number since it's not
> distributed anywhere. The serial number implies that it was copied in from
> some other distribution.
>
> * The Makefile-xorg-gtest.am removal should be reverted. I think you removed
> it because of issues with the wrong files being included when compiling xorg-
> gtest itself. This has been fixed in the Makefile-xorg-gtest.am shipped
> upstream. It has not been fixed in Ubuntu yet, but you can download the change
> from here:

Done.

[Chase Douglas (chasedouglas)]

Looks good!

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2012-03-28 00:45:08 +0000
+++ .bzrignore	2012-07-18 13:01:21 +0000
@@ -26,9 +26,10 @@
 m4/lt~obsolete.m4
 m4/pkg.m4
 stamp-*
-test/check-c-compile
-test/check-cxx-compile
-test/check-frame
+test/regular/check-c-compile
+test/regular/check-cxx-compile
+test/regular/check-regular
+test/integration/check-integration
 tools/utouch-frame-test-mtdev
 tools/utouch-frame-test-mtdev.1
 tools/utouch-frame-test-xi2
 
=== modified file 'Makefile.am'
--- Makefile.am	2012-03-31 02:31:54 +0000
+++ Makefile.am	2012-07-18 13:01:21 +0000
@@ -9,8 +9,6 @@
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = utouch-frame.pc
 
-INCLUDES = $(top_srcdir)/include/
-
 if HAVE_GCOV
   .PHONY: clean-gcda
   clean-gcda:
 
=== modified file 'configure.ac'
--- configure.ac	2012-06-18 18:28:21 +0000
+++ configure.ac	2012-07-18 13:01:21 +0000
@@ -25,7 +25,8 @@
 AC_PROG_CXX
 AC_PROG_INSTALL
 
-PKG_CHECK_MODULES([EVEMU], [utouch-evemu >= 1.0.5])
+PKG_CHECK_MODULES([EVEMU], [utouch-evemu >= 1.0.5], [have_evemu=yes])
+AM_CONDITIONAL([HAVE_EVEMU], [test "x$have_evemu" = xyes])
 
 PKG_CHECK_MODULES(XINPUT, x11 xext xorg-server [xi >= 1.5.99.1] [inputproto >= 2.1.99.6])
 
@@ -34,6 +35,11 @@
 AS_IF([test "x$ASCIIDOC" = "x"],
       [AC_MSG_WARN([asciidoc not installed, man pages will not be created])])
 
+
+# Check for Google C++ Testing Framework
+CHECK_GTEST()
+AM_CONDITIONAL([HAVE_GTEST], [test "x$have_gtest" = xyes])
+
 # Check for TDD tools
 AC_ARG_ENABLE([integration-tests],
               [AS_HELP_STRING([--enable-integration-tests],
@@ -43,13 +49,11 @@
 
 AS_IF([test "x$enable_integration_tests" != xno],
       [CHECK_XORG_GTEST(
-          [AC_MSG_NOTICE([xorg-gtest is available, tests will be built])],
+          [AC_MSG_NOTICE([xorg-gtest is available, integration tests will be built])],
           [AC_MSG_WARN([xorg-gtest is not available, tests will not be built])])])
 
 AM_CONDITIONAL([ENABLE_INTEGRATION_TESTS], [test "x$have_xorg_gtest" = xyes])
 
-AM_CONDITIONAL([HAVE_GTEST], [test "x$have_xorg_gtest" = xyes])
-
 AC_SUBST([GTEST_LDFLAGS])
 AC_SUBST([GTEST_CXXFLAGS])
 
@@ -66,6 +70,10 @@
                  doc/Makefile
                  src/Makefile
                  test/Makefile
+                 test/gtest/Makefile
+                 test/integration/Makefile
+                 test/regular/Makefile
+                 test/x11_mocks/Makefile
                  tools/Makefile
                  utouch-frame.pc])
 
 
=== added file 'm4/gtest.m4'
--- m4/gtest.m4	1970-01-01 00:00:00 +0000
+++ m4/gtest.m4	2012-07-18 13:01:21 +0000
@@ -0,0 +1,51 @@
+# 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" = xyes],
+        [GTEST_LIBS=-lpthread
+         AC_SUBST(GTEST_CPPFLAGS)
+         AC_SUBST(GTEST_SOURCE)
+         AC_SUBST(GTEST_LIBS)])
+]) # CHECK_GTEST
 
=== modified file 'src/x11/window_x11.cpp'
--- src/x11/window_x11.cpp	2012-06-18 18:28:21 +0000
+++ src/x11/window_x11.cpp	2012-07-18 13:01:21 +0000
@@ -36,8 +36,6 @@
     : window_(window),
       display_(display),
       device_(static_cast<UFDeviceX11*>(device.get())),
-      touches_to_accept_(),
-      touches_to_reject_(),
       unaccepted_unrejected_touches_() {
 }
 
@@ -167,55 +165,37 @@
 
   current_frame_ = *frame;
 
-  if (touches_to_accept_.count(event->touchid)) {
-    XIAllowTouchEvents(display_, device_->master_id(), event->touchid, window_,
-                       XIAcceptTouch);
-    touches_to_accept_.erase(event->touchid);
-  } else if (touches_to_reject_.count(event->touchid)) {
-    XIAllowTouchEvents(display_, device_->master_id(), event->touchid, window_,
-                       XIRejectTouch);
-    touches_to_reject_.erase(event->touchid);
-  } else {
-    unaccepted_unrejected_touches_.insert(event->touchid);
-  }
+  unaccepted_unrejected_touches_.insert(event->touchid);
 
   return true;
 }
 
 UFStatus WindowX11::AcceptTouch(UFTouchId touch_id) {
-  if (current_frame_->IsTouchOwned(touch_id)) {
-    if (XIAllowTouchEvents(display_, device_->master_id(), touch_id, window_,
-                           XIAcceptTouch))
-      return UFStatusErrorGeneric;
-
-    /* Flush output buffer so touches are actually accepted ASAP. The server
-     * can't perform pointer emulation while the currently emulated touch is
-     * still potentially active for pointer emulation. */
-    XFlush(display_);
-
-    unaccepted_unrejected_touches_.erase(touch_id);
-  } else {
-    touches_to_accept_.insert(touch_id);
-  }
+  if (XIAllowTouchEvents(display_, device_->master_id(), touch_id, window_,
+                         XIAcceptTouch))
+    return UFStatusErrorGeneric;
+
+  /* Flush output buffer so touches are actually accepted ASAP. The server
+   * can't perform pointer emulation while the currently emulated touch is
+   * still potentially active for pointer emulation. */
+  XFlush(display_);
+
+  unaccepted_unrejected_touches_.erase(touch_id);
 
   return UFStatusSuccess;
 }
 
 UFStatus WindowX11::RejectTouch(UFTouchId touch_id) {
-  if (current_frame_->IsTouchOwned(touch_id)) {
-    if (XIAllowTouchEvents(display_, device_->master_id(), touch_id, window_,
-                           XIRejectTouch))
-      return UFStatusErrorGeneric;
-
-    /* Flush output buffer so touches are actually rejected ASAP. The server
-     * can't perform pointer emulation while the currently emulated touch is
-     * still potentially active for pointer emulation. */
-    XFlush(display_);
-
-    unaccepted_unrejected_touches_.erase(touch_id);
-  } else {
-    touches_to_reject_.insert(touch_id);
-  }
+  if (XIAllowTouchEvents(display_, device_->master_id(), touch_id, window_,
+                         XIRejectTouch))
+    return UFStatusErrorGeneric;
+
+  /* Flush output buffer so touches are actually rejected ASAP. The server
+   * can't perform pointer emulation while the currently emulated touch is
+   * still potentially active for pointer emulation. */
+  XFlush(display_);
+
+  unaccepted_unrejected_touches_.erase(touch_id);
 
   return UFStatusSuccess;
 }
 
=== modified file 'src/x11/window_x11.h'
--- src/x11/window_x11.h	2012-06-18 18:28:21 +0000
+++ src/x11/window_x11.h	2012-07-18 13:01:21 +0000
@@ -57,8 +57,6 @@
   ::Window window_;
   Display* display_;
   UFDeviceX11* device_;
-  std::set<UFTouchId> touches_to_accept_;
-  std::set<UFTouchId> touches_to_reject_;
   std::set<UFTouchId> unaccepted_unrejected_touches_;
 };
 
 
=== removed file 'test/Makefile-xorg-gtest.am'
--- test/Makefile-xorg-gtest.am	2012-06-18 18:28:21 +0000
+++ test/Makefile-xorg-gtest.am	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-# 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.
-#
-
-XORG_GTEST_BUILD_LIBS = \
-	libgtest.a \
-	libgtest_main.a \
-	libxorg-gtest.a \
-	libxorg-gtest_main.a
-
-nodist_libgtest_a_SOURCES = $(GTEST_SOURCE)/src/gtest-all.cc
-libgtest_a_CPPFLAGS = $(GTEST_CPPFLAGS) $(AM_CPPFLAGS) -w
-libgtest_a_CXXFLAGS = $(GTEST_CXXFLAGS) $(AM_CXXFLAGS)
-
-nodist_libgtest_main_a_SOURCES = $(GTEST_SOURCE)/src/gtest_main.cc
-libgtest_main_a_CPPFLAGS = $(GTEST_CPPFLAGS) $(AM_CPPFLAGS) -w
-libgtest_main_a_CXXFLAGS = $(GTEST_CXXFLAGS) $(AM_CXXFLAGS)
-
-nodist_libxorg_gtest_a_SOURCES = $(XORG_GTEST_SOURCE)/src/xorg-gtest-all.cpp
-libxorg_gtest_a_CPPFLAGS = \
-	$(XORG_GTEST_CPPFLAGS) \
-	$(GTEST_CPPFLAGS) \
-	$(AM_CPPFLAGS) \
-	-iquote$(XORG_GTEST_SOURCE) \
-	-w
-libxorg_gtest_a_CXXFLAGS = \
-	$(XORG_GTEST_CXXFLAGS) \
-	$(GTEST_CXXFLAGS) \
-	$(AM_CPPFLAGS)
-
-nodist_libxorg_gtest_main_a_SOURCES = \
-	$(XORG_GTEST_SOURCE)/src/xorg-gtest_main.cpp
-libxorg_gtest_main_a_CPPFLAGS = \
-	$(XORG_GTEST_CPPFLAGS) \
-	$(GTEST_CPPFLAGS) \
-	$(AM_CPPFLAGS) \
-	-iquote$(XORG_GTEST_SOURCE) \
-	-w
-libxorg_gtest_main_a_CXXFLAGS = \
-	$(XORG_GTEST_CXXFLAGS) \
-	$(GTEST_CXXFLAGS) \
-	$(AM_CXXFLAGS)
-
-XORG_GTEST_LIBS = libxorg-gtest.a libgtest.a -lpthread $(X11_LIBS)
-XORG_GTEST_MAIN_LIBS = libxorg-gtest_main.a
 
=== added file 'test/Makefile.am'
--- test/Makefile.am	1970-01-01 00:00:00 +0000
+++ test/Makefile.am	2012-07-18 13:01:21 +0000
@@ -0,0 +1,5 @@
+SUBDIRS = gtest x11_mocks regular
+
+if ENABLE_INTEGRATION_TESTS
+SUBDIRS += integration
+endif
 
=== added file 'test/README'
--- test/README	1970-01-01 00:00:00 +0000
+++ test/README	2012-07-18 13:01:21 +0000
@@ -0,0 +1,11 @@
+Directory structure
+===================
+
+- integration
+    Here goes all integration tests.
+    Those tests take time to run and rely on or interact with other processes
+    beyond the test program itself.
+
+- regular
+    Here goes tests that are fast to run and don't rely on the run-time
+    environment (such as other processes, files, etc).
 
=== added directory 'test/gtest'
=== added file 'test/gtest/Makefile-xorg-gtest.am'
--- test/gtest/Makefile-xorg-gtest.am	1970-01-01 00:00:00 +0000
+++ test/gtest/Makefile-xorg-gtest.am	2012-07-18 13:01:21 +0000
@@ -0,0 +1,68 @@
+# 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.
+#
+
+XORG_GTEST_BUILD_LIBS = \
+	libgtest.a \
+	libgtest_main.a \
+	libxorg-gtest.a \
+	libxorg-gtest_main.a
+
+# Here and below we compile without warnings (-w) because the projects using
+# xorg-gtest will not want to see warnings or fail to build due to warnings in
+# gtest or xorg-gtest.
+nodist_libgtest_a_SOURCES = $(GTEST_SOURCE)/src/gtest-all.cc
+libgtest_a_CPPFLAGS = --std=c++0x $(GTEST_CPPFLAGS) $(AM_CPPFLAGS) -w
+libgtest_a_CXXFLAGS = $(GTEST_CXXFLAGS) $(AM_CXXFLAGS)
+
+nodist_libgtest_main_a_SOURCES = $(GTEST_SOURCE)/src/gtest_main.cc
+libgtest_main_a_CPPFLAGS = --std=c++0x $(GTEST_CPPFLAGS) $(AM_CPPFLAGS) -w
+libgtest_main_a_CXXFLAGS = $(GTEST_CXXFLAGS) $(AM_CXXFLAGS)
+
+nodist_libxorg_gtest_a_SOURCES = $(XORG_GTEST_SOURCE)/src/xorg-gtest-all.cpp
+libxorg_gtest_a_CPPFLAGS = \
+	--std=c++0x \
+	$(XORG_GTEST_CPPFLAGS) \
+	$(GTEST_CPPFLAGS) \
+	$(AM_CPPFLAGS) \
+	-iquote$(XORG_GTEST_SOURCE) \
+	-w
+libxorg_gtest_a_CXXFLAGS = \
+	$(XORG_GTEST_CXXFLAGS) \
+	$(GTEST_CXXFLAGS) \
+	$(AM_CPPFLAGS)
+
+nodist_libxorg_gtest_main_a_SOURCES = \
+	$(XORG_GTEST_SOURCE)/src/xorg-gtest_main.cpp
+libxorg_gtest_main_a_CPPFLAGS = \
+	--std=c++0x \
+	$(XORG_GTEST_CPPFLAGS) \
+	$(GTEST_CPPFLAGS) \
+	$(AM_CPPFLAGS) \
+	-iquote$(XORG_GTEST_SOURCE) \
+	-w
+libxorg_gtest_main_a_CXXFLAGS = \
+	$(XORG_GTEST_CXXFLAGS) \
+	$(GTEST_CXXFLAGS) \
+	$(AM_CXXFLAGS)
+
+XORG_GTEST_LIBS = libxorg-gtest.a libgtest.a -lpthread $(X11_LIBS)
+XORG_GTEST_MAIN_LIBS = libxorg-gtest_main.a
 
=== added file 'test/gtest/Makefile.am'
--- test/gtest/Makefile.am	1970-01-01 00:00:00 +0000
+++ test/gtest/Makefile.am	2012-07-18 13:01:21 +0000
@@ -0,0 +1,11 @@
+include $(top_srcdir)/test/gtest/Makefile-xorg-gtest.am
+
+check_LIBRARIES =
+
+if HAVE_GTEST
+  check_LIBRARIES += libgtest.a libgtest_main.a
+endif
+
+if ENABLE_INTEGRATION_TESTS
+  check_LIBRARIES += libxorg-gtest.a libxorg-gtest_main.a
+endif
 
=== added directory 'test/integration'
=== renamed file 'test/Makefile.am' => 'test/integration/Makefile.am'
--- test/Makefile.am	2012-06-18 18:28:21 +0000
+++ test/integration/Makefile.am	2012-07-18 13:01:21 +0000
@@ -1,18 +1,11 @@
-test_targets = check-c-compile check-cxx-compile
-
-if ENABLE_INTEGRATION_TESTS
-include $(top_srcdir)/test/Makefile-xorg-gtest.am
-check_LIBRARIES = $(XORG_GTEST_BUILD_LIBS)
-
-test_targets += check-frame
-endif
+test_targets = check-integration
 
 TESTS = $(test_targets)
-check_PROGRAMS = $(test_targets) check-static-type-checking
+check_PROGRAMS = $(test_targets)
 
 x11dir = x11
 
-check_frame_SOURCES = \
+check_integration_SOURCES = \
 	events.cpp \
 	events.h \
 	x11/device.cpp \
@@ -22,53 +15,43 @@
 	x11/ids.cpp \
 	x11/recording.cpp
 
-AM_CPPFLAGS = \
+check_integration_CPPFLAGS = \
+	--std=c++0x \
+	-I$(top_srcdir) \
 	-I$(top_srcdir)/include \
+	-I../include \
+	-DTEST_ROOT_DIR=\"$(abs_top_srcdir)/test/integration/\"\
 	$(WARNING_CPPFLAGS) \
 	$(GTEST_CPPFLAGS) \
 	$(XORG_GTEST_CPPFLAGS)
 
-AM_CFLAGS = $(C11_CFLAGS) $(COVERAGE_CFLAGS)
+check_integration_CFLAGS = \
+	$(C11_CFLAGS) \
+	$(COVERAGE_CFLAGS) \
+	$(XORG_GTEST_CFLAGS)
 
-AM_CXXFLAGS = \
+check_integration_CXXFLAGS = \
 	$(CXX11_CXXFLAGS) \
+	$(COVERAGE_CXXFLAGS) \
 	$(GTEST_CXXFLAGS) \
-	$(COVERAGE_CXXFLAGS) \
 	$(XORG_GTEST_CXXFLAGS)
 
-check_c_compile_SOURCES = check-c-compile.c
-check_c_compile_LDADD = \
-	$(top_builddir)/src/libutouch-frame.la \
-	$(COVERAGE_LIBS)
-
-check_cxx_compile_SOURCES = check-cxx-compile.cpp
-check_cxx_compile_LDADD = \
-	$(top_builddir)/src/libutouch-frame.la \
-	$(COVERAGE_LIBS)
-
-check_frame_LDFLAGS = $(GTEST_LDFLAGS)
+# check_integration_LDFLAGS = $(GTEST_LDFLAGS)
 
 #
 # Link against the (non-distributed) static lib to pick up the
 # internal symbols.
 #
-check_frame_LDADD = \
+check_integration_LDADD = \
 	$(top_builddir)/src/.libs/libutouch-frame.a \
+	$(top_builddir)/test/gtest/libgtest.a \
+	$(top_builddir)/test/gtest/libxorg-gtest.a \
+	$(top_builddir)/test/gtest/libxorg-gtest_main.a \
+	$(GTEST_LIBS) \
 	$(XORG_GTEST_LIBS) \
-	$(XORG_GTEST_MAIN_LIBS) \
 	$(XINPUT_LIBS) \
 	$(EVEMU_LIBS) \
 	$(COVERAGE_LIBS) \
 	$(CXX_LIBS)
 
-check-static-type-checking$(EXEEXT):
-	@echo "Checking whether static type checking works..."
-	$(AM_V_at)if $(CC) -I../include -L../.libs check-static-type-checking.c -o check_static_type_checking; then \
-		echo "FAIL: Static type checking source compiled without error"; \
-		exit -1; \
-	else \
-		echo "SUCCESS: Static type checking source failed to compile"; \
-		exit 0; \
-	fi
-
 EXTRA_DIST = recordings
 
=== renamed file 'test/events.cpp' => 'test/integration/events.cpp'
=== renamed file 'test/events.h' => 'test/integration/events.h'
=== renamed directory 'test/recordings' => 'test/integration/recordings'
=== renamed directory 'test/x11' => 'test/integration/x11'
=== added directory 'test/regular'
=== added file 'test/regular/Makefile.am'
--- test/regular/Makefile.am	1970-01-01 00:00:00 +0000
+++ test/regular/Makefile.am	2012-07-18 13:01:21 +0000
@@ -0,0 +1,57 @@
+test_targets = check-c-compile check-cxx-compile
+
+if HAVE_GTEST
+test_targets += check-regular
+endif
+
+TESTS = $(test_targets)
+check_PROGRAMS = $(test_targets) check-static-type-checking
+
+check_c_compile_SOURCES = check-c-compile.c
+check_c_compile_LDADD = \
+	$(top_builddir)/src/libutouch-frame.la \
+	$(COVERAGE_LIBS)
+
+check_cxx_compile_SOURCES = check-cxx-compile.cpp
+check_cxx_compile_LDADD = \
+	$(top_builddir)/src/libutouch-frame.la \
+	$(COVERAGE_LIBS)
+
+check-static-type-checking$(EXEEXT):
+	@echo "Checking whether static type checking works..."
+	$(AM_V_at)if $(CC) -I../../include -L../../.libs check-static-type-checking.c -o check_static_type_checking; then \
+		echo "FAIL: Static type checking source compiled without error"; \
+		exit -1; \
+	else \
+		echo "SUCCESS: Static type checking source failed to compile"; \
+		exit 0; \
+	fi
+
+### check-regular
+
+check_regular_SOURCES = \
+	accept-ended-touch.cpp \
+	frame-fixture.cpp
+
+#
+# Link against the (non-distributed) static lib to pick up the
+# internal symbols.
+#
+check_regular_LDADD = \
+	$(top_builddir)/src/.libs/libutouch-frame.a \
+	$(top_builddir)/test/gtest/libgtest.a \
+	$(top_builddir)/test/gtest/libgtest_main.a \
+	$(top_builddir)/test/x11_mocks/libx11_mocks.a \
+	$(COVERAGE_LIBS) \
+	$(GTEST_LIBS)
+
+check_regular_CPPFLAGS = \
+	--std=c++0x \
+	-I$(top_srcdir) \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/test/x11_mocks \
+	$(WARNING_CPPFLAGS) \
+	$(GTEST_CPPFLAGS)
+
+check_regular_CFLAGS = \
+	$(COVERAGE_CFLAGS)
 
=== added file 'test/regular/accept-ended-touch.cpp'
--- test/regular/accept-ended-touch.cpp	1970-01-01 00:00:00 +0000
+++ test/regular/accept-ended-touch.cpp	2012-07-18 13:01:21 +0000
@@ -0,0 +1,72 @@
+#include "frame-fixture.h"
+#include "x11_mocks.h"
+
+class AcceptEndedTouch : public FrameFixture
+{
+};
+
+/*
+  Regression test for https://bugs.launchpad.net/bugs/1025297
+
+  The bug is as follows:
+
+  frame lib fails to forward the accept/reject command to xserver for an owned
+  touch if it has already ended.
+
+  Steps to reproduce the issue:
+    1 - touch 1 begins and gets ownership
+    2 - touch 1 ends
+    3 - touch 2 begins and gets ownership
+    4 - frame client accepts touch 1
+
+  Expected outcome:
+    frame lib accepts the touch on the XInput backend.
+
+  Outcome of the bug:
+    Nothing happens. frame lib never accepts that touch.
+ */
+TEST_F(AcceptEndedTouch, Test)
+{
+  UFStatus status;
+  UFDevice device;
+
+  xmock_server_time = 1234;
+
+  CreateXMockTouchScreenDevice();
+
+  Display *display = XOpenDisplay(NULL);
+
+  status = frame_x11_new(display, &frame_handle);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  FetchDeviceAddedEvent(&device);
+  AssertNoMoreEvents();
+
+  SendTouchEvent(XI_TouchBegin, 1, 10.0f, 10.0f);
+  SendTouchOwnershipEvent(1);
+
+  xmock_server_time += 10;
+
+  SendTouchEvent(XI_TouchEnd, 1, 10.0f, 20.0f);
+
+  xmock_server_time += 3;
+
+  SendTouchEvent(XI_TouchBegin, 2, 10.0f, 21.0f);
+  SendTouchOwnershipEvent(2);
+
+  UFWindowId frame_window_id = frame_x11_create_window_id(DefaultRootWindow(display));
+  status = frame_x11_accept_touch(device, frame_window_id, 1);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  ASSERT_EQ(XIAcceptTouch,
+            xmock_get_touch_acceptance(xmock_devices[0].attachment /* device id */,
+                                       1 /* touch id */,
+                                       DefaultRootWindow(display)));
+
+  frame_x11_delete(frame_handle);
+  frame_handle = nullptr;
+
+  XCloseDisplay(display);
+
+  DestroyXMockDevices();
+}
 
=== renamed file 'test/check-c-compile.c' => 'test/regular/check-c-compile.c'
=== renamed file 'test/check-cxx-compile.cpp' => 'test/regular/check-cxx-compile.cpp'
=== renamed file 'test/check-static-type-checking.c' => 'test/regular/check-static-type-checking.c'
=== added file 'test/regular/frame-fixture.cpp'
--- test/regular/frame-fixture.cpp	1970-01-01 00:00:00 +0000
+++ test/regular/frame-fixture.cpp	2012-07-18 13:01:21 +0000
@@ -0,0 +1,161 @@
+#include "frame-fixture.h"
+#include "x11_mocks.h"
+
+FrameFixture::FrameFixture()
+  : frame_handle(nullptr),
+    _xevent_serial_number(1)
+{
+}
+
+void FrameFixture::SetUp()
+{
+  xmock_touch_acceptance.clear();
+}
+
+void FrameFixture::TearDown()
+{
+  ASSERT_EQ(nullptr, frame_handle);
+}
+
+void FrameFixture::CreateXMockTouchScreenDevice()
+{
+  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 FrameFixture::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 FrameFixture::SendTouchEvent(
+    int event_type, int touch_id, float x, float y)
+{
+  UFStatus status;
+  XGenericEventCookie xcookie;
+  XIDeviceEvent *device_event = 0;
+
+  device_event = (XIDeviceEvent*)calloc(1, sizeof(XIDeviceEvent));
+  device_event->serial = _xevent_serial_number++;
+  device_event->display = xmock_display;
+  device_event->extension = xmock_xi2_opcode;
+  device_event->evtype = event_type;
+  device_event->time = xmock_server_time;
+  device_event->deviceid = 0;
+  device_event->sourceid = device_event->deviceid;
+  device_event->detail = touch_id;
+  device_event->root = DefaultRootWindow(xmock_display);
+  device_event->event = DefaultRootWindow(xmock_display);
+  device_event->child = 0;
+  device_event->root_x = x;
+  device_event->root_y = y;
+  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] = 0; /* just change the coordinate system */
+  device_event->valuators.values[1] = 0;
+  xcookie.extension = xmock_xi2_opcode;
+  xcookie.evtype = event_type;
+  xcookie.data = device_event;
+
+  status = frame_x11_process_event(frame_handle, &xcookie);
+  ASSERT_EQ(UFStatusSuccess, status);
+}
+
+void FrameFixture::SendTouchOwnershipEvent(int touch_id)
+{
+  UFStatus status;
+  XGenericEventCookie xcookie;
+  XITouchOwnershipEvent *ownership_event = 0;
+
+  ownership_event = (XITouchOwnershipEvent*)calloc(1, sizeof(XITouchOwnershipEvent));
+  ownership_event->type = GenericEvent;
+  ownership_event->serial = _xevent_serial_number++;
+  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 = touch_id;
+  ownership_event->root = DefaultRootWindow(xmock_display);
+  ownership_event->event = DefaultRootWindow(xmock_display);
+  ownership_event->child = 0;
+  xcookie.extension = xmock_xi2_opcode;
+  xcookie.evtype = XI_TouchOwnership;
+  xcookie.data = ownership_event;
+
+  status = frame_x11_process_event(frame_handle, &xcookie);
+  ASSERT_EQ(UFStatusSuccess, status);
+}
+
+void FrameFixture::FetchDeviceAddedEvent(UFDevice *device)
+{
+  UFEvent event;
+  UFStatus status;
+
+  status = frame_get_event(frame_handle, &event);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  ASSERT_EQ(UFEventTypeDeviceAdded, frame_event_get_type(event));
+
+  status = frame_event_get_property(event, UFEventPropertyDevice, device);
+  ASSERT_EQ(UFStatusSuccess, status);
+
+  frame_event_unref(event);
+}
+
+void FrameFixture::AssertNoMoreEvents()
+{
+  UFEvent event;
+  UFStatus status;
+
+  status = frame_get_event(frame_handle, &event);
+  ASSERT_EQ(UFStatusErrorNoEvent, status);
+}
 
=== added file 'test/regular/frame-fixture.h'
--- test/regular/frame-fixture.h	1970-01-01 00:00:00 +0000
+++ test/regular/frame-fixture.h	2012-07-18 13:01:21 +0000
@@ -0,0 +1,31 @@
+#ifndef GTEST_FRAME_FIXTURE_H
+#define GTEST_FRAME_FIXTURE_H
+
+#include <gtest/gtest.h>
+#include "utouch/frame.h"
+#include "utouch/frame_x11.h"
+
+class FrameFixture : public ::testing::Test
+{
+ protected:
+  FrameFixture();
+
+  virtual void SetUp();
+  virtual void TearDown();
+
+  void CreateXMockTouchScreenDevice();
+  void DestroyXMockDevices();
+
+  void SendTouchEvent(int event_type, int touch_id, float x, float y);
+  void SendTouchOwnershipEvent(int touch_id);
+  
+  void FetchDeviceAddedEvent(UFDevice *device);
+  void AssertNoMoreEvents();
+
+  UFHandle frame_handle;
+ private:
+  /* holds the serial number to be used on the next synthetic XEvent */
+  int _xevent_serial_number;
+};
+
+#endif
 
=== added directory 'test/x11_mocks'
=== added file 'test/x11_mocks/Makefile.am'
--- test/x11_mocks/Makefile.am	1970-01-01 00:00:00 +0000
+++ test/x11_mocks/Makefile.am	2012-07-18 13:01:21 +0000
@@ -0,0 +1,14 @@
+#
+# @file testsuite/x11_mocks/Makefile.am 
+# @brief automake recipe for the X11 mockups
+#
+
+check_LIBRARIES = libx11_mocks.a
+
+libx11_mocks_a_SOURCES = \
+	x11_mocks.h x11_mocks.cpp
+
+libx11_mocks_a_CPPFLAGS = \
+	--std=c++0x \
+	-Wno-unused-parameter
+
 
=== added file 'test/x11_mocks/x11_mocks.cpp'
--- test/x11_mocks/x11_mocks.cpp	1970-01-01 00:00:00 +0000
+++ test/x11_mocks/x11_mocks.cpp	2012-07-18 13:01:21 +0000
@@ -0,0 +1,435 @@
+/* needed to break into 'Display' struct internals. */
+#define XLIB_ILLEGAL_ACCESS
+#include <X11/Xlib.h>
+
+#include "x11_mocks.h"
+
+#include <sys/eventfd.h>
+#include <stdio.h>
+#include <stdlib.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;
+
+std::map<int, std::map<unsigned int, std::map<Window, int> > > xmock_touch_acceptance;
+
+/* 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 = reinterpret_cast<struct EventQueueItem *>(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);
+  }
+}
+
+int xmock_get_touch_acceptance(int device_id, unsigned int touch_id, Window window)
+{
+  if (xmock_touch_acceptance.find(device_id) == xmock_touch_acceptance.end())
+    return -1;
+
+  std::map<unsigned int, std::map<Window, int> > &touch_map =
+    xmock_touch_acceptance[device_id];
+
+  if (touch_map.find(touch_id) == touch_map.end())
+    return -1;
+
+  std::map<Window, int> &window_map = touch_map[touch_id];
+
+  if (window_map.find(window) == window_map.end())
+    return -1;
+
+  return window_map[window];
+}
+
+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 = reinterpret_cast<XIDeviceInfo*>(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;
+  xmock_touch_acceptance[deviceid][touchid][grab_window] = 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 = reinterpret_cast<XSyncSystemCounter*>(malloc(sizeof(XSyncSystemCounter)));
+  sys_counter->name = const_cast<char*>("SERVERTIME"); // I know it's technically dangerous, but it's simple.
+  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;
+  return Success;
+}
+
+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;
+}
+
+Atom XInternAtom(Display* display, _Xconst char* atom_name, Bool only_if_exists)
+{
+  XMOCK_PRINT_FUNCTION;
+  /* This function doesn't end up getting called when frame is run from tests yet.
+     It's here just to make the code compile. Add some minimal logic when needed. */
+  abort();
+  return 1;
+}
+
+
 
=== added file 'test/x11_mocks/x11_mocks.h'
--- test/x11_mocks/x11_mocks.h	1970-01-01 00:00:00 +0000
+++ test/x11_mocks/x11_mocks.h	2012-07-18 13:01:21 +0000
@@ -0,0 +1,41 @@
+#ifndef X11_MOCKS_H
+#define X11_MOCKS_H
+
+#include <X11/Xlib.h>
+#include <X11/extensions/XInput2.h>
+#include <X11/extensions/sync.h>
+#include <stdint.h>
+#include <map>
+
+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);
+
+/*
+  Each call to:
+  XIAllowTouchEvents(display, device_id, touch_id, window_id, touch_acceptance)
+  Causes:
+  xmock_touch_acceptance[device_id][touch_id][window_id] = touch_acceptance;
+ */
+extern std::map<int, std::map<unsigned int, std::map<Window, int> > > xmock_touch_acceptance;
+
+/*
+  Returns -1 if XIAllowTouchEvents wasn't called with the given parameters.
+ */
+int xmock_get_touch_acceptance(int device_id, unsigned int touch_id, Window window);
+
+#endif