Merge lp:~pitti/platform-api/test-backend into lp:platform-api

[Martin Pitt]

Add backend for simulated sensor data.

This provides an initial implementation of simulated sensors, as discussed in
http://pad.ubuntu.com/sensors-testing.

You can now run an app with the simulated sensor backend
(UBUNTU_PLATFORM_API_BACKEND=libubuntu_application_test_api.so) and point it to
a simulation data file (UBUNTU_PLATFORM_API_SENSOR_TEST=/path/to/test.sensor)
and get these events delivered.

This also introduces a test suite and tests for the simulation sensor backend.

Note that this will currently fail, we need to land
https://code.launchpad.net/~thomas-voss/process-cpp/fix_pkgconfig_setup/+merge/198025
and then add a versioned build dep. This also adopts the rather higher-level black magic TEST_FP macro, so that this can go away.

This is an initial MP for reviewing the general structure, my code style (I'm a
C++ novice, so please tell me what to improve), the test structure, etc.

[Martin Pitt (pitti)]

Note that this just provides the initial building blocks. Once that lands, we most probably want to add some more commands to the test data files, such as a command to create a set of standard sensors, or composite events like "turn device by 90 degrees" (either by new commands, or by providing a library of test data files, remains to be discussed).

I'll also create some tests in qtubuntu-sensors which use the QtSensors API, to ensure that the data is correctly passed back and forth through QtSensors/qtubuntu-sensors/platform-api.

[Martin Pitt (pitti)]

Note to self: Need to package/ship new backend and README.

[Thomas Voß (thomas-voss)]

Looks great, thanks for getting the testing effort started :)

A few minor niggles:

l. 300ff: You can switch "class" to "struct" and get rid of the explicit "public" specifiers. No need to make it a class if default visibility is public.

l. 341ff: Instead of returning a pointer (and managing its lifetime), you could as well return a mutable reference and initialize it as in:

static SensorController& instance()
{
    static SensorController inst_;
    return inst_;
}

With that, the instance is created exactly once on first access, and released after main automatically.

In line 381, you could then make the type->sensor instance mapping non-static, and switch to a shared_ptr for handling the lifetime of the pointer: map<ubuntu_sensor_type, std::shared_ptr<TestSensor>> sensors.

