Merge lp:~bregma/evemu/lp-731678 into lp:evemu

[Stephen M. Webb]

This MR takes Duncan McGreggor's original Python bindings branch, fixes all the unit tests, and refactors into a single Device class with a clear invariant and a simpler API. A few bits of the original remain.

The unit tests exercise pretty much all of the C API, so that takes care of unit testing for this library.

The unit tests need to be run as root because they require write access to kernel devices. They may also exercise race condition bugs in desktop software (eg. utouch-geis, GTK+, x.org) and may randomly require you to restart all or part of your system. Bugs have been filed upstream in those projects. Do not say you have not been warned.

[Chase Douglas (chasedouglas)]

Everything looks sane to me, though I don't know python very well. I'm fine with merging it anyways though. Unit testing is good, creating new bindings is better, and unit testing through the new bindings is awesome :).

The only question I have is whether the python/Makefile.original and python/TODO files were meant to be included. If so, why are they there?

[lp:~bregma/evemu/lp-731678]

121. By Stephen M. Webb on 2011-11-30

Removed python/Makefile.original and python/TODO

=== modified file '.bzrignore'
--- .bzrignore	2011-06-17 01:54:02 +0000
+++ .bzrignore	2011-11-30 21:40:28 +0000
@@ -11,6 +11,7 @@
 config-aux
 config.*
 configure
+evemu-test-runner
 libtool
 stamp-*
 tools/evemu-describe

=== modified file 'Makefile.am'
--- Makefile.am	2011-04-19 09:30:21 +0000
+++ Makefile.am	2011-11-30 21:40:28 +0000
@@ -1,4 +1,4 @@
-SUBDIRS = src tools
+SUBDIRS = src tools python
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = utouch-evemu.pc
@@ -9,6 +9,8 @@
 INSTALL:
 	$(INSTALL_CMD)
 
+EXTRA_DIST = data
+
 ChangeLog:
 	@if test -d ".bzr"; then \
 	    cmd=bzr; \
@@ -20,3 +22,5 @@
 	$${cmd} log > ChangeLog;
 
 dist-hook: ChangeLog INSTALL
+
+DISTCLEANFILES = ChangeLog

=== modified file 'configure.ac'
--- configure.ac	2011-11-02 13:27:23 +0000
+++ configure.ac	2011-11-30 21:40:28 +0000
@@ -22,6 +22,7 @@
 # Checks for programs.
 AC_PROG_CC
 AC_PROG_INSTALL
+AM_PATH_PYTHON([2.6])
 
 # man page generation
 AC_ARG_VAR([XMLTO], [Path to xmlto command])
@@ -39,6 +40,7 @@
 
 AC_CONFIG_FILES([Makefile
                  src/Makefile
+                 python/Makefile
                  tools/Makefile
                  utouch-evemu.pc])
 AC_OUTPUT

=== modified file 'data/3m.prop'
--- data/3m.prop	2010-09-19 08:43:49 +0000
+++ data/3m.prop	2011-11-30 21:40:28 +0000
@@ -1,4 +1,4 @@
-N: 3M-3M-MicroTouch-USB-controller
+N: 3M-3M-MicroTouch-USB-controller Virtual Device
 I: 0003 0596 0502 0110
 B: 00 0b 00 00 00 00 00 00 00
 B: 01 00 00 00 00 00 00 00 00

=== modified file 'data/bcm5974.prop'
--- data/bcm5974.prop	2010-09-18 17:10:11 +0000
+++ data/bcm5974.prop	2011-11-30 21:40:28 +0000
@@ -1,4 +1,4 @@
-N: bcm5974
+N: bcm5974 Virtual Device
 I: 0003 05ac 0223 0000
 B: 00 0b 00 00 00 00 00 00 00
 B: 01 00 00 00 00 00 00 00 00

