ilmInput: add unit and nullpointer tests

Signed-off-by: Emre Ucan <eucan@de.adit-jv.com>

5 files changed, 517 insertions, 0 deletions

diff --git a/ivi-input-api/test/CMakeLists.txt b/ivi-input-api/test/CMakeLists.txt
new file mode 100644
index 0000000..f1a7e95
--- /dev/null
+++ b/ivi-input-api/test/CMakeLists.txt
@@ -0,0 +1,81 @@
+############################################################################
+#
+# Copyright 2014 BMW Car IT GmbH
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#               http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+############################################################################
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+
+OPTION(BUILD_ILM_API_TESTS   "Install unit tests for IVI LayerManagement API" OFF)
+OPTION(INSTALL_ILM_API_TESTS "Build unit tests for IVI LayerManagement API"   OFF)
+
+FIND_PACKAGE(gtest)
+
+IF(NOT gtest_FOUND)
+    MESSAGE(STATUS "gtest not found, disabling unit tests (BUILD_ILM_API_TESTS=OFF)")
+    SET(BUILD_ILM_API_TESTS FALSE CACHE BOOL "Build unit tests for IVI LayerManagement API" FORCE)
+ENDIF()
+
+IF(BUILD_ILM_API_TESTS)
+
+    PROJECT(ivi-input-api-test)
+
+    INCLUDE_DIRECTORIES(
+        ${CMAKE_SOURCE_DIR}/ivi-layermanagement-api/ilmCommon/include
+        ${CMAKE_SOURCE_DIR}/ivi-layermanagement-api/ilmClient/include
+        ${CMAKE_SOURCE_DIR}/ivi-layermanagement-api/ilmControl/include
+        ${CMAKE_CURRENT_SOURCE_DIR}/../ilmInput/include
+        ${WAYLAND_CLIENT_INCLUDE_DIRS}
+        ${gtest_INCLUDE_DIRS}
+    )
+
+    LINK_DIRECTORIES(
+        ${WAYLAND_CLIENT_LIBRARY_DIRS}
+    )
+
+    SET(LIBS
+        ilmCommon
+        ilmClient
+        ilmControl
+        ilmInput
+        ${gtest_LIBRARIES}
+        ${WAYLAND_CLIENT_LIBRARY_DIRS}
+    )
+
+    SET(SRC_FILES
+        TestBase.cpp
+        ilm_input_test.cpp
+        ilm_input_null_pointer_test.cpp
+    )
+
+    ADD_EXECUTABLE(${PROJECT_NAME} ${SRC_FILES})
+
+    TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${LIBS})
+
+    ADD_DEPENDENCIES(${PROJECT_NAME} ${LIBS})
+
+    IF(INSTALL_ILM_API_TESTS)
+        INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
+    ENDIF()
+
+    # use CTest
+    ENABLE_TESTING()
+    ADD_TEST(ilmCommon  ${PROJECT_NAME})
+    ADD_TEST(ilmClient  ${PROJECT_NAME})
+    ADD_TEST(ilmControl ${PROJECT_NAME})
+    ADD_TEST(ilmInput ${PROJECT_NAME})
+
+ENDIF()
diff --git a/ivi-input-api/test/TestBase.cpp b/ivi-input-api/test/TestBase.cpp
new file mode 100644
index 0000000..b871b1e
--- /dev/null
+++ b/ivi-input-api/test/TestBase.cpp
@@ -0,0 +1,56 @@
+#include "TestBase.h"
+#include <cstring>
+#include <stdexcept>
+
+void registry_listener_callback(void* data, struct wl_registry* registry, uint32_t id, const char* interface, uint32_t version)
+{
+    if (0 == strcmp(interface, "wl_compositor"))
+    {
+        wl_compositor** compositor = reinterpret_cast<wl_compositor**>(data);
+        *compositor = reinterpret_cast<wl_compositor*>(wl_registry_bind(registry, id, &wl_compositor_interface, 1));
+    }
+}
+
+TestBase::TestBase()
+: wlDisplay(NULL)
+, wlRegistry(NULL)
+{
+    wlDisplay = wl_display_connect(NULL);
+    if (!wlDisplay)
+    {
+        throw std::runtime_error("could not connect to wayland display");
+    }
+    wlRegistry = wl_display_get_registry(wlDisplay);
+
+    static const struct wl_registry_listener registry_listener = {
+        registry_listener_callback,
+        NULL
+    };
+
+    wl_registry_add_listener(wlRegistry, &registry_listener, &wlCompositor);
+
+    if (wl_display_roundtrip(wlDisplay) == -1 || wl_display_roundtrip(wlDisplay) == -1)
+    {
+        throw std::runtime_error("wl_display error");
+    }
+
+    wlSurfaces.reserve(10);
+    for (int i = 0; i < wlSurfaces.capacity(); ++i)
+    {
+        wlSurfaces.push_back(wl_compositor_create_surface(wlCompositor));
+    }
+}
+
+TestBase::~TestBase()
+{
+    for (std::vector<wl_surface *>::reverse_iterator it = wlSurfaces.rbegin();
+         it != wlSurfaces.rend();
+         ++it)
+    {
+        wl_surface_destroy(*it);
+    }
+    wlSurfaces.clear();
+    wl_compositor_destroy(wlCompositor);
+    wl_registry_destroy(wlRegistry);
+    wl_display_disconnect(wlDisplay);
+}
diff --git a/ivi-input-api/test/TestBase.h b/ivi-input-api/test/TestBase.h
new file mode 100644
index 0000000..33efde9
--- /dev/null
+++ b/ivi-input-api/test/TestBase.h
@@ -0,0 +1,18 @@
+
+#include "wayland-client.h"
+#include <vector>
+
+class TestBase
+{
+public:
+    TestBase();
+    virtual ~TestBase();
+
+protected:
+    std::vector<wl_surface *> wlSurfaces;
+    wl_display*    wlDisplay;
+
+private:
+    wl_registry*   wlRegistry;
+    wl_compositor* wlCompositor;
+};
diff --git a/ivi-input-api/test/ilm_input_null_pointer_test.cpp b/ivi-input-api/test/ilm_input_null_pointer_test.cpp
new file mode 100644
index 0000000..9ea3104
--- /dev/null
+++ b/ivi-input-api/test/ilm_input_null_pointer_test.cpp
@@ -0,0 +1,159 @@
+/***************************************************************************
+ *
+ * Copyright 2010-2014 BMW Car IT GmbH
+ * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ****************************************************************************/
+
+#include <gtest/gtest.h>
+#include <stdio.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+
+#include <iostream>
+
+#include "TestBase.h"
+
+extern "C" {
+    #include "ilm_client.h"
+    #include "ilm_control.h"
+    #include "ilm_input.h"
+}
+
+template <typename T>
+bool contains(T const *actual, size_t as, T expected)
+{
+   for (unsigned i = 0; i < as; i++)
+      if (actual[i] == expected)
+         return true;
+   return false;
+}
+
+class IlmNullPointerTest : public TestBase, public ::testing::Test {
+public:
+    void SetUp()
+    {
+        ASSERT_EQ(ILM_SUCCESS, ilm_initWithNativedisplay((t_ilm_nativedisplay)wlDisplay));
+    }
+
+    void TearDown()
+    {
+        //print_lmc_get_scene();
+        t_ilm_layer* layers = NULL;
+        t_ilm_int numLayer=0;
+        EXPECT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&numLayer, &layers));
+        for (t_ilm_int i=0; i<numLayer; i++)
+        {
+            EXPECT_EQ(ILM_SUCCESS, ilm_layerRemove(layers[i]));
+        };
+        free(layers);
+
+        t_ilm_surface* surfaces = NULL;
+        t_ilm_int numSurfaces=0;
+        EXPECT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&numSurfaces, &surfaces));
+        for (t_ilm_int i=0; i<numSurfaces; i++)
+        {
+            EXPECT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surfaces[i]));
+        };
+        free(surfaces);
+
+        EXPECT_EQ(ILM_SUCCESS, ilm_commitChanges());
+        EXPECT_EQ(ILM_SUCCESS, ilm_destroy());
+    }
+};
+
+TEST_F(IlmNullPointerTest, ilm_set_input_focus_null_pointer) {
+    ASSERT_EQ(ILM_FAILED, ilm_setInputFocus(NULL, 5, ILM_INPUT_DEVICE_KEYBOARD, ILM_TRUE));
+}
+
+TEST_F(IlmNullPointerTest, ilm_get_input_focus_null_pointer) {
+    const uint32_t surfaceCount = 4;
+    t_ilm_surface surfaces[] = {1010, 2020, 3030, 4040};
+    t_ilm_surface *surfaceIDs;
+    ilmInputDevice *bitmasks;
+    t_ilm_uint num_ids;
+
+    for (unsigned int i = 0; i < surfaceCount; i++) {
+        ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[i], 0, 0,
+                                                 ILM_PIXELFORMAT_RGBA_8888, &surfaces[i]));
+    }
+
+    EXPECT_EQ(ILM_FAILED, ilm_getInputFocus(0, &bitmasks, &num_ids));
+
+    EXPECT_EQ(ILM_FAILED, ilm_getInputFocus(&surfaceIDs, NULL, &num_ids));
+
+    EXPECT_EQ(ILM_FAILED, ilm_getInputFocus(&surfaceIDs, &bitmasks, NULL));
+
+
+}
+
+TEST_F(IlmNullPointerTest, ilm_set_input_event_acceptance_null_pointer) {
+    t_ilm_surface surface1 = 1010, surface2 = 2020;
+    t_ilm_uint num_seats = 0;
+    t_ilm_string *seats = NULL;
+    t_ilm_string set_seats[] = {"default", "foo"};
+    t_ilm_uint set_seats_count = 2;
+    ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0],
+                                             0, 0, ILM_PIXELFORMAT_RGBA_8888,
+                                             &surface1));
+
+    EXPECT_EQ(ILM_FAILED, ilm_setInputAcceptanceOn(surface1, set_seats_count, NULL));
+
+    EXPECT_EQ(ILM_FAILED, ilm_setInputAcceptanceOn(0, set_seats_count, set_seats));
+}
+
+TEST_F(IlmNullPointerTest, ilm_get_input_event_acceptance_null_pointer) {
+    t_ilm_surface surface1 = 1010;
+    t_ilm_uint num_seats = 0;
+    t_ilm_string *seats = NULL;
+    t_ilm_string set_seats[] = {"default", "foo"};
+    t_ilm_uint set_seats_count = 2;
+    ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0],
+                                             0, 0, ILM_PIXELFORMAT_RGBA_8888,
+                                             &surface1));
+
+    EXPECT_EQ(ILM_FAILED, ilm_getInputAcceptanceOn(0, &num_seats,
+                                                    &seats));
+
+    EXPECT_EQ(ILM_FAILED, ilm_getInputAcceptanceOn(surface1, NULL,
+                                                    &seats));
+
+    EXPECT_EQ(ILM_FAILED, ilm_getInputAcceptanceOn(surface1, &num_seats,
+                                                    NULL));
+
+}
+
+TEST_F(IlmNullPointerTest, ilm_get_input_devices_null_pointer) {
+    t_ilm_surface surface1 = 1010;
+    t_ilm_string seats[] = {"default", "foo"};
+    t_ilm_uint num_seats = 2;
+    ilmInputDevice bitmask = ILM_INPUT_DEVICE_POINTER;
+    ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0],
+                                             0, 0, ILM_PIXELFORMAT_RGBA_8888,
+                                             &surface1));
+
+    EXPECT_EQ(ILM_FAILED, ilm_getInputDevices(bitmask, &num_seats,
+                                                    NULL));
+}
+
+TEST_F(IlmNullPointerTest, ilm_get_input_device_capabilities_null_pointer) {
+    t_ilm_string seats[] = {"default", "foo"};
+    ilmInputDevice bitmask;
+
+    EXPECT_EQ(ILM_FAILED, ilm_getInputDeviceCapabilities(NULL, &bitmask));
+    EXPECT_EQ(ILM_FAILED, ilm_getInputDeviceCapabilities(seats[1], NULL));
+}
diff --git a/ivi-input-api/test/ilm_input_test.cpp b/ivi-input-api/test/ilm_input_test.cpp
new file mode 100644
index 0000000..f60eb3a
--- /dev/null
+++ b/ivi-input-api/test/ilm_input_test.cpp
@@ -0,0 +1,203 @@
+/***************************************************************************
+ *
+ * Copyright 2010-2014 BMW Car IT GmbH
+ * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ****************************************************************************/
+
+#include <gtest/gtest.h>
+#include <stdio.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+
+#include <iostream>
+
+#include "TestBase.h"
+
+extern "C" {
+    #include "ilm_client.h"
+    #include "ilm_control.h"
+    #include "ilm_input.h"
+}
+
+template <typename T>
+bool contains(T const *actual, size_t as, T expected)
+{
+   for (unsigned i = 0; i < as; i++)
+      if (actual[i] == expected)
+         return true;
+   return false;
+}
+
+class IlmCommandTest : public TestBase, public ::testing::Test {
+public:
+    void SetUp()
+    {
+        ASSERT_EQ(ILM_SUCCESS, ilm_initWithNativedisplay((t_ilm_nativedisplay)wlDisplay));
+    }
+
+    void TearDown()
+    {
+        //print_lmc_get_scene();
+        t_ilm_layer* layers = NULL;
+        t_ilm_int numLayer=0;
+        EXPECT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&numLayer, &layers));
+        for (t_ilm_int i=0; i<numLayer; i++)
+        {
+            EXPECT_EQ(ILM_SUCCESS, ilm_layerRemove(layers[i]));
+        };
+        free(layers);
+
+        t_ilm_surface* surfaces = NULL;
+        t_ilm_int numSurfaces=0;
+        EXPECT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&numSurfaces, &surfaces));
+        for (t_ilm_int i=0; i<numSurfaces; i++)
+        {
+            EXPECT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surfaces[i]));
+        };
+        free(surfaces);
+
+        EXPECT_EQ(ILM_SUCCESS, ilm_commitChanges());
+        EXPECT_EQ(ILM_SUCCESS, ilm_destroy());
+    }
+};
+
+TEST_F(IlmCommandTest, ilm_input_focus) {
+    const uint32_t surfaceCount = 4;
+    t_ilm_surface surfaces[] = {1010, 2020, 3030, 4040};
+    t_ilm_surface *surfaceIDs;
+    ilmInputDevice *bitmasks;
+    t_ilm_uint num_ids;
+
+    for (unsigned int i = 0; i < surfaceCount; i++) {
+        ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[i], 0, 0,
+                                                 ILM_PIXELFORMAT_RGBA_8888, &surfaces[i]));
+    }
+
+    ASSERT_EQ(ILM_SUCCESS, ilm_getInputFocus(&surfaceIDs, &bitmasks, &num_ids));
+    /* All the surfaces are returned */
+    ASSERT_EQ(num_ids, surfaceCount);
+    int surfaces_found = 0;
+    for (unsigned int i = 0; i < num_ids; i++) {
+        /* The bitmasks all start unset */
+        EXPECT_EQ(bitmasks[i], 0);
+        if (contains(&surfaces[0], surfaceCount, surfaceIDs[i]))
+            surfaces_found++;
+    }
+    free(surfaceIDs);
+    free(bitmasks);
+    /* The surfaces returned are the correct ones */
+    ASSERT_EQ(surfaces_found, surfaceCount);
+
+    /* Can set all focus to keyboard */
+    ASSERT_EQ(ILM_SUCCESS, ilm_setInputFocus(&surfaces[0], surfaceCount, ILM_INPUT_DEVICE_KEYBOARD, ILM_TRUE));
+
+    ASSERT_EQ(ILM_SUCCESS, ilm_getInputFocus(&surfaceIDs, &bitmasks, &num_ids));
+    for (unsigned int i = 0; i < num_ids; i++) {
+        /* All surfaces now have keyboard focus */
+        EXPECT_EQ(bitmasks[i], ILM_INPUT_DEVICE_KEYBOARD);
+    }
+    free(surfaceIDs);
+    free(bitmasks);
+
+    /* Can remove keyboard focus from one surface */
+    ASSERT_EQ(ILM_SUCCESS, ilm_setInputFocus(&surfaces[0], 1, ILM_INPUT_DEVICE_KEYBOARD, ILM_FALSE));
+    ASSERT_EQ(ILM_SUCCESS, ilm_getInputFocus(&surfaceIDs, &bitmasks, &num_ids));
+    /* keyboard focus now removed for surfaces[0] */
+    for (unsigned int i = 0; i < num_ids; i++)
+        if (surfaceIDs[i] == surfaces[0])
+            EXPECT_EQ(bitmasks[i], 0);
+    free(surfaceIDs);
+    free(bitmasks);
+
+    /* Pointer focus set for surfaces[1] */
+    ASSERT_EQ(ILM_SUCCESS, ilm_setInputFocus(&surfaces[1], 1, ILM_INPUT_DEVICE_POINTER, ILM_TRUE));
+    ASSERT_EQ(ILM_SUCCESS, ilm_getInputFocus(&surfaceIDs, &bitmasks, &num_ids));
+    /* surfaces[1] now has pointer and keyboard focus */
+    for (unsigned int i = 0; i < num_ids; i++)
+        if (surfaceIDs[i] == surfaces[1])
+            EXPECT_EQ(bitmasks[i], ILM_INPUT_DEVICE_POINTER | ILM_INPUT_DEVICE_KEYBOARD);
+    free(surfaceIDs);
+    free(bitmasks);
+
+    /* Touch focus set for surfaces[2] */
+    ASSERT_EQ(ILM_SUCCESS, ilm_setInputFocus(&surfaces[2], 1, ILM_INPUT_DEVICE_TOUCH, ILM_TRUE));
+    ASSERT_EQ(ILM_SUCCESS, ilm_getInputFocus(&surfaceIDs, &bitmasks, &num_ids));
+    /* surfaces[2] now has keyboard and touch focus */
+    for (unsigned int i = 0; i < num_ids; i++)
+        if (surfaceIDs[i] == surfaces[2])
+            EXPECT_EQ(bitmasks[i], ILM_INPUT_DEVICE_KEYBOARD | ILM_INPUT_DEVICE_TOUCH);
+    free(surfaceIDs);
+    free(bitmasks);
+}
+
+TEST_F(IlmCommandTest, ilm_input_event_acceptance) {
+    t_ilm_surface surface1 = 1010, surface2 = 2020;
+    t_ilm_uint num_seats = 0;
+    t_ilm_string *seats = NULL;
+    t_ilm_string set_seats[] = {"default", "foo"};
+    t_ilm_uint set_seats_count = 2;
+    ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0],
+                                             0, 0, ILM_PIXELFORMAT_RGBA_8888,
+                                             &surface1));
+    ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1],
+                                             0, 0, ILM_PIXELFORMAT_RGBA_8888,
+                                             &surface2));
+
+    /* All seats accept the "default" seat when created */
+    ASSERT_EQ(ILM_SUCCESS, ilm_getInputAcceptanceOn(surface1, &num_seats,
+                                                    &seats));
+    EXPECT_EQ(1, num_seats);
+    /* googletest doesn't like comparing to null pointers */
+    ASSERT_EQ(false, seats == NULL);
+    EXPECT_STREQ("default", seats[0]);
+    free(seats[0]);
+    free(seats);
+
+    /* Can remove a seat from acceptance */
+    ASSERT_EQ(ILM_SUCCESS, ilm_setInputAcceptanceOn(surface1, 0, NULL));
+    ASSERT_EQ(ILM_SUCCESS, ilm_getInputAcceptanceOn(surface1, &num_seats,
+                                                    &seats));
+    EXPECT_EQ(0, num_seats);
+    free(seats);
+
+    /* Can add a seat to acceptance */
+    ASSERT_EQ(ILM_SUCCESS, ilm_setInputAcceptanceOn(surface2, set_seats_count,
+                                                    set_seats));
+    ASSERT_EQ(ILM_SUCCESS, ilm_getInputAcceptanceOn(surface2, &num_seats,
+                                                    &seats));
+    EXPECT_EQ(set_seats_count, num_seats);
+    bool found = false;
+    for (uint i = 0; i < num_seats; i++)
+        if (strcmp(seats[i], set_seats[0]))
+            found = true;
+    EXPECT_EQ(true, found) << set_seats[0] << " not found in returned seats";
+
+    for (uint i = 0; i < num_seats; i++)
+        if (strcmp(seats[i], set_seats[1]))
+            found = true;
+    EXPECT_EQ(true, found) << set_seats[1] << " not found in returned seats";
+
+    for (uint i = 0; i < num_seats; i++)
+        free(seats[i]);
+    free(seats);
+
+    /* Seats can be set, unset, then reset */
+    ASSERT_EQ(ILM_SUCCESS, ilm_setInputAcceptanceOn(surface1, 1, &set_seats[1]));
+    ASSERT_EQ(ILM_SUCCESS, ilm_setInputAcceptanceOn(surface1, 0, NULL));
+    ASSERT_EQ(ILM_SUCCESS, ilm_setInputAcceptanceOn(surface1, 1, &set_seats[1]));
+}