For stylistic karma: The functions handling time could be switched over to use std::chrono (see http://en.cppreference.com/w/cpp/chrono/duration). With that, you don't need comments in the source code specifying the timebase but just return std::chrono::microseconds or std::chrono::nanoseconds. Casting between time bases happens automatically then. With std::chrono, the current time can be sampled with std::chrono::high_resolution_clock::now() or std::chrono::steady_clock::now().

review: Needs Fixing

[Martin Pitt (pitti)]

Did the changes Thomas suggested in his review, thanks!

[Martin Pitt (pitti)]

More code review appreciated, but so far I'm happy with this as a first version. Plan:

- Wait for process-cpp to land, then bump build-dep on it in this MP
- Get this MP landed
- Add some high-level integration tests to qtubuntu-sensors which use the QtSensors API, to make sure that qtsensors-opensource-src → qtubuntusensors → platform-api communication all works (not blocked by the above, can be developed in parallel)
- land these tests

After that we should meet with some app developers to discuss what kind of more abstract events they would like to get, and add them to our sensor test API (the file parser).

[Martin Pitt (pitti)]

process-cpp landed at last, so I made the necessary build-dep changes and dropped TEST_FP which now moved into process-cpp. Ready now from my POV.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:202
http://jenkins.qa.ubuntu.com/job/platform-api-ci/172/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-amd64-ci/6
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-armhf-ci/6/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-i386-ci/6

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/platform-api-ci/172/rebuild

review: Needs Fixing (continuous-integration)

[lp:~pitti/platform-api/test-backend]

203. By Martin Pitt on 2013-12-12

Declare functions which return float as "aapcs" calling convention on ARM, like the hybris library

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:203
http://jenkins.qa.ubuntu.com/job/platform-api-ci/173/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-amd64-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-armhf-ci/7
        deb: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-armhf-ci/7/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-i386-ci/7

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/platform-api-ci/173/rebuild

review: Approve (continuous-integration)

[lp:~pitti/platform-api/test-backend]

204. By Martin Pitt on 2013-12-12

avoid integer overflow in itimerspec calculation, and fix precision warnings

[Thomas Voß (thomas-voss)]

LGTM, again: Thanks for getting this started.

review: Approve

[Martin Pitt (pitti)]

Ricardo, can you please do another review, and top-approve if you are happy with it? Thanks!

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:204
http://jenkins.qa.ubuntu.com/job/platform-api-ci/174/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-amd64-ci/8
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-armhf-ci/8
        deb: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-armhf-ci/8/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-i386-ci/8

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/platform-api-ci/174/rebuild

review: Approve (continuous-integration)

[Martin Pitt (pitti)]

Notes from IRC from Rick: It should stop building a *.so symlink for the test backend, and libubuntu-application-test-api1 should be libubuntu-application-api-test1 to follow naming for mirserver/mirclient/hybris backends.

Another thing to look at: the test .so only provides the sensor functions, not the whole thing; the bridge could be more clever about that and load the other symbols from the real backend; but that's supposedly not blocking the MP.

[lp:~pitti/platform-api/test-backend]

205. By Martin Pitt on 2014-01-08

merge with trunk

206. By Martin Pitt on 2014-01-08

Don't install a *.so symlink for libubuntu_application_test_api

This is not a development library to link against, and users (i. e. test
suites) should always specify the ABI version.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:206
http://jenkins.qa.ubuntu.com/job/platform-api-ci/186/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-amd64-ci/20
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-armhf-ci/20
        deb: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-armhf-ci/20/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-i386-ci/20

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/platform-api-ci/186/rebuild

review: Approve (continuous-integration)

[Ricardo Mendoza (ricmm)]

As said by pitti the missing providers for non-sensor related helpers is not a blocker for this MR, as this lays the groundwork for the general testing and implements only the sensor backend.

A followup MR will split backends and make more smart use of the bridge to dynamically load each component area.

Currently just missing the package/SO rename and it should be good to go.

review: Needs Fixing

[lp:~pitti/platform-api/test-backend]

207. By Martin Pitt on 2014-01-08

rename libubuntu-application-test-api1 to libubuntu-application-api-test1

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:207
http://jenkins.qa.ubuntu.com/job/platform-api-ci/187/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-amd64-ci/21
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-armhf-ci/21
        deb: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-armhf-ci/21/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-trusty-i386-ci/21

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/platform-api-ci/187/rebuild

review: Approve (continuous-integration)

[Ricardo Mendoza (ricmm)]

Looks good, tested across devices. All comments addressed.

Landing.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-08-22 06:32:14 +0000
+++ CMakeLists.txt	2014-01-08 15:17:50 +0000
@@ -93,3 +93,9 @@
 add_subdirectory(doc/)
 add_subdirectory(include/)
 add_subdirectory(src/)
+
+#### Enable tests
+include(CTest)
+set(GTEST_ROOT /usr/src/gtest)
+add_subdirectory(tests/)
+add_subdirectory(${GTEST_ROOT} ${CMAKE_CURRENT_BINARY_DIR}/gtest)
 
=== modified file 'debian/control'
--- debian/control	2014-01-02 21:25:57 +0000
+++ debian/control	2014-01-08 15:17:50 +0000
@@ -17,6 +17,8 @@
                libdbus-1-dev,
                dbus-cpp-dev,
                libubuntu-location-service-dev,
+               libgtest-dev,
+               libprocess-cpp-dev (>= 0.0.1+14.04.20131212),
 Standards-Version: 3.9.4
 Homepage: https://launchpad.net/platform-api
 Vcs-Bzr: lp:platform-api
@@ -142,6 +144,22 @@
  The produced library should be used via libhybris, to communicate with the
  Android userspace, which is where the Ubuntu Application Manager lives.
 
+Package: libubuntu-application-api-test1
+Section: libs
+Architecture: any
+Pre-Depends: ${misc:Pre-Depends},
+Multi-Arch: same
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Description: test implementation of the Platform API
+ This package provides an implementation of the Platform API for testing. It
+ does not communicate with actual hardware, but reads input from a text file.
+ .
+ You need to explicitly enable this at runtime. Please see the README for
+ details.
+ .
+ For now this provides simulated sensors.
+
 Package: libplatform-api1-hybris-tests
 Architecture: any
 Depends: ${misc:Depends},
 
=== added file 'debian/libubuntu-application-api-test1.docs'
--- debian/libubuntu-application-api-test1.docs	1970-01-01 00:00:00 +0000
+++ debian/libubuntu-application-api-test1.docs	2014-01-08 15:17:50 +0000
@@ -0,0 +1,1 @@
+src/ubuntu/testbackend/README.md
 
=== added file 'debian/libubuntu-application-api-test1.install'
--- debian/libubuntu-application-api-test1.install	1970-01-01 00:00:00 +0000
+++ debian/libubuntu-application-api-test1.install	2014-01-08 15:17:50 +0000
@@ -0,0 +1,1 @@
+usr/lib/*/libubuntu_application_api_test.so.*
 
=== modified file 'debian/rules'
--- debian/rules	2013-08-14 12:16:09 +0000
+++ debian/rules	2014-01-08 15:17:50 +0000
@@ -13,3 +13,9 @@
 
 overrid_dh_install:
 	dh_install --fail-missing
+
+override_dh_auto_test:
+ifeq (, $(findstring nocheck, $(DEB_BUILD_OPTIONS)))
+	cd obj-* && ctest --verbose
+endif
+
 
=== modified file 'src/ubuntu/CMakeLists.txt'
--- src/ubuntu/CMakeLists.txt	2013-08-23 13:48:59 +0000
+++ src/ubuntu/CMakeLists.txt	2014-01-08 15:17:50 +0000
@@ -3,6 +3,7 @@
 )
 
 add_subdirectory(application)
+add_subdirectory(testbackend)
 
 set(
   UBUNTU_APPLICATION_API_LINK_LIBRARIES
@@ -25,4 +26,4 @@
 
 if(ENABLE_MIRCLIENT_IMPLEMENTATION)
   add_subdirectory(mirclient/)
-endif()
 \ No newline at end of file
+endif()
 
=== modified file 'src/ubuntu/hybris/CMakeLists.txt'
--- src/ubuntu/hybris/CMakeLists.txt	2013-08-17 05:22:31 +0000
+++ src/ubuntu/hybris/CMakeLists.txt	2014-01-08 15:17:50 +0000
@@ -27,6 +27,7 @@
 
 target_link_libraries(
   ubuntu_platform_hardware_api
+  dl
   hybris-common
 )
 
 
=== modified file 'src/ubuntu/hybris/bridge.h'
--- src/ubuntu/hybris/bridge.h	2013-12-03 07:27:23 +0000
+++ src/ubuntu/hybris/bridge.h	2014-01-08 15:17:50 +0000
@@ -22,6 +22,8 @@
 #include <assert.h>
 #include <dlfcn.h>
 #include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
 
 #define HIDDEN_SYMBOL __attribute__ ((visibility ("hidden")))
 
@@ -39,19 +41,24 @@
 namespace internal
 {
 
+/* By default we load the backend from /system/lib/libubuntu_application_api.so
+ * Programs can select a different backend with $UBUNTU_PLATFORM_API_BACKEND,
+ * which either needs to be a full path or just the file name (then it will be
+ * looked up in the usual library search path, see dlopen(3)).
+ */
 struct HIDDEN_SYMBOL ToApplication
 {
     static const char* path()
     {
-        return "/system/lib/libubuntu_application_api.so";
-    }
-};
-
-struct HIDDEN_SYMBOL ToHardware
-{
-    static const char* path()
-    {
-        return "/system/lib/libubuntu_platform_hardware_api.so";
+        static const char* cache = NULL;
+
+        if (cache == NULL) {
+            cache = secure_getenv("UBUNTU_PLATFORM_API_BACKEND");
+            if (cache == NULL)
+                cache = "/system/lib/libubuntu_application_api.so";
+        }
+
+        return cache;
     }
 };
 
@@ -67,12 +74,23 @@
 
     void* resolve_symbol(const char* symbol) const
     {
-        return android_dlsym(lib_handle, symbol);
+        return dlsym_fn(lib_handle, symbol);
     }
 
   protected:
     Bridge() : lib_handle(android_dlopen(Scope::path(), RTLD_LAZY))
     {
+        const char* path = Scope::path();
+        /* use Android dl functions for Android libs in /system/, glibc dl
+         * functions for others */
+        if (strncmp(path, "/system/", 8) == 0) {
+            lib_handle = android_dlopen(path, RTLD_LAZY);
+            dlsym_fn = android_dlsym;
+        } else {
+            lib_handle = dlopen(path, RTLD_LAZY);
+            dlsym_fn = dlsym;
+        }
+
         assert(lib_handle && "Error loading ubuntu_application_api");
     }
 
@@ -82,6 +100,7 @@
     }
 
     void* lib_handle;