=== added file 'data/ntrig-dell-xt2.event'
--- data/ntrig-dell-xt2.event	1970-01-01 00:00:00 +0000
+++ data/ntrig-dell-xt2.event	2011-11-30 21:40:28 +0000
@@ -0,0 +1,146 @@
+E: 1299660667.063211 0003 0035 7411
+E: 1299660667.063229 0003 0036 4677
+E: 1299660667.063232 0003 0034 1
+E: 1299660667.063236 0003 0030 462
+E: 1299660667.063238 0003 0031 360
+E: 1299660667.063242 0000 0002 0
+E: 1299660667.063260 0003 0035 7361
+E: 1299660667.063263 0003 0036 3291
+E: 1299660667.063266 0003 0034 1
+E: 1299660667.063269 0003 0030 462
+E: 1299660667.063271 0003 0031 360
+E: 1299660667.063275 0000 0002 0
+E: 1299660667.063280 0003 0035 5912
+E: 1299660667.063283 0003 0036 1483
+E: 1299660667.063286 0003 0034 0
+E: 1299660667.063289 0003 0030 540
+E: 1299660667.063292 0003 0031 462
+E: 1299660667.063295 0000 0002 0
+E: 1299660667.063299 0001 014a 1
+E: 1299660667.063302 0003 0000 7411
+E: 1299660667.063306 0003 0001 4677
+E: 1299660667.063311 0000 0000 0
+E: 1299660667.081029 0003 0035 7380
+E: 1299660667.081039 0003 0036 4674
+E: 1299660667.081043 0003 0034 1
+E: 1299660667.081045 0003 0030 462
+E: 1299660667.081048 0003 0031 360
+E: 1299660667.081051 0000 0002 0
+E: 1299660667.081064 0003 0035 7401
+E: 1299660667.081067 0003 0036 3263
+E: 1299660667.081070 0003 0034 0
+E: 1299660667.081073 0003 0030 360
+E: 1299660667.081076 0003 0031 308
+E: 1299660667.081079 0000 0002 0
+E: 1299660667.081082 0003 0035 5887
+E: 1299660667.081085 0003 0036 1484
+E: 1299660667.081088 0003 0034 0
+E: 1299660667.081091 0003 0030 540
+E: 1299660667.081094 0003 0031 308
+E: 1299660667.081097 0000 0002 0
+E: 1299660667.081106 0000 0000 0
+E: 1299660667.097214 0003 0035 7379
+E: 1299660667.097237 0003 0036 4678
+E: 1299660667.097240 0003 0034 0
+E: 1299660667.097243 0003 0030 360
+E: 1299660667.097246 0003 0031 308
+E: 1299660667.097249 0000 0002 0
+E: 1299660667.097267 0003 0035 7371
+E: 1299660667.097270 0003 0036 3262
+E: 1299660667.097273 0003 0034 1
+E: 1299660667.097276 0003 0030 462
+E: 1299660667.097279 0003 0031 360
+E: 1299660667.097282 0000 0002 0
+E: 1299660667.097286 0003 0035 5901
+E: 1299660667.097290 0003 0036 1488
+E: 1299660667.097293 0003 0034 0
+E: 1299660667.097296 0003 0030 540
+E: 1299660667.097299 0003 0031 462
+E: 1299660667.097302 0000 0002 0
+E: 1299660667.097312 0000 0000 0
+E: 1299660667.113209 0003 0035 7382
+E: 1299660667.113228 0003 0036 4680
+E: 1299660667.113231 0003 0034 0
+E: 1299660667.113234 0003 0030 360
+E: 1299660667.113237 0003 0031 308
+E: 1299660667.113240 0000 0002 0
+E: 1299660667.113256 0003 0035 7399
+E: 1299660667.113259 0003 0036 3253
+E: 1299660667.113262 0003 0034 0
+E: 1299660667.113265 0003 0030 360
+E: 1299660667.113268 0003 0031 308
+E: 1299660667.113271 0000 0002 0
+E: 1299660667.113275 0003 0035 5886
+E: 1299660667.113277 0003 0036 1489
+E: 1299660667.113280 0003 0034 1
+E: 1299660667.113283 0003 0030 462
+E: 1299660667.113286 0003 0031 360
+E: 1299660667.113289 0000 0002 0
+E: 1299660667.113293 0003 0035 6837
+E: 1299660667.113296 0003 0036 2669
+E: 1299660667.113298 0003 0034 1
+E: 1299660667.113301 0003 0030 462
+E: 1299660667.113304 0003 0031 360
+E: 1299660667.113307 0000 0002 0
+E: 1299660667.113316 0000 0000 0
+E: 1299660667.129014 0003 0035 7375
+E: 1299660667.129022 0003 0036 4685
+E: 1299660667.129025 0003 0034 0
+E: 1299660667.129028 0003 0030 360
+E: 1299660667.129031 0003 0031 308
+E: 1299660667.129034 0000 0002 0
+E: 1299660667.129043 0003 0035 7396
+E: 1299660667.129046 0003 0036 3254
+E: 1299660667.129049 0003 0034 0
+E: 1299660667.129052 0003 0030 360
+E: 1299660667.129055 0003 0031 308
+E: 1299660667.129058 0000 0002 0
+E: 1299660667.129062 0003 0035 5892
+E: 1299660667.129064 0003 0036 1503
+E: 1299660667.129067 0003 0034 0
+E: 1299660667.129070 0003 0030 540
+E: 1299660667.129073 0003 0031 462
+E: 1299660667.129076 0000 0002 0
+E: 1299660667.129080 0003 0035 6829
+E: 1299660667.129083 0003 0036 2671
+E: 1299660667.129086 0003 0034 1
+E: 1299660667.129089 0003 0030 462
+E: 1299660667.129091 0003 0031 360
+E: 1299660667.129094 0000 0002 0
+E: 1299660667.129103 0000 0000 0
+E: 1299660667.145205 0003 0035 7378
+E: 1299660667.145221 0003 0036 4687
+E: 1299660667.145224 0003 0034 0
+E: 1299660667.145232 0003 0030 360
+E: 1299660667.145235 0003 0031 308
+E: 1299660667.145238 0000 0002 0
+E: 1299660667.145254 0003 0035 7403
+E: 1299660667.145257 0003 0036 3252
+E: 1299660667.145260 0003 0034 0
+E: 1299660667.145263 0003 0030 360
+E: 1299660667.145266 0003 0031 308
+E: 1299660667.145269 0000 0002 0
+E: 1299660667.145272 0003 0035 5894
+E: 1299660667.145275 0003 0036 1508
+E: 1299660667.145278 0003 0034 0
+E: 1299660667.145281 0003 0030 540
+E: 1299660667.145284 0003 0031 462
+E: 1299660667.145287 0000 0002 0
+E: 1299660667.145290 0003 0035 6853
+E: 1299660667.145293 0003 0036 2668
+E: 1299660667.145296 0003 0034 0
+E: 1299660667.145299 0003 0030 360
+E: 1299660667.145302 0003 0031 154
+E: 1299660667.145305 0000 0002 0
+E: 1299660667.145314 0000 0000 0
+E: 1299660667.169030 0003 0035 5897
+E: 1299660667.169040 0003 0036 1513
+E: 1299660667.169044 0003 0034 0
+E: 1299660667.169047 0003 0030 540
+E: 1299660667.169049 0003 0031 308
+E: 1299660667.169053 0000 0002 0
+E: 1299660667.169066 0003 0000 5897
+E: 1299660667.169069 0003 0001 1513
+E: 1299660667.169074 0000 0000 0
+E: 1299660667.181005 0001 014a 0
+E: 1299660667.181013 0000 0000 0

=== added file 'data/ntrig-dell-xt2.prop'
--- data/ntrig-dell-xt2.prop	1970-01-01 00:00:00 +0000
+++ data/ntrig-dell-xt2.prop	2011-11-30 21:40:28 +0000
@@ -0,0 +1,31 @@
+N: N-Trig-MultiTouch-Virtual-Device
+I: 0003 1b96 0001 0110
+P: 00 00 00 00 00 00 00 00
+B: 00 0b 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 04 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 02 00 00 00 00 00 00 00 00
+B: 03 03 00 00 00 00 00 73 00
+B: 04 00 00 00 00 00 00 00 00
+B: 05 00 00 00 00 00 00 00 00
+B: 11 00 00 00 00 00 00 00 00
+B: 12 00 00 00 00 00 00 00 00
+B: 15 00 00 00 00 00 00 00 00
+B: 15 00 00 00 00 00 00 00 00
+A: 00 0 9600 75 0
+A: 01 0 7200 78 0
+A: 30 0 9600 200 0
+A: 31 0 7200 150 0
+A: 34 0 1 0 0
+A: 35 0 9600 75 0
+A: 36 0 7200 78 0

=== added file 'data/ntrig-lenovo-T410s.event'
=== added file 'data/ntrig-lenovo-T410s.prop'
--- data/ntrig-lenovo-T410s.prop	1970-01-01 00:00:00 +0000
+++ data/ntrig-lenovo-T410s.prop	2011-11-30 21:40:28 +0000
@@ -0,0 +1,24 @@
+N: N-Trig-MultiTouch Virtual Device
+I: 0003 1b96 0001 0110
+P: 00 00 00 00 00 00 00 00
+B: 00 01 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 02 00 00 00 00 00 00 00 00
+B: 03 00 00 00 00 00 00 00 00
+B: 04 00 00 00 00 00 00 00 00
+B: 05 00 00 00 00 00 00 00 00
+B: 11 00 00 00 00 00 00 00 00
+B: 12 00 00 00 00 00 00 00 00
+B: 15 00 00 00 00 00 00 00 00
+B: 15 00 00 00 00 00 00 00 00

=== added file 'data/synaptics.prop'
--- data/synaptics.prop	1970-01-01 00:00:00 +0000
+++ data/synaptics.prop	2011-11-30 21:40:28 +0000
@@ -0,0 +1,32 @@
+N: SynPS/2 Synaptics TouchPad
+I: 0011 0002 0007 01b1
+P: 09 00 00 00 00 00 00 00
+B: 00 0b 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 03 00 00 00 00 00
+B: 01 20 64 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 01 00 00 00 00 00 00 00 00
+B: 02 00 00 00 00 00 00 00 00
+B: 03 03 00 00 11 00 80 60 02
+B: 04 00 00 00 00 00 00 00 00
+B: 05 00 00 00 00 00 00 00 00
+B: 11 00 00 00 00 00 00 00 00
+B: 12 00 00 00 00 00 00 00 00
+B: 15 00 00 00 00 00 00 00 00
+B: 15 00 00 00 00 00 00 00 00
+A: 00 1472 5888 0 0
+A: 01 1408 4820 0 0
+A: 18 0 255 0 0
+A: 1c 0 15 0 0
+A: 2f 0 1 0 0
+A: 35 1472 5888 0 0
+A: 36 1408 4820 0 0
+A: 39 0 65535 0 0

=== modified file 'data/wetab.prop'
--- data/wetab.prop	2010-11-18 13:56:30 +0000
+++ data/wetab.prop	2011-11-30 21:40:28 +0000
@@ -1,4 +1,4 @@
-N: eGalax-Inc.-USB-TouchController
+N: eGalax-Inc.-USB-TouchController Virtual Device
 I: 0003 0eef 72a1 0210
 B: 00 0b 00 00 00 00 00 00 00
 B: 01 00 00 00 00 00 00 00 00