+    void* (*dlsym_fn) (void*, const char*);
 };
 
 }
 
=== added directory 'src/ubuntu/testbackend'
=== added file 'src/ubuntu/testbackend/CMakeLists.txt'
--- src/ubuntu/testbackend/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/ubuntu/testbackend/CMakeLists.txt	2014-01-08 15:17:50 +0000
@@ -0,0 +1,21 @@
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11")
+
+add_library(
+  ubuntu_application_api_test SHARED
+  ubuntu_application_sensors.cpp
+)
+
+set_target_properties(
+  ubuntu_application_api_test
+  PROPERTIES
+  VERSION ${UBUNTU_PLATFORM_API_VERSION_MAJOR}.${UBUNTU_PLATFORM_API_VERSION_MINOR}.${UBUNTU_PLATFORM_API_VERSION_PATCH}
+  SOVERSION ${UBUNTU_PLATFORM_API_VERSION_MAJOR}
+)
+
+install(
+  TARGETS ubuntu_application_api_test
+  # this is not a development library to compile against, users should always
+  # specify the SONAME; so don't build a *.so
+  LIBRARY DESTINATION "${LIB_INSTALL_DIR}" NAMELINK_SKIP
+)
+
 
=== added file 'src/ubuntu/testbackend/README.md'
--- src/ubuntu/testbackend/README.md	1970-01-01 00:00:00 +0000
+++ src/ubuntu/testbackend/README.md	2014-01-08 15:17:50 +0000
@@ -0,0 +1,77 @@
+Testing applications with simulated sensor data
+===============================================
+
+Purpose
+-------
+platform-api's interface to sensor data is in the shared library
+`libubuntu_platform_hardware_api.so`. That is only a stub which dynamically
+(dlopen) loads a backend library which provides the actual implementation. By
+default this is `/system/lib/libubuntu_application_api.so` which reads sensor
+data from the Android side. For testing purposes this can be replaced with this
+`libubuntu_application_api_test.so.1` which simulates sensors and their data based
+on a simple text input file.
+
+Using the test sensors
+----------------------
+Run your application under test with the environment variable
+
+    UBUNTU_PLATFORM_API_BACKEND=libubuntu_application_api_test.so.1
+
+and make sure that ld.so(8) can find it. If you don't have the library
+installed in a standard system library path, it is recommended to set
+`LD_LIBRARY_PATH` to the directory that contains the library (usually when using
+the library right out of the build tree). Alternatively you can specify the
+full path in `$UBUNTU_PLATFORM_API_BACKEND`.
+
+The env variable `$UBUNTU_PLATFORM_API_SENSOR_TEST` needs to point to a file that
+describes the desired sensor behaviour.
+
+Data format
+-----------
+The test sensors use a simple line based file format. The first part
+instantiates desired sensors with their parameters:
+
+    create [accel|light] <min> <max> <resolution>
+    # but no arguments for proximity sensor: 
+    create proximity
+  
+After that, it defines events; <delay> specifies time after previous event
+in ms:
+
+    <delay> proximity [unknown|near|far]
+    <delay> light <value>
+    <delay> accel <x> <y> <z>
+
+Empty lines and comment lines (starting with #) are allowed.
+
+Example file:
+
+    create light 0 10 1
+    create accel 0 1000 0.1
+    create proximity
+     
+    200 proximity near
+    500 light 5
+    # simulate crash on the ground
+    500 accel 0.2 0.1 10
+    100 accel 0.2 0.2 1000
+    20 accel 0 0 0
+    10 proximity far
+    0 light 10
+
+
+Complete example
+----------------
+ * Build platform-api:
+
+        mkdir obj; (cd obj; cmake .. && make)
+
+ * Put above example file into /tmp/test.sensors
+
+ * Run the sensor test with it:
+ 
+        LD_LIBRARY_PATH=obj/src/ubuntu/testbackend \
+        UBUNTU_PLATFORM_API_BACKEND=libubuntu_application_api_test.so.1 \
+        UBUNTU_PLATFORM_API_SENSOR_TEST=/tmp/test.sensors \
+        obj/src/ubuntu/hybris/tests/test_android_sensors_api
+
 
=== added file 'src/ubuntu/testbackend/ubuntu_application_sensors.cpp'
--- src/ubuntu/testbackend/ubuntu_application_sensors.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/testbackend/ubuntu_application_sensors.cpp	2014-01-08 15:17:50 +0000
@@ -0,0 +1,553 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Martin Pitt <[e-mail]>
+ */
+
+#include <ubuntu/application/sensors/ubuntu_application_sensors.h>
+#include <ubuntu/application/sensors/accelerometer.h>
+#include <ubuntu/application/sensors/proximity.h>
+#include <ubuntu/application/sensors/light.h>
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cerrno>
+#include <csignal>
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <stdexcept>
+#include <chrono>
+#include <map>
+#include <memory>
+
+using namespace std;
+
+// necessary for functions that return float
+// pcs attribute (calling convention) is only defined on ARM, avoid warning on
+// other platforms
+#ifdef __arm__
+#define __SF_FN_ATTR __attribute__((pcs("aapcs")))
+#else
+#define __SF_FN_ATTR
+#endif
+
+
+/***************************************
+ *
+ * test sensor implementation
+ *
+ ***************************************/
+
+// this is only internal API, so we make everything public
+struct TestSensor
+{
+    TestSensor(ubuntu_sensor_type _type, float _min_value, float _max_value, float _resolution) :
+        type(_type),
+        enabled(false),
+        resolution(_resolution),
+        min_delay(0),
+        min_value(_min_value),
+        max_value(_max_value),
+        on_event_cb(NULL),
+        event_cb_context(NULL),
+        x(_min_value),
+        y(_min_value),
+        z(_min_value),
+        distance((UASProximityDistance) 0),  // LP#1256969
+        timestamp(0)
+    {}
+
+    ubuntu_sensor_type type;
+    bool enabled;
+    float resolution;
+    uint32_t min_delay;
+    float min_value, max_value;
+    void (*on_event_cb)(void*, void*);
+    void* event_cb_context;
+
+    /* current value; note that we do not track separate Event objects/pointers
+     * at all, and just always deliver the current value */
+    float x, y, z;
+    UASProximityDistance distance;
+    uint64_t timestamp;
+};
+
+/* Singleton which reads the sensor data file and maintains the TestSensor
+ * instances */
+class SensorController
+{
+  public:
+    // Ensure that controller is initialized, and return singleton
+    static SensorController& instance()
+    {
+        static SensorController _inst;
+        return _inst;
+    }
+
+    // Return TestSensor of given type, or NULL if it doesn't exist
+    TestSensor* get(ubuntu_sensor_type type)
+    {
+        try {
+            return sensors.at(type).get();
+        } catch (const out_of_range&) {
+            return NULL;
+        }
+    }
+
+  private:
+    SensorController();
+    bool next_command();
+    bool process_create_command();
+    void process_event_command();
+    void setup_timer(unsigned delay_ms);
+    static void on_timer(union sigval sval);
+
+    static ubuntu_sensor_type type_from_name(const string& type)
+    {
+        if (type == "light")
+            return ubuntu_sensor_type_light;
+        if (type == "proximity")
+            return ubuntu_sensor_type_proximity;
+        if (type == "accel")
+            return ubuntu_sensor_type_accelerometer;
+
+        cerr << "TestSensor ERROR: unknown sensor type " << type << endl;
+        abort();
+    }
+
+    map<ubuntu_sensor_type, shared_ptr<TestSensor>> sensors;
+    ifstream data;
+
+    // current command/event
+    string current_command;
+    TestSensor* event_sensor;
+    float event_x, event_y, event_z;
+    UASProximityDistance event_distance;
+};
+
+SensorController::SensorController()
+{
+    const char* path = getenv("UBUNTU_PLATFORM_API_SENSOR_TEST");
+
+    if (path == NULL) {
+        cerr << "TestSensor ERROR: Need $UBUNTU_PLATFORM_API_SENSOR_TEST to point to a data file\n";
+        abort();
+    }
+
+    //cout << "SensorController ctor: opening " << path << endl;
+
+    data.open(path);
+    if (!data.is_open()) {
+        cerr << "TestSensor ERROR: Failed to open data file " << path << ": " << strerror(errno) << endl;
+        abort();
+    }
+
+    // process all "create" commands
+    while (next_command()) {
+        if (!process_create_command())
+            break;
+    }
+
+    // start event processing
+    if (!data.eof())
+        process_event_command();
+}
+
+bool
+SensorController::next_command()
+{
+    while (getline(data, current_command)) {
+        // trim leading and trailing space
+        current_command.erase(0, current_command.find_first_not_of(" \t"));
+        current_command.erase(current_command.find_last_not_of(" \t") + 1);
+        // ignore empty or comment lines
+        if (current_command.size() == 0 || current_command[0] == '#')
+            continue;
+        return true;
+    }
+    return false;
+}
+
+bool
+SensorController::process_create_command()
+{
+    stringstream ss(current_command, ios_base::in);
+    string token;
+
+    // we only process "create" commands here; if we have something else, stop
+    ss >> token;
+    if (token != "create")
+        return false;
+
+    ss >> token;
+    ubuntu_sensor_type type = type_from_name(token);
+
+    if (get(type) != NULL) {
+        cerr << "TestSensor ERROR: duplicate creation of sensor type " << token << endl;
+        abort();
+    }
+
+    float min = 0, max = 0, resolution = 0;
+
+    if (type != ubuntu_sensor_type_proximity) {
+        // read min, max, resolution
+        ss >> min >> max >> resolution;
+
+        if (max <= min) {
+            cerr << "TestSensor ERROR: max_value must be >= min_value in  " << current_command << endl;
+            abort();
+        }
+        if (resolution <= 0) {
+            cerr << "TestSensor ERROR: resolution must be > 0 in " << current_command << endl;
+            abort();
+        }
+    }
+
+    //cout << "SensorController::process_create_command: type " << type << " min " << min << " max " << max << " res " << resolution << endl;
+
+    sensors[type] = make_shared<TestSensor>(type, min, max, resolution);
+    return true;
+}
+
+void
+SensorController::process_event_command()
+{
+    stringstream ss(current_command, ios_base::in);
+    int delay;
+
+    //cout << "TestSensor: processing event " << current_command << endl;
+
+    // parse delay
+    ss >> delay;
+    if (delay <= 0) {
+        cerr << "TestSensor ERROR: delay must be positive in command " << current_command << endl;
+        abort();
+    }
+
+    // parse sensor type
+    string token;
+    ss >> token;
+    ubuntu_sensor_type type = type_from_name(token);
+    event_sensor = get(type);
+    if (event_sensor == NULL) {
+        cerr << "TestSensor ERROR: sensor does not exist, you need to create it: " << token << endl;
+        abort();
+    }
+
+    switch (type) {
+        case ubuntu_sensor_type_light:
+            ss >> event_x;
+            //cout << "got event: sensor type " << type << " (light), delay "
+            //     << delay << " ms, value " << event_x << endl;
+            break;
+
+        case ubuntu_sensor_type_accelerometer:
+            ss >> event_x >> event_y >> event_z;
+            //cout << "got event: sensor type " << type << " (accel), delay "
+            //     << delay << " ms, value " << event_x << "/" << event_y << "/" << event_z << endl;
+            break;
+
+        case ubuntu_sensor_type_proximity:
+            ss >> token;
+            if (token == "unknown")
+                event_distance = (UASProximityDistance) 0;  // LP#1256969
+            else if (token == "near")
+                event_distance = U_PROXIMITY_NEAR;
+            else if (token == "far")
+                event_distance = U_PROXIMITY_FAR;
+            else {
+                cerr << "TestSensor ERROR: unknown proximity value " << token << endl;
+                abort();
+            }
+            //cout << "got event: sensor type " << type << " (proximity), delay "
+            //     << delay << " ms, value " << int(event_distance) << endl;
+            break;
+
+        default:
+            cerr << "TestSensor ERROR: unhandled sensor type " << token << endl;
+            abort();
+    }
+
+    // wake up after given delay for committing the change and processing the
+    // next event
+    setup_timer(unsigned(delay));
+}
+
+void
+SensorController::setup_timer(unsigned delay_ms)
+{
+    static timer_t timerid; // we keep a pointer to that until on_timer
+    struct sigevent sev;
+    struct itimerspec its { {0, 0}, // interval
+                            {time_t(delay_ms / 1000),
+                             long((delay_ms % 1000) * 1000000L) % 1000000000L } };
+
+    sev.sigev_notify = SIGEV_THREAD;
+    sev.sigev_notify_function = SensorController::on_timer;
+    sev.sigev_notify_attributes = NULL;
+    sev.sigev_value.sival_ptr = &timerid;
+
+    if (timer_create(CLOCK_MONOTONIC, &sev, &timerid) < 0) {
+        perror("TestSensor ERROR: Failed to create timer");
+        abort();
+    }
+    if (timer_settime(timerid, 0, &its, NULL) < 0) {
+        perror("TestSensor ERROR: Failed to set up timer");
+        abort();
+    };
+}
+
+void
+SensorController::on_timer(union sigval sval)
+{
+    timer_t* timerid = static_cast<timer_t*>(sval.sival_ptr);
+    //cout << "on_timer called\n";
+    timer_delete(*timerid);
+
+    SensorController& sc = SensorController::instance();
+
+    // update sensor values, call callback
+    if (sc.event_sensor && sc.event_sensor->enabled) {
+        sc.event_sensor->x = sc.event_x;
+        sc.event_sensor->y = sc.event_y;
+        sc.event_sensor->z = sc.event_z;
+        sc.event_sensor->distance = sc.event_distance;
+        sc.event_sensor->timestamp = chrono::duration_cast<chrono::nanoseconds>(
+                chrono::system_clock::now().time_since_epoch()).count();
+        if (sc.event_sensor->on_event_cb != NULL) {
+            //cout << "TestSensor: calling sensor callback for type " << sc.event_sensor->type << endl;
+            sc.event_sensor->on_event_cb(sc.event_sensor, sc.event_sensor->event_cb_context);
+        } else {
+            //cout << "TestSensor: sensor type " << sc.event_sensor->type << "has no callback\n";
+        }
+    } else {
+        //cout << "TestSensor: sensor type " << sc.event_sensor->type << "disabled, not processing event\n";
+    }
+
+    // read/process next event
+    if (sc.next_command())
+        sc.process_event_command();
+    else {
+        //cout << "TestSensor: script ended, no further commands\n";
+    }
+}
+
+
+/***************************************
+ *
+ * Acceleration API
+ *
+ ***************************************/
+
+UASensorsAccelerometer* ua_sensors_accelerometer_new()
+{
+    return SensorController::instance().get(ubuntu_sensor_type_accelerometer);
+}
+
+UStatus ua_sensors_accelerometer_enable(UASensorsAccelerometer* s)
+{
+    static_cast<TestSensor*>(s)->enabled = true;
+    return (UStatus) 0;
+}
+
+UStatus ua_sensors_accelerometer_disable(UASensorsAccelerometer* s)
+{
+    static_cast<TestSensor*>(s)->enabled = false;
+    return (UStatus) 0;
+}
+
+uint32_t ua_sensors_accelerometer_get_min_delay(UASensorsAccelerometer* s)
+{
+    return static_cast<TestSensor*>(s)->min_delay;
+}
+
+float ua_sensors_accelerometer_get_min_value(UASensorsAccelerometer* s) __SF_FN_ATTR;
+float ua_sensors_accelerometer_get_min_value(UASensorsAccelerometer* s)
+{
+    return static_cast<TestSensor*>(s)->min_value;
+}
+
+float ua_sensors_accelerometer_get_max_value(UASensorsAccelerometer* s) __SF_FN_ATTR;
+float ua_sensors_accelerometer_get_max_value(UASensorsAccelerometer* s)
+{
+    return static_cast<TestSensor*>(s)->max_value;
+}
+
+float ua_sensors_accelerometer_get_resolution(UASensorsAccelerometer* s) __SF_FN_ATTR;
+float ua_sensors_accelerometer_get_resolution(UASensorsAccelerometer* s)
+{
+    return static_cast<TestSensor*>(s)->resolution;
+}
+
+void ua_sensors_accelerometer_set_reading_cb(UASensorsAccelerometer* s, on_accelerometer_event_cb cb, void* ctx)
+{
+    TestSensor* sensor = static_cast<TestSensor*>(s);
+    sensor->on_event_cb = cb;
+    sensor->event_cb_context = ctx;
+}
+
+uint64_t uas_accelerometer_event_get_timestamp(UASAccelerometerEvent* e)
+{
+    return static_cast<TestSensor*>(e)->timestamp;
+}
+
+float uas_accelerometer_event_get_acceleration_x(UASAccelerometerEvent* e) __SF_FN_ATTR;
+float uas_accelerometer_event_get_acceleration_x(UASAccelerometerEvent* e)
+{
+    return static_cast<TestSensor*>(e)->x;
+}
+
+float uas_accelerometer_event_get_acceleration_y(UASAccelerometerEvent* e) __SF_FN_ATTR;
+float uas_accelerometer_event_get_acceleration_y(UASAccelerometerEvent* e)
+{
+    return static_cast<TestSensor*>(e)->y;
+}
+
+float uas_accelerometer_event_get_acceleration_z(UASAccelerometerEvent* e) __SF_FN_ATTR;
+float uas_accelerometer_event_get_acceleration_z(UASAccelerometerEvent* e)
+{
+    return static_cast<TestSensor*>(e)->z;
+}
+
+/***************************************
+ *
+ * Proximity API
+ *
+ ***************************************/
+
+UASensorsProximity* ua_sensors_proximity_new()
+{
+    return SensorController::instance().get(ubuntu_sensor_type_proximity);
+}
+
+UStatus ua_sensors_proximity_enable(UASensorsProximity* s)
+{
+    static_cast<TestSensor*>(s)->enabled = true;
+    return (UStatus) 0;
+}
+
+UStatus ua_sensors_proximity_disable(UASensorsProximity* s)
+{
+    static_cast<TestSensor*>(s)->enabled = false;
+    return (UStatus) 0;
+}
+
+uint32_t ua_sensors_proximity_get_min_delay(UASensorsProximity* s)
+{
+    return static_cast<TestSensor*>(s)->min_delay;
+}
+
+// the next three function make no sense in the API, just return zero
+float ua_sensors_proximity_get_min_value(UASensorsProximity*) __SF_FN_ATTR;
+float ua_sensors_proximity_get_min_value(UASensorsProximity*)
+{
+    return 0.0;
+}
+
+float ua_sensors_proximity_get_max_value(UASensorsProximity*) __SF_FN_ATTR;
+float ua_sensors_proximity_get_max_value(UASensorsProximity*)
+{
+    return 0.0;
+}
+
+float ua_sensors_proximity_get_resolution(UASensorsProximity*) __SF_FN_ATTR;
+float ua_sensors_proximity_get_resolution(UASensorsProximity*)
+{
+    return 0.0;
+}
+
+void ua_sensors_proximity_set_reading_cb(UASensorsProximity* s, on_proximity_event_cb cb, void* ctx)
+{
+    TestSensor* sensor = static_cast<TestSensor*>(s);
+    sensor->on_event_cb = cb;
+    sensor->event_cb_context = ctx;
+}
+
+uint64_t uas_proximity_event_get_timestamp(UASProximityEvent* e)
+{
+    return static_cast<TestSensor*>(e)->timestamp;
+}
+
+UASProximityDistance uas_proximity_event_get_distance(UASProximityEvent* e)
+{
+    return static_cast<TestSensor*>(e)->distance;
+}
+
+
+/***************************************
+ *
+ * Light API
+ *
+ ***************************************/
+
+UASensorsLight* ua_sensors_light_new()
+{
+    return SensorController::instance().get(ubuntu_sensor_type_light);
+}
+
+UStatus ua_sensors_light_enable(UASensorsLight* s)
+{
+    static_cast<TestSensor*>(s)->enabled = true;
+    return (UStatus) 0;
+}
+
+UStatus ua_sensors_light_disable(UASensorsLight* s)
+{
+    static_cast<TestSensor*>(s)->enabled = false;
+    return (UStatus) 0;
+}
+
+uint32_t ua_sensors_light_get_min_delay(UASensorsLight* s)
+{
+    return static_cast<TestSensor*>(s)->min_delay;
+}
+
+float ua_sensors_light_get_min_value(UASensorsLight* s) __SF_FN_ATTR;
+float ua_sensors_light_get_min_value(UASensorsLight* s)
+{
+    return static_cast<TestSensor*>(s)->min_value;
+}
+
+float ua_sensors_light_get_max_value(UASensorsLight* s) __SF_FN_ATTR;
+float ua_sensors_light_get_max_value(UASensorsLight* s)
+{
+    return static_cast<TestSensor*>(s)->max_value;
+}
+
+float ua_sensors_light_get_resolution(UASensorsLight* s) __SF_FN_ATTR;
+float ua_sensors_light_get_resolution(UASensorsLight* s)
+{
+    return static_cast<TestSensor*>(s)->resolution;
+}
+
+void ua_sensors_light_set_reading_cb(UASensorsLight* s, on_light_event_cb cb, void* ctx)
+{
+    TestSensor* sensor = static_cast<TestSensor*>(s);
+    sensor->on_event_cb = cb;
+    sensor->event_cb_context = ctx;
+}
+
+uint64_t uas_light_event_get_timestamp(UASLightEvent* e)
+{
+    return static_cast<TestSensor*>(e)->timestamp;
+}
+
+float uas_light_event_get_light(UASLightEvent* e) __SF_FN_ATTR;
+float uas_light_event_get_light(UASLightEvent* e)
+{
+    return static_cast<TestSensor*>(e)->x;
+}
 
=== added directory 'tests'
=== added file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/CMakeLists.txt	2014-01-08 15:17:50 +0000
@@ -0,0 +1,30 @@
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(PROCESS_CPP process-cpp REQUIRED)
+
+include_directories(${GTEST_ROOT}/src)
+include_directories(${PROCESS_CPP_INCLUDE_DIRS})
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11")
+
+add_executable(
+    test_ubuntu_application_sensors
+    test_ubuntu_application_sensors.cpp
+)
+
+target_link_libraries(
+    test_ubuntu_application_sensors
+
+    ubuntu_application_api
+    gtest
+    gtest_main
+    ${PROCESS_CPP_LIBRARIES}
+)
+
+# we need to call the tests with pointing to the locally built test platform
+# library
+add_test(
+    test_ubuntu_application_sensors
+    
+    env LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/src/ubuntu/testbackend ${CMAKE_CURRENT_BINARY_DIR}/test_ubuntu_application_sensors
+)
+
 
=== added file 'tests/test_ubuntu_application_sensors.cpp'
--- tests/test_ubuntu_application_sensors.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_ubuntu_application_sensors.cpp	2014-01-08 15:17:50 +0000
@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Martin Pitt <[e-mail]>
+ */
+
+#include <cstdlib>
+#include <cstdio>
+#include <queue>
+#include <chrono>
+
+#include <core/testing/fork_and_run.h>
+
+#include "gtest/gtest.h"
+
+#include <ubuntu/application/sensors/accelerometer.h>
+#include <ubuntu/application/sensors/event/accelerometer.h>
+#include <ubuntu/application/sensors/proximity.h>
+#include <ubuntu/application/sensors/event/proximity.h>
+#include <ubuntu/application/sensors/light.h>
+#include <ubuntu/application/sensors/event/light.h>
+
+using namespace std;
+
+typedef chrono::time_point<chrono::system_clock,chrono::nanoseconds> time_point_system_ns;
+
+struct event {
+    uint64_t timestamp;
+    float x, y, z;
+    UASProximityDistance distance;
+    void* context;
+};
+queue<struct event> events;
+
+class APITest : public testing::Test
+{
+  protected:
+    virtual void SetUp()
+    {
+        snprintf(data_file, sizeof(data_file), "%s", "/tmp/sensor_test.XXXXXX");
+        data_fd = mkstemp(data_file);
+        if (data_fd < 0) {
+            perror("mkstemp");
+            abort();
+        }
+        setenv("UBUNTU_PLATFORM_API_SENSOR_TEST", data_file, 1);
+        setenv("UBUNTU_PLATFORM_API_BACKEND", "libubuntu_application_api_test.so.1", 1);
+
+        // ensure the queue is clear
+        while (events.size() > 0)
+            events.pop();
+    }
+
+    virtual void TearDown()
+    {
+        unlink(data_file);
+    }
+
+    void set_data(const char* data)
+    {
+        write(data_fd, data, strlen(data));
+        fsync(data_fd);
+    }
+
+    char data_file[100];
+    int data_fd;
+};
+
+// without any data, there are no sensors defined
+TESTP_F(APITest, NoData, {
+    EXPECT_EQ(NULL, ua_sensors_accelerometer_new());
+    EXPECT_EQ(NULL, ua_sensors_proximity_new());
+    EXPECT_EQ(NULL, ua_sensors_light_new());
+})
+
+TESTP_F(APITest, CreateProximity, {
+    set_data("create proximity");
+    EXPECT_EQ(NULL, ua_sensors_accelerometer_new());
+    EXPECT_EQ(NULL, ua_sensors_light_new());
+
+    UASensorsProximity *s = ua_sensors_proximity_new();
+    EXPECT_TRUE(s != NULL);
+})
+
+TESTP_F(APITest, CreateAccelerator, {
+    set_data("create accel 0.5 1000 0.1");
+    EXPECT_EQ(NULL, ua_sensors_proximity_new());
+    EXPECT_EQ(NULL, ua_sensors_light_new());
+
+    UASensorsAccelerometer *s = ua_sensors_accelerometer_new();
+    EXPECT_TRUE(s != NULL);
+    EXPECT_FLOAT_EQ(0.5, ua_sensors_accelerometer_get_min_value(s));
+    EXPECT_FLOAT_EQ(1000.0, ua_sensors_accelerometer_get_max_value(s));
+    EXPECT_FLOAT_EQ(0.1, ua_sensors_accelerometer_get_resolution(s));
+})
+
+TESTP_F(APITest, CreateLight, {
+    set_data("create light 0 10 0.5");
+    EXPECT_EQ(NULL, ua_sensors_proximity_new());
+    EXPECT_EQ(NULL, ua_sensors_accelerometer_new());
+
+    UASensorsLight *s = ua_sensors_light_new();
+    EXPECT_TRUE(s != NULL);
+    EXPECT_FLOAT_EQ(0.0, ua_sensors_light_get_min_value(s));
+    EXPECT_FLOAT_EQ(10.0, ua_sensors_light_get_max_value(s));
+    EXPECT_FLOAT_EQ(0.5, ua_sensors_light_get_resolution(s));
+})
+
+TESTP_F(APITest, ProximityEvents, {
+    set_data("create proximity\n"
+             "  # some comment\n"
+             "  \n"
+             "50 proximity near\n"
+             "100 proximity far\n"
+             "80 proximity unknown\n"
+    );
+
+    UASensorsProximity *s = ua_sensors_proximity_new();
+    EXPECT_TRUE(s != NULL);
+    ua_sensors_proximity_enable(s);
+    auto start_time = chrono::system_clock::now();
+
+    ua_sensors_proximity_set_reading_cb(s,
+        [](UASProximityEvent* ev, void* ctx) {
+            events.push({uas_proximity_event_get_timestamp(ev),
+                         .0, .0, .0,
+                         uas_proximity_event_get_distance(ev),
+                         ctx});
+        }, NULL);
+
+    usleep(350000);
+    EXPECT_EQ(3, events.size());
+
+    auto e = events.front();
+    events.pop();
+    EXPECT_EQ(e.distance, U_PROXIMITY_NEAR);
+    EXPECT_EQ(NULL, e.context);
+    auto event_time = time_point_system_ns(std::chrono::nanoseconds(e.timestamp));
+    auto delay = chrono::duration_cast<chrono::milliseconds>(event_time - start_time).count();
+    EXPECT_GE(delay, 30);
+    EXPECT_LE(delay, 70);
+
+    e = events.front();
+    events.pop();
+    EXPECT_EQ(e.distance, U_PROXIMITY_FAR);
+    event_time = time_point_system_ns(std::chrono::nanoseconds(e.timestamp));
+    delay = chrono::duration_cast<chrono::milliseconds>(event_time - start_time).count();
+    EXPECT_GE(delay, 130);
+    EXPECT_LE(delay, 170);
+
+    e = events.front();
+    events.pop();
+    EXPECT_EQ(e.distance, (UASProximityDistance) 0);
+    event_time = time_point_system_ns(std::chrono::nanoseconds(e.timestamp));
+    delay = chrono::duration_cast<chrono::milliseconds>(event_time - start_time).count();
+    EXPECT_GE(delay, 210);
+    EXPECT_LE(delay, 250);
+})
+
+TESTP_F(APITest, LightEvents, {
+    set_data(" create  light  0 10 1\n"
+             "1 light 5\n"
+             "100 light 8\n"
+    );
+
+    UASensorsLight *s = ua_sensors_light_new();
+    EXPECT_TRUE(s != NULL);
+    ua_sensors_light_enable(s);
+    auto start_time = chrono::system_clock::now();
+
+    ua_sensors_light_set_reading_cb(s,
+        [](UASLightEvent* ev, void* ctx) {
+            events.push({uas_light_event_get_timestamp(ev),
+                         uas_light_event_get_light(ev), .0, .0,
+                         (UASProximityDistance) 0, ctx});
+        }, NULL);
+
+    usleep(130000);
+    EXPECT_EQ(2, events.size());
+
+    auto e = events.front();
+    events.pop();
+    EXPECT_FLOAT_EQ(e.x, 5);
+    EXPECT_EQ(NULL, e.context);
+    auto event_time = time_point_system_ns(std::chrono::nanoseconds(e.timestamp));
+    auto delay = chrono::duration_cast<chrono::milliseconds>(event_time - start_time).count();
+    EXPECT_LE(delay, 10);
+
+    e = events.front();
+    events.pop();
+    EXPECT_FLOAT_EQ(e.x, 8);
+    event_time = time_point_system_ns(std::chrono::nanoseconds(e.timestamp));
+    delay = chrono::duration_cast<chrono::milliseconds>(event_time - start_time).count();
+    EXPECT_GE(delay, 91);
+    EXPECT_LE(delay, 111);
+})
+
+TESTP_F(APITest, AccelEvents, {
+    // cover the case of > 1 s, to ensure that we correctly do mod arithmetic
+    set_data("create accel -1000 1000 0.1\n"
+             "1100 accel 5.5 -8.5 9.9\n"
+    );
+
+    UASensorsAccelerometer *s = ua_sensors_accelerometer_new();
+    EXPECT_TRUE(s != NULL);
+    ua_sensors_accelerometer_enable(s);
+    auto start_time = chrono::system_clock::now();
+
+    ua_sensors_accelerometer_set_reading_cb(s,
+        [](UASAccelerometerEvent* ev, void* ctx) {
+            events.push({uas_accelerometer_event_get_timestamp(ev),
+                         uas_accelerometer_event_get_acceleration_x(ev),
+                         uas_accelerometer_event_get_acceleration_y(ev),
+                         uas_accelerometer_event_get_acceleration_z(ev),
+                         (UASProximityDistance) 0, ctx});
+        }, NULL);
+
+    usleep(1200000);
+    EXPECT_EQ(1, events.size());
+
+    auto e = events.front();
+    events.pop();
+    EXPECT_FLOAT_EQ(e.x, 5.5);
+    EXPECT_FLOAT_EQ(e.y, -8.5);
+    EXPECT_FLOAT_EQ(e.z, 9.9);
+    EXPECT_EQ(NULL, e.context);
+    auto event_time = time_point_system_ns(std::chrono::nanoseconds(e.timestamp));
+    auto delay = chrono::duration_cast<chrono::milliseconds>(event_time - start_time).count();
+    EXPECT_GE(delay, 1050);
+    EXPECT_LE(delay, 1150);
+})