=== added directory 'python'
=== added file 'python/Makefile.am'
--- python/Makefile.am	1970-01-01 00:00:00 +0000
+++ python/Makefile.am	2011-11-30 21:40:28 +0000
@@ -0,0 +1,37 @@
+#
+# @file python/Makefile.am
+# @brief automake recipe for the uTouch evemu Python bindings
+#
+# Copyright 2011 Canonical, Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it 
+# under the terms of the GNU General Public License version 3, as published 
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but 
+# WITHOUT ANY WARRANTY; without even the implied warranties of 
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along 
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+nobase_python_PYTHON = \
+	$(wildcard evemu/*.py)
+
+check_SCRIPTS = evemu-test-runner
+
+TESTS = $(check_SCRIPTS)
+
+evemu-test-runner: evemu-test-runner.in Makefile
+	$(AM_V_GEN)$(SED) \
+	  -e 's,[@]builddir[@],$(builddir),g' \
+	  -e 's,[@]top_builddir[@],$(top_builddir),g' \
+	  -e 's,[@]srcdir[@],$(srcdir),g' \
+	  -e 's,[@]python[@],$(PYTHON),g' \
+	  $< >$@
+	chmod +x $@
+
+BUILT_SOURCES = evemu-test-runner
+EXTRA_DIST =  evemu-test-runner.in $(wildcard evemu/test*)
+CLEANFILES = $(BUILT_SOURCES)

=== added directory 'python/evemu'
=== added file 'python/evemu-test-runner.in'
--- python/evemu-test-runner.in	1970-01-01 00:00:00 +0000
+++ python/evemu-test-runner.in	2011-11-30 21:40:28 +0000
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+PYTHONPATH=@builddir@:@srcdir@ LD_LIBRARY_PATH=@top_builddir@/src/.libs @python@ -m evemu.testing.runner
+

=== added file 'python/evemu/__init__.py'
--- python/evemu/__init__.py	1970-01-01 00:00:00 +0000
+++ python/evemu/__init__.py	2011-11-30 21:40:28 +0000
@@ -0,0 +1,271 @@
+"""
+The evemu module provides the Python interface to the kernel-level input device
+raw events.
+"""
+
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it 
+# under the terms of the GNU General Public License version 3, as published 
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but 
+# WITHOUT ANY WARRANTY; without even the implied warranties of 
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along 
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from ctypes.util import find_library
+
+import ctypes
+import evemu.base
+import evemu.const
+import glob
+import os
+import re
+import stat
+
+__all__ = ["Device"]
+
+
+class Device(object):
+    """
+    Encapsulates a raw kernel input event device, either an existing one as
+    reported by the kernel or a pseudodevice as created through a .prop file.
+    """
+
+    def __init__(self, f):
+        """
+        Initializas an evemu Device.
+
+        args:
+        f -- a file object or filename string for either an existing input
+        device node (/dev/input/eventNN) or an evemu prop file that can be used
+        to create a pseudo-device node.
+        """
+
+        if type(f).__name__ == 'str':
+            self._file = open(f, 'r+b')
+        elif type(f).__name__ == 'file':
+            self._file = f
+        else:
+            raise TypeError("expected file or file name")
+
+        self._is_propfile = True
+        if stat.S_ISCHR(os.fstat(self._file.fileno()).st_mode):
+            self._is_propfile = False
+        elif self._file.read(3) == 'N: ':
+            self._file.seek(0)
+        else:
+            raise TypeError("file must be a device special or prop file")
+
+        self._evemu = evemu.base.EvEmuBase(find_library(evemu.const.LIB))
+        self._uinput = None
+
+        libevemu_new = self._evemu.get_lib().evemu_new
+        libevemu_new.restype = ctypes.c_void_p
+        self._evemu_device = libevemu_new("")
+
+        if self._is_propfile:
+            fs = self._evemu._call0(self._evemu.get_c_lib().fdopen,
+                                    self._file.fileno(),
+                                    'r')
+            self._evemu._call(self._evemu.get_lib().evemu_read,
+                              self._evemu_device,
+                              fs)
+            self._uinput = os.open(evemu.const.UINPUT_NODE, os.O_WRONLY)
+            self._file = self._create_devnode()
+        else:
+            self._evemu._call(self._evemu.get_lib().evemu_extract,
+                             self._evemu_device,
+                             self._file.fileno())
+
+    def __del__(self):
+        if self._is_propfile:
+            self._file.close()
+            self._evemu._call(self._evemu.get_lib().evemu_destroy,
+                              self._uinput)
+
+    def _create_devnode(self):
+        self._evemu._call(self._evemu.get_lib().evemu_create,
+                          self._evemu_device,
+                          self._uinput)
+        return open(self._find_newest_devnode(self.name), 'r+')
+
+    def _find_newest_devnode(self, target_name):
+        newest_node = (None, float(0))
+        for sysname in glob.glob("/sys/class/input/event*/device/name"):
+            with open(sysname) as f:
+                name = f.read().rstrip()
+                if name == target_name:
+                    ev = re.search("(event\d+)", sysname)
+                    if ev:
+                       devname = os.path.join("/dev/input", ev.group(1))
+                       ctime = os.stat(devname).st_ctime
+                       if ctime > newest_node[1]:
+                           newest_node = (devname, ctime)
+        return newest_node[0]
+
+    def describe(self, prop_file):
+        """
+        Gathers information about the input device and prints it
+        to prop_file. This information can be parsed later when constructing
+        a Device to create a virtual input device with the same properties.
+
+        Scripts that use this method need to be run as root.
+        """
+        if type(prop_file).__name__ != 'file':
+            raise TypeError("expected file")
+
+        fs = self._evemu._call0(self._evemu.get_c_lib().fdopen,
+                                prop_file.fileno(),
+                                "w")
+        self._evemu._call(self._evemu.get_lib().evemu_write,
+                          self._evemu_device,
+                          fs)
+        self._evemu.get_c_lib().fflush(fs)
+
+    def play(self, events_file):
+        """
+        Replays an event sequence, as provided by the events_file,
+        through the input device. The event sequence must be in
+        the form created by the record method.
+
+        Scripts that use this method need to be run as root.
+        """
+        if type(events_file).__name__ != 'file':
+            raise TypeError("expected file")
+
+        fs = self._evemu._call0(self._evemu.get_c_lib().fdopen,
+                                events_file.fileno(),
+                                "r")
+        self._evemu._call(self._evemu.get_lib().evemu_play,
+                          fs,
+                          self._file.fileno())
+
+    def record(self, events_file, timeout=10000):
+        """
+        Captures events from the input device and prints them to the
+        events_file. The events can be parsed by the play method,
+        allowing a virtual input device to emit the exact same event
+        sequence.
+
+        Scripts that use this method need to be run as root.
+        """
+        if type(events_file).__name__ != 'file':
+            raise TypeError("expected file")
+
+        fs = self._evemu._call0(self._evemu.get_c_lib().fdopen,
+                                events_file.fileno(),
+                                "w")
+        self._evemu._call(self._evemu.get_lib().evemu_record,
+                          fs,
+                          self._file.fileno(),
+                          timeout)
+        self._evemu.get_c_lib().fflush(fs)
+
+    @property
+    def version(self):
+        """
+        Gets the version of the evemu library used to create the Device.
+        """
+        return self._evemu._call(self._evemu.get_lib().evemu_get_version,
+                                 self._evemu_device)
+
+    @property
+    def devnode(self):
+        """
+        Gets the name of the /dev node of the input device.
+        """
+        return self._file.name
+
+    @property
+    def name(self):
+        """
+        Gets the name of the input device (as reported by the device).
+        """
+        func = self._evemu.get_lib().evemu_get_name
+        func.restype = ctypes.c_char_p
+        return self._evemu._call(func, self._evemu_device)
+
+    @property
+    def id_bustype(self):
+        """
+        Identifies the kernel device bustype.
+        """
+        return self._evemu._call(self._evemu.get_lib().evemu_get_id_bustype,
+                                 self._evemu_device)
+
+    @property
+    def id_vendor(self):
+        """
+        Identifies the kernel device vendor.
+        """
+        return self._evemu._call(self._evemu.get_lib().evemu_get_id_vendor,
+                                 self._evemu_device)
+
+    @property
+    def id_product(self):
+        """
+        Identifies the kernel device product.
+        """
+        return self._evemu._call(self._evemu.get_lib().evemu_get_id_product,
+                                 self._evemu_device)
+
+    @property
+    def id_version(self):
+        """
+        Identifies the kernel device version.
+        """
+        return self._evemu._call(self._evemu.get_lib().evemu_get_id_version,
+                                 self._evemu_device)
+
+    def get_abs_minimum(self, event_code):
+        return self._evemu._call(self._evemu.get_lib().evemu_get_abs_minimum,
+                                 self._evemu_device,
+                                 int(event_code))
+
+    def get_abs_maximum(self, event_code):
+        return self._evemu._call(self._evemu.get_lib().evemu_get_abs_maximum,
+                                 self._evemu_device,
+                                 event_code)
+
+    def get_abs_fuzz(self, event_code):
+        return self._evemu._call(self._evemu.get_lib().evemu_get_abs_fuzz,
+                                 self._evemu_device,
+                                 event_code)
+
+    def get_abs_flat(self, event_code):
+        return self._evemu._call(self._evemu.get_lib().evemu_get_abs_flat,
+                                 self._evemu_device,
+                                 event_code)
+
+    def get_abs_resolution(self, event_code):
+        return self._evemu._call(self._evemu.get_lib().evemu_get_abs_resolution,
+                                 self._evemu_device,
+                                 event_code)
+
+    def has_prop(self, event_code):
+        return self._evemu._call(self._evemu.get_lib().evemu_has_prop,
+                                 self._evemu_device,
+                                 event_code)
+
+    def has_event(self, event_type, event_code):
+        """
+        This method's 'even_type' parameter is expected to mostly take the
+        value for EV_ABS (i.e., 0x03), but may on occasion EV_KEY (i.e., 0x01).
+        If the former, then the even_code parameter will take the same values
+        as the methods above (ABS_*). However, if the latter, then the legal
+        values will be BTN_*.
+
+        The reason for including the button data, is that buttons are sometimes
+        used to simulate gestures for a higher number of touches than are
+        possible with just 2-touch hardware.
+        """
+        return self._evemu._call(self._evemu.get_lib().evemu_has_event,
+                                 self._evemu_device,
+                                 event_type,
+                                 event_code)
+

=== added file 'python/evemu/base.py'
--- python/evemu/base.py	1970-01-01 00:00:00 +0000
+++ python/evemu/base.py	2011-11-30 21:40:28 +0000
@@ -0,0 +1,43 @@
+import ctypes
+from ctypes.util import find_library
+import os
+
+from evemu import const
+from evemu import exception
+
+
+class EvEmuBase(object):
+    """
+    A base wrapper class for the evemu functions, accessed via ctypes.
+    """
+    def __init__(self, library=""):
+        if not library:
+            library = const.LIB
+        self._lib = ctypes.CDLL(library, use_errno=True)
+        self._libc = ctypes.CDLL(find_library("c"), use_errno=True)
+
+    def _call0(self, api_call, *parameters):
+        result = api_call(*parameters)
+        if result == 0 and self.get_c_errno() != 0:
+            raise exception.ExecutionError, "%s: %s" % (
+                api_call.__name__, self.get_c_error())
+        return result
+
+    def _call(self, api_call, *parameters):
+        result = api_call(*parameters)
+        if result < 0 and self.get_c_errno() != 0:
+            raise exception.ExecutionError, "%s: %s" % (
+                api_call.__name__, self.get_c_error())
+        return result
+
+    def get_c_errno(self):
+        return ctypes.get_errno()
+
+    def get_c_error(self):
+        return os.strerror(ctypes.get_errno())
+
+    def get_c_lib(self):
+        return self._libc
+
+    def get_lib(self):
+        return self._lib

=== added file 'python/evemu/const.py'
--- python/evemu/const.py	1970-01-01 00:00:00 +0000
+++ python/evemu/const.py	2011-11-30 21:40:28 +0000
@@ -0,0 +1,235 @@
+LIB = "utouch-evemu"
+DEFAULT_LIB = "/usr/lib/libutouch-evemu.so"
+LOCAL_LIB = "../src/.libs/libutouch-evemu.so"
+UINPUT_NODE = "/dev/uinput"
+MAX_EVENT_NODE = 32
+UINPUT_MAX_NAME_SIZE = 80 # defined in linux/uinput.h
+DEVICE_PATH_TEMPLATE = "/dev/input/event%d"
+DEVICE_NAME_PATH_TEMPLATE = "/sys/class/input/event%d/device/name"
+# The following should be examined every release of evemu
+API = [
+    "evemu_new",
+    "evemu_delete",
+    "evemu_extract",
+    "evemu_write",
+    "evemu_read",
+    "evemu_write_event",
+    "evemu_record",
+    "evemu_read_event",
+    "evemu_play",
+    "evemu_create",
+    "evemu_destroy",
+    # Device settrs
+    "evemu_set_name",
+    # Device gettrs
+    "evemu_get_version",
+    "evemu_get_name",
+    "evemu_get_id_bustype",
+    "evemu_get_id_vendor",
+    "evemu_get_id_product",
+    "evemu_get_id_version",
+    "evemu_get_abs_minimum",
+    "evemu_get_abs_maximum",
+    "evemu_get_abs_fuzz",
+    "evemu_get_abs_flat",
+    "evemu_get_abs_resolution",
+    # Device hasers
+    "evemu_has_prop",
+    "evemu_has_event",
+    ]
+
+event_types = {
+    "EV_SYN": 0x00,
+    "EV_KEY": 0x01,
+    "EV_REL": 0x02,
+    "EV_ABS": 0x03,
+    "EV_MSC": 0x04,
+    "EV_SW": 0x05,
+    "EV_LED": 0x11,
+    "EV_SND": 0x12,
+    "EV_REP": 0x14,
+    "EV_FF": 0x15,
+    "EV_PWR": 0x16,
+    "EV_FF_STATUS": 0x17,
+    "EV_MAX": 0x1f,
+    }
+event_types["EV_CNT"] = event_types["EV_MAX"] + 1,
+
+event_names = {
+    "EV_SYN": "Sync",
+    "EV_KEY": "Keys or Buttons",
+    "EV_REL": "Relative Axes",
+    "EV_ABS": "Absolute Axes",
+    "EV_MSC": "Miscellaneous",
+    "EV_SW": "Switches",
+    "EV_LED": "Leds",
+    "EV_SND": "Sound",
+    "EV_REP": "Repeat",
+    "EV_FF": "Force Feedback",
+    "EV_PWR": "Power Management",
+    "EV_FF_STATUS": "Force Feedback Status",
+}
+
+absolute_axes = {
+    "ABS_X": 0x00,
+    "ABS_Y": 0x01,
+    "ABS_Z": 0x02,
+    "ABS_RX": 0x03,
+    "ABS_RY": 0x04,
+    "ABS_RZ": 0x05,
+    "ABS_THROTTLE": 0x06,
+    "ABS_RUDDER": 0x07,
+    "ABS_WHEEL": 0x08,
+    "ABS_GAS": 0x09,
+    "ABS_BRAKE": 0x0a,
+    "ABS_HAT0X": 0x10,
+    "ABS_HAT0Y": 0x11,
+    "ABS_HAT1X": 0x12,
+    "ABS_HAT1Y": 0x13,
+    "ABS_HAT2X": 0x14,
+    "ABS_HAT2Y": 0x15,
+    "ABS_HAT3X": 0x16,
+    "ABS_HAT3Y": 0x17,
+    "ABS_PRESSURE": 0x18,
+    "ABS_DISTANCE": 0x19,
+    "ABS_TILT_X": 0x1a,
+    "ABS_TILT_Y": 0x1b,
+    "ABS_TOOL_WIDTH": 0x1c,
+    "ABS_VOLUME": 0x20,
+    "ABS_MISC": 0x28,
+    "ABS_MT_SLOT": 0x2f,  # MT slot being modified
+    "ABS_MT_TOUCH_MAJOR": 0x30,  # Major axis of touching ellipse
+    "ABS_MT_TOUCH_MINOR": 0x31,  # Minor axis (omit if circular)
+    "ABS_MT_WIDTH_MAJOR": 0x32,  # Major axis of approaching ellipse
+    "ABS_MT_WIDTH_MINOR": 0x33,  # Minor axis (omit if circular)
+    "ABS_MT_ORIENTATION": 0x34,  # Ellipse orientation
+    "ABS_MT_POSITION_X": 0x35,  # Center X ellipse position
+    "ABS_MT_POSITION_Y": 0x36,  # Center Y ellipse position
+    "ABS_MT_TOOL_TYPE": 0x37,  # Type of touching device
+    "ABS_MT_BLOB_ID": 0x38,  # Group a set of packets as a blob
+    "ABS_MT_TRACKING_ID": 0x39,  # Unique ID of initiated contact
+    "ABS_MT_PRESSURE": 0x3a,  # Pressure on contact area
+    "ABS_MT_DISTANCE": 0x3b, # Contact hover distance
+    "ABS_MAX": 0x3f,
+    }
+# XXX ABS_CNT doesn't always give the same value from test data; disabling it
+# for now.
+#absolute_axes["ABS_CNT"] = absolute_axes["ABS_MAX"] + 1
+
+buttons = {
+    "BTN_MISC": 0x100,
+    "BTN_0": 0x100,
+    "BTN_1": 0x101,
+    "BTN_2": 0x102,
+    "BTN_3": 0x103,
+    "BTN_4": 0x104,
+    "BTN_5": 0x105,
+    "BTN_6": 0x106,
+    "BTN_7": 0x107,
+    "BTN_8": 0x108,
+    "BTN_9": 0x109,
+
+    "BTN_MOUSE": 0x110,
+    "BTN_LEFT": 0x110,
+    "BTN_RIGHT": 0x111,
+    "BTN_MIDDLE": 0x112,
+    "BTN_SIDE": 0x113,
+    "BTN_EXTRA": 0x114,
+    "BTN_FORWARD": 0x115,
+    "BTN_BACK": 0x116,
+    "BTN_TASK": 0x117,
+
+    "BTN_JOYSTICK": 0x120,
+    "BTN_TRIGGER": 0x120,
+    "BTN_THUMB": 0x121,
+    "BTN_THUMB2": 0x122,
+    "BTN_TOP": 0x123,
+    "BTN_TOP2": 0x124,
+    "BTN_PINKIE": 0x125,
+    "BTN_BASE": 0x126,
+    "BTN_BASE2": 0x127,
+    "BTN_BASE3": 0x128,
+    "BTN_BASE4": 0x129,
+    "BTN_BASE5": 0x12a,
+    "BTN_BASE6": 0x12b,
+    "BTN_DEAD": 0x12f,
+
+    "BTN_GAMEPAD": 0x130,
+    "BTN_A": 0x130,
+    "BTN_B": 0x131,
+    "BTN_C": 0x132,
+    "BTN_X": 0x133,
+    "BTN_Y": 0x134,
+    "BTN_Z": 0x135,
+    "BTN_TL": 0x136,
+    "BTN_TR": 0x137,
+    "BTN_TL2": 0x138,
+    "BTN_TR2": 0x139,
+    "BTN_SELECT": 0x13a,
+    "BTN_START": 0x13b,
+    "BTN_MODE": 0x13c,
+    "BTN_THUMBL": 0x13d,
+    "BTN_THUMBR": 0x13e,
+
+    "BTN_DIGI": 0x140,
+    "BTN_TOOL_PEN": 0x140,
+    "BTN_TOOL_RUBBER": 0x141,
+    "BTN_TOOL_BRUSH": 0x142,
+    "BTN_TOOL_PENCIL": 0x143,
+    "BTN_TOOL_AIRBRUSH": 0x144,
+    "BTN_TOOL_FINGER": 0x145,
+    "BTN_TOOL_MOUSE": 0x146,
+    "BTN_TOOL_LENS": 0x147,
+    "BTN_TOUCH": 0x14a,
+    "BTN_STYLUS": 0x14b,
+    "BTN_STYLUS2": 0x14c,
+    "BTN_TOOL_DOUBLETAP": 0x14d,
+    "BTN_TOOL_TRIPLETAP": 0x14e,
+    "BTN_TOOL_QUADTAP": 0x14f, # Four fingers on trackpad
+
+    "BTN_WHEEL": 0x150,
+    "BTN_GEAR_DOWN": 0x150,
+    "BTN_GEAR_UP": 0x151,
+
+    "BTN_TRIGGER_HAPPY": 0x2c0,
+    "BTN_TRIGGER_HAPPY1": 0x2c0,
+    "BTN_TRIGGER_HAPPY2": 0x2c1,
+    "BTN_TRIGGER_HAPPY3": 0x2c2,
+    "BTN_TRIGGER_HAPPY4": 0x2c3,
+    "BTN_TRIGGER_HAPPY5": 0x2c4,
+    "BTN_TRIGGER_HAPPY6": 0x2c5,
+    "BTN_TRIGGER_HAPPY7": 0x2c6,
+    "BTN_TRIGGER_HAPPY8": 0x2c7,
+    "BTN_TRIGGER_HAPPY9": 0x2c8,
+    "BTN_TRIGGER_HAPPY10": 0x2c9,
+    "BTN_TRIGGER_HAPPY11": 0x2ca,
+    "BTN_TRIGGER_HAPPY12": 0x2cb,
+    "BTN_TRIGGER_HAPPY13": 0x2cc,
+    "BTN_TRIGGER_HAPPY14": 0x2cd,
+    "BTN_TRIGGER_HAPPY15": 0x2ce,
+    "BTN_TRIGGER_HAPPY16": 0x2cf,
+    "BTN_TRIGGER_HAPPY17": 0x2d0,
+    "BTN_TRIGGER_HAPPY18": 0x2d1,
+    "BTN_TRIGGER_HAPPY19": 0x2d2,
+    "BTN_TRIGGER_HAPPY20": 0x2d3,
+    "BTN_TRIGGER_HAPPY21": 0x2d4,
+    "BTN_TRIGGER_HAPPY22": 0x2d5,
+    "BTN_TRIGGER_HAPPY23": 0x2d6,
+    "BTN_TRIGGER_HAPPY24": 0x2d7,
+    "BTN_TRIGGER_HAPPY25": 0x2d8,
+    "BTN_TRIGGER_HAPPY26": 0x2d9,
+    "BTN_TRIGGER_HAPPY27": 0x2da,
+    "BTN_TRIGGER_HAPPY28": 0x2db,
+    "BTN_TRIGGER_HAPPY29": 0x2dc,
+    "BTN_TRIGGER_HAPPY30": 0x2dd,
+    "BTN_TRIGGER_HAPPY31": 0x2de,
+    "BTN_TRIGGER_HAPPY32": 0x2df,
+    "BTN_TRIGGER_HAPPY33": 0x2e0,
+    "BTN_TRIGGER_HAPPY34": 0x2e1,
+    "BTN_TRIGGER_HAPPY35": 0x2e2,
+    "BTN_TRIGGER_HAPPY36": 0x2e3,
+    "BTN_TRIGGER_HAPPY37": 0x2e4,
+    "BTN_TRIGGER_HAPPY38": 0x2e5,
+    "BTN_TRIGGER_HAPPY39": 0x2e6,
+    "BTN_TRIGGER_HAPPY40": 0x2e7,
+    }

=== added file 'python/evemu/exception.py'
--- python/evemu/exception.py	1970-01-01 00:00:00 +0000
+++ python/evemu/exception.py	2011-11-30 21:40:28 +0000
@@ -0,0 +1,22 @@
+class EvEmuError(Exception):
+    pass
+
+
+class WrapperError(EvEmuError):
+    pass
+
+
+class ExecutionError(EvEmuError):
+    pass
+
+
+class TestError(EvEmuError):
+    pass
+
+
+class NullFileHandleError(EvEmuError):
+    pass
+
+
+class SkipTest(Exception):
+    pass

=== added directory 'python/evemu/testing'
=== added file 'python/evemu/testing/__init__.py'
=== added file 'python/evemu/testing/mocker.py'
--- python/evemu/testing/mocker.py	1970-01-01 00:00:00 +0000
+++ python/evemu/testing/mocker.py	2011-11-30 21:40:28 +0000
@@ -0,0 +1,5 @@
+"""
+This module is for use by unit tests in order to mock the uinput device. This
+alleviates the need for root access, and thus makes the unit tests something
+that can be run by packaging software.
+"""

=== added file 'python/evemu/testing/result.py'
--- python/evemu/testing/result.py	1970-01-01 00:00:00 +0000
+++ python/evemu/testing/result.py	2011-11-30 21:40:28 +0000
@@ -0,0 +1,48 @@
+import unittest
+try:
+    # Python 2.7
+    from unittest import TextTestResult
+except ImportError:
+    # Python 2.4, 2.5, 2.6
+    from unittest import _TextTestResult as TextTestResult
+
+
+def get_test_directory():
+    from evemu import tests
+    return tests.__path__[0]
+
+
+def get_test_module():
+    return get_test_directory().replace("/", ".")
+
+
+class CustomTestResult(TextTestResult):
+
+    def __init__(self, *args, **kwds):
+        super(CustomTestResult, self).__init__(*args, **kwds)
+        self.current_module = ""
+        self.last_module = ""
+        self.current_class = ""
+        self.last_class = ""
+
+    def startTest(self, test):
+        unittest.TestResult.startTest(self, test)
+        if not self.showAll:
+            return
+        self.last_module = self.current_module
+        self.last_class = self.current_class
+        method = test._testMethodName
+        module_and_class = test.id().rsplit(method)[0][:-1]
+        this_module = ".".join(module_and_class.split(".")[:-1])
+        self.current_module = this_module
+        this_class = module_and_class.split(".")[-1]
+        self.current_class = this_class
+        if self.last_module != self.current_module:
+            heading = "\n%s.%s" % (get_test_module(), this_module)
+            self.stream.writeln(heading)
+        if self.last_class != self.current_class:
+            self.stream.writeln("    %s" % this_class)
+        self.stream.write("        %s " % method.ljust(50, "."))
+        self.stream.write(" ")
+        self.stream.flush()
+

=== added file 'python/evemu/testing/runner.py'
--- python/evemu/testing/runner.py	1970-01-01 00:00:00 +0000
+++ python/evemu/testing/runner.py	2011-11-30 21:40:28 +0000
@@ -0,0 +1,63 @@
+import os
+import unittest
+
+from evemu.testing import result
+
+
+def get_test_directory():
+    from evemu import tests
+    return tests.__path__[0]
+
+
+class CustomTestRunner(unittest.TextTestRunner):
+    """
+    This is only needed for Python 2.6 and lower.
+    """
+    def _makeResult(self):
+        return result.CustomTestResult(
+            self.stream, self.descriptions, self.verbosity)
+
+
+def get_suite(loader, top_level_directory):
+    if hasattr(loader, "discover"):
+        # Python 2.7
+        suite = loader.discover(top_level_directory)
+    else:
+        # Python 2.4, 2.5, 2.6
+        names = []
+        def _path_to_module(path):
+            # generate dotted names for file paths
+            path = path.replace(".py", "")
+            return path.replace("/", ".")
+
+        # walk the directory
+        for dirpath, dirnames, filenames in os.walk(top_level_directory):
+            modules = [
+                _path_to_module(os.path.join(dirpath, x)) for x in filenames 
+                    if x.startswith("test_") and x.endswith(".py")]
+            if not modules:
+                continue
+            names.extend(modules)
+        suite = loader.loadTestsFromNames(names)
+    return suite
+
+
+def get_runner():
+    try:
+        # Python 2.7
+        runner = unittest.TextTestRunner(
+            verbosity=2, resultclass=result.CustomTestResult)
+    except TypeError:
+        # Python 2.4, 2.5, 2.6
+        runner = CustomTestRunner(verbosity=2)
+    return runner
+
+
+def run_tests():
+    loader = unittest.TestLoader()
+    suite = get_suite(loader, get_test_directory())
+    get_runner().run(suite)
+
+
+if __name__ == "__main__":
+    run_tests()

=== added file 'python/evemu/testing/testcase.py'
--- python/evemu/testing/testcase.py	1970-01-01 00:00:00 +0000
+++ python/evemu/testing/testcase.py	2011-11-30 21:40:28 +0000
@@ -0,0 +1,70 @@
+from ctypes.util import find_library
+import os
+import unittest
+
+from evemu import const
+from evemu import exception
+
+
+def get_top_directory():
+    import evemu
+    return evemu.__path__[0]
+
+
+def skip(message):
+    try:
+        return unittest.skip(message)
+    except AttributeError:
+        def _skip(message):
+            def decorator(test_item):
+                def skip_wrapper(*args, **kwds):
+                    raise exception.SkipTest(message)
+                return skip_wrapper
+            return decorator
+        return _skip(message)
+
+
+class Non26BaseTestCase(unittest.TestCase):
+    """
+    This is to provide methods that aren't in 2.6 and below, but are in 2.7 and
+    above.
+    """
+    def __init__(self, *args, **kwds):
+        super(Non26BaseTestCase, self).__init__(*args, **kwds)
+        if not hasattr(unittest.TestCase, "assertIn"):
+            self.assertIn = self._assertIn26
+
+    def _assertIn26(self, member, container, msg=None):
+        """Just like self.assertTrue(a in b), but with a nicer default message."""
+        if member not in container:
+            standardMsg = '%s not found in %s' % (repr(member),
+                                                  repr(container))
+            self.fail(msg or standardMsg)
+
+
+class BaseTestCase(unittest.TestCase):
+
+    def setUp(self):
+        super(BaseTestCase, self).setUp()
+        library = find_library(const.LIB)
+        if not library:
+            if os.path.exists(const.DEFAULT_LIB):
+                library = const.DEFAULT_LIB
+            else:
+                library = const.LOCAL_LIB
+        self.library = library
+        basedir = get_top_directory()
+        self.data_dir = os.path.join(basedir, "..", "..", "data")
+        self.device = None
+
+    def tearDown(self):
+       if self.device:
+            self.device.destroy()
+       super(BaseTestCase, self).tearDown()
+
+    def get_device_file(self):
+        return os.path.join(self.data_dir, "ntrig-dell-xt2.prop")
+
+    def get_events_file(self):
+        return os.path.join(self.data_dir, "ntrig-dell-xt2.event")
+

=== added directory 'python/evemu/tests'
=== added file 'python/evemu/tests/__init__.py'
=== added file 'python/evemu/tests/test_base.py'
--- python/evemu/tests/test_base.py	1970-01-01 00:00:00 +0000
+++ python/evemu/tests/test_base.py	2011-11-30 21:40:28 +0000
@@ -0,0 +1,25 @@
+import unittest
+
+from evemu import const
+from evemu.base import EvEmuBase
+from evemu.testing import testcase
+
+
+class EvEmuBaseTestCase(testcase.BaseTestCase):
+
+    def test_so_library_found(self):
+        wrapper = EvEmuBase(self.library)
+        # Make sure that the library loads
+        self.assertNotEqual(
+            wrapper._lib._name.find("libutouch-evemu"), -1)
+
+    def test_c_symbols_found(self):
+        # Make sure that the expected functions are present
+        wrapper = EvEmuBase(self.library)
+        for function_name in const.API:
+            function = getattr(wrapper._lib, function_name)
+            self.assertTrue(function is not None)
+
+
+if __name__ == "__main__":
+    unittest.main()

=== added file 'python/evemu/tests/test_device.py'
--- python/evemu/tests/test_device.py	1970-01-01 00:00:00 +0000
+++ python/evemu/tests/test_device.py	2011-11-30 21:40:28 +0000
@@ -0,0 +1,223 @@
+
+from evemu.testing import testcase
+from multiprocessing import Process, Queue, Event
+
+import evemu
+import os
+import re
+import tempfile
+import unittest
+
+
+def record(recording_started, device_node, q):
+    """
+    Runs the recorder in a separate process because the evemu API is a
+    blocking API.
+    """
+    device = evemu.Device(device_node)
+    with tempfile.TemporaryFile() as event_file:
+        recording_started.set()
+        device.record(event_file, 1000)
+        event_file.flush()
+        event_file.seek(0)
+        outdata = event_file.readlines()
+        q.put(outdata)
+
+
+class DeviceActionTestCase(testcase.BaseTestCase):
+    """
+    Verifies the high-level Device functions (create, describe, play, record).
+    """
+
+    def test_construct_from_dev_node_name(self):
+        """
+        Verifies a Device can be constructed from an existing input device node
+        name.
+        """
+        d = evemu.Device("/dev/input/event10")
+
+    def test_construct_from_dev_node_file(self):
+        """
+        Verifies a Device can be constructed from an existing input device node
+        file object.
+        """
+        d = evemu.Device(open("/dev/input/event10"))
+
+    def test_construct_from_prop_file_name(self):
+        """
+        Verifies a device can be constructed from an evemu prop file name.
+        """
+        d = evemu.Device(self.get_device_file())
+
+    def test_construct_from_prop_file_file(self):
+        """
+        Verifies a device can be constructed from an evemu prop file file
+        object.
+        """
+        d = evemu.Device(open(self.get_device_file()))
+
+    def test_describe(self):
+        """
+        Verifies that a device description can be correctly extracted from a
+        Device.
+        """
+        # Get original description
+        with open(self.get_device_file()) as f:
+            data = f.readlines()
+
+        # Create a pseudo device with that description
+        d = evemu.Device(self.get_device_file())
+
+        # get the description to a temporary file
+        with tempfile.TemporaryFile() as t:
+            d.describe(t)
+
+            # read in the temporary file and compare to the original
+            t.flush()
+            t.seek(0)
+            newdata = t.readlines()
+            self.assertEquals(data, newdata)
+
+    def test_play_and_record(self):
+        """
+        Verifies that a Device and play back prerecorded events.
+        """
+        device = evemu.Device(self.get_device_file())
+        devnode = device.devnode
+        events_file = self.get_events_file()
+        with open(events_file) as e:
+            indata = e.readlines()
+
+        recording_started = Event()
+        q = Queue()
+        record_process = Process(target=record,
+                                 args=(recording_started, devnode, q))
+        record_process.start()
+        recording_started.wait(100)
+        device.play(open(events_file))
+
+        outdata = q.get()
+        record_process.join()
+
+        self.assertEquals(len(indata), len(outdata))
+        fuzz = re.compile("E: \d+\.\d+ (.*)")
+        for i in range(len(indata)):
+            lhs = fuzz.match(indata[i])
+            self.assertTrue(lhs)
+            rhs = fuzz.match(outdata[i])
+            self.assertTrue(rhs)
+            self.assertEquals(lhs.group(1), rhs.group(1))
+
+
+class DevicePropertiesTestCase(testcase.BaseTestCase):
+    """
+    Verifies the workings of the various device property accessors.
+    """
+
+    def setUp(self):
+        super(DevicePropertiesTestCase, self).setUp()
+        self._device = evemu.Device(self.get_device_file())
+
+    def tearDown(self):
+        del self._device
+        super(DevicePropertiesTestCase, self).tearDown()
+
+    def test_version(self):
+        self.assertEqual(self._device.version, 0)
+
+    def test_name(self):
+        self.assertEqual(self._device.name, "N-Trig-MultiTouch-Virtual-Device")
+
+    def test_id_bustype(self):
+        self.assertEqual(self._device.id_bustype, 3)
+
+    def test_id_vendor(self):
+        self.assertEqual(hex(self._device.id_vendor), "0x1b96")
+
+    def test_id_product(self):
+        self.assertEqual(self._device.id_product, 1)
+
+    def test_id_version(self):
+        self.assertEqual(self._device.id_version, 272)
+
+    def test_get_abs_minimum(self):
+        expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            ]
+        results = [self._device.get_abs_minimum(x) 
+                   for x in evemu.const.absolute_axes.values()]
+        self.assertEqual(results, expected)
+
+    def test_get_abs_maximum(self):
+        expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9600, 7200, 0, 0, 0, 0,
+            7200, 1, 7200, 0, 9600, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9600,
+            0, 0,
+            ]
+        # Skipping the entry for ABS_CNT; some times it's 0, sometimes a very
+        # large negative number.
+        results = [self._device.get_abs_maximum(x) 
+                   for x in evemu.const.absolute_axes.values()]
+        self.assertEqual(results[:-1], expected[:-1])
+
+    def test_get_abs_fuzz(self):
+        expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 75, 78, 0, 0, 0, 0, 150,
+            0, 78, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 200, 0, 0, 
+            ]
+        results = [self._device.get_abs_fuzz(x) 
+                   for x in evemu.const.absolute_axes.values()]
+        self.assertEqual(results, expected)
+
+    def test_get_abs_flat(self):
+        expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            ]
+        results = [self._device.get_abs_flat(x) 
+                   for x in evemu.const.absolute_axes.values()]
+        self.assertEqual(results, expected)
+
+    def test_get_abs_resolution(self):
+        expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            ]
+        results = [self._device.get_abs_resolution(x) 
+                   for x in evemu.const.absolute_axes.values()]
+        self.assertEqual(results, expected)
+
+    def test_has_prop(self):
+        expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            ]
+        results = [self._device.has_prop(x) 
+                   for x in evemu.const.absolute_axes.values()]
+        self.assertEqual(results, expected)
+
+    def test_has_event_ev_abs(self):
+        expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1,
+            1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+            ]
+        results = [self._device.has_event(evemu.const.event_types["EV_ABS"], x) 
+                   for x in evemu.const.absolute_axes.values()]
+        self.assertEqual(results, expected)
+
+    def test_has_event_ev_key(self):
+        expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            ]
+        results = [self._device.has_event(evemu.const.event_types["EV_KEY"], x) 
+                   for x in evemu.const.buttons.values()]
+        self.assertEqual(results, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

=== added file 'python/setup.py'
=== modified file 'src/evemu.c'
--- src/evemu.c	2011-11-02 13:49:33 +0000
+++ src/evemu.c	2011-11-30 21:40:28 +0000
@@ -337,7 +337,7 @@
 
 	memset(dev, 0, sizeof(*dev));
 
-	ret = fscanf(fp, "N: %ms\n", &devname);
+	ret = fscanf(fp, "N: %m[^\n]\n", &devname);
 	if (ret <= 0) {
 		if (devname != NULL)
 			free(devname);