← Back to branch summary

~unity-system-compositor-team/unity-system-compositor/ubuntu

« back to all changes in this revision

Viewing changes to tests/integration-tests/test_unity_input_service.cpp

  • Committer: CI Train Bot
  • Author(s): CI Train Bot, Kevin DuBois, Alexandros Frantzis
  • Date: 2016-01-21 17:58:56 UTC
  • mfrom: (200.45.12 0.3)
  • Revision ID: ci-train-bot@canonical.com-20160121175856-m9rosowob03a105o
Release 0.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/integration-tests/test_unity_input_service.cpp
19
19
#include "src/unity_input_service.h"
20
20
#include "src/dbus_connection_handle.h"
21
21
#include "src/dbus_connection_thread.h"
 
22
#include "src/dbus_event_loop.h"
22
23
#include "src/dbus_message_handle.h"
23
 
#include "src/input_configuration.h"
24
24
#include "src/unity_input_service_introspection.h"
 
25
 
25
26
#include "wait_condition.h"
26
27
#include "dbus_bus.h"
27
28
#include "dbus_client.h"
 
29
#include "unity_input_dbus_client.h"
28
30
 
29
 
#include <gtest/gtest.h>
30
 
#include <gmock/gmock.h>
 
31
#include "usc/test/mock_input_configuration.h"
31
32
 
32
33
#include <stdexcept>
33
34
#include <memory>
37
38
namespace
38
39
{
39
40
 
40
 
struct MockInputConfiguration : usc::InputConfiguration
41
 
{
42
 
public:
43
 
    MOCK_METHOD1(set_mouse_primary_button, void(int32_t));
44
 
    MOCK_METHOD1(set_mouse_cursor_speed, void(double));
45
 
    MOCK_METHOD1(set_mouse_scroll_speed, void(double));
46
 
    MOCK_METHOD1(set_touchpad_primary_button, void(int32_t));
47
 
    MOCK_METHOD1(set_touchpad_cursor_speed, void(double));
48
 
    MOCK_METHOD1(set_touchpad_scroll_speed, void(double));
49
 
    MOCK_METHOD1(set_two_finger_scroll, void(bool));
50
 
    MOCK_METHOD1(set_tap_to_click, void(bool));
51
 
    MOCK_METHOD1(set_disable_touchpad_with_mouse, void(bool));
52
 
    MOCK_METHOD1(set_disable_touchpad_while_typing, void(bool));
53
 
};
54
 
 
55
 
class UnityInputDBusClient : public ut::DBusClient
56
 
{
57
 
public:
58
 
    UnityInputDBusClient(std::string const& address)
59
 
        : ut::DBusClient{
60
 
            address,
61
 
            "com.canonical.Unity.Input",
62
 
            "/com/canonical/Unity/Input"}
63
 
    {
64
 
    }
65
 
 
66
 
    ut::DBusAsyncReplyString request_introspection()
67
 
    {
68
 
        return invoke_with_reply<ut::DBusAsyncReplyString>(
69
 
            "org.freedesktop.DBus.Introspectable", "Introspect",
70
 
            DBUS_TYPE_INVALID);
71
 
    }
72
 
 
73
 
    ut::DBusAsyncReplyVoid request(char const* requestName, int32_t value)
74
 
    {
75
 
        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
76
 
            unity_input_interface, requestName,
77
 
            DBUS_TYPE_INT32, &value,
78
 
            DBUS_TYPE_INVALID);
79
 
    }
80
 
 
81
 
    ut::DBusAsyncReplyVoid request_set_mouse_primary_button(int32_t button)
82
 
    {
83
 
        return request("setMousePrimaryButton", button);
84
 
    }
85
 
 
86
 
    ut::DBusAsyncReplyVoid request_set_touchpad_primary_button(int32_t button)
87
 
    {
88
 
        return request("setTouchpadPrimaryButton", button);
89
 
    }
90
 
 
91
 
    ut::DBusAsyncReplyVoid request(char const* requestName, double value)
92
 
    {
93
 
        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
94
 
            unity_input_interface, requestName,
95
 
            DBUS_TYPE_DOUBLE, &value,
96
 
            DBUS_TYPE_INVALID);
97
 
    }
98
 
 
99
 
    ut::DBusAsyncReplyVoid request_set_mouse_cursor_speed(double speed)
100
 
    {
101
 
        return request("setMouseCursorSpeed", speed);
102
 
    }
103
 
 
104
 
    ut::DBusAsyncReplyVoid request_set_mouse_scroll_speed(double speed)
105
 
    {
106
 
        return request("setMouseScrollSpeed", speed);
107
 
    }
108
 
 
109
 
    ut::DBusAsyncReplyVoid request_set_touchpad_cursor_speed(double speed)
110
 
    {
111
 
        return request("setTouchpadCursorSpeed", speed);
112
 
    }
113
 
 
114
 
    ut::DBusAsyncReplyVoid request_set_touchpad_scroll_speed(double speed)
115
 
    {
116
 
        return request("setTouchpadScrollSpeed", speed);
117
 
    }
118
 
 
119
 
    ut::DBusAsyncReplyVoid request(char const* requestName, bool value)
120
 
    {
121
 
        dbus_bool_t copied = value;
122
 
        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
123
 
            unity_input_interface, requestName,
124
 
            DBUS_TYPE_BOOLEAN, &copied,
125
 
            DBUS_TYPE_INVALID);
126
 
    }
127
 
 
128
 
    ut::DBusAsyncReplyVoid request_set_touchpad_two_finger_scroll(bool enabled)
129
 
    {
130
 
        return request("setTouchpadTwoFingerScroll", enabled);
131
 
    }
132
 
 
133
 
    ut::DBusAsyncReplyVoid request_set_touchpad_tap_to_click(bool enabled)
134
 
    {
135
 
        return request("setTouchpadTapToClick", enabled);
136
 
    }
137
 
 
138
 
    ut::DBusAsyncReplyVoid request_set_touchpad_disable_with_mouse(bool enabled)
139
 
    {
140
 
        return request("setTouchpadDisableWithMouse", enabled);
141
 
    }
142
 
 
143
 
    ut::DBusAsyncReplyVoid request_set_touchpad_disable_while_typing(bool enabled)
144
 
    {
145
 
        return request("setTouchpadDisableWhileTyping", enabled);
146
 
    }
147
 
 
148
 
    char const* const unity_input_interface = "com.canonical.Unity.Input";
149
 
};
150
 
 
151
41
struct AUnityInputService : testing::Test
152
42
{
153
43
    std::chrono::seconds const default_timeout{3};
154
44
    ut::DBusBus bus;
155
45
 
156
 
    std::shared_ptr<MockInputConfiguration> const mock_input_configuration =
157
 
        std::make_shared<testing::NiceMock<MockInputConfiguration>>();
158
 
    UnityInputDBusClient client{bus.address()};
 
46
    std::shared_ptr<ut::MockInputConfiguration> const mock_input_configuration =
 
47
        std::make_shared<testing::NiceMock<ut::MockInputConfiguration>>();
 
48
    ut::UnityInputDBusClient client{bus.address()};
 
49
    std::shared_ptr<usc::DBusEventLoop> const dbus_loop=
 
50
        std::make_shared<usc::DBusEventLoop>();
 
51
    usc::UnityInputService service{dbus_loop, bus.address(), mock_input_configuration};
159
52
    std::shared_ptr<usc::DBusConnectionThread> const dbus_thread =
160
 
        std::make_shared<usc::DBusConnectionThread>(bus.address());
161
 
    usc::UnityInputService service{dbus_thread, mock_input_configuration};
 
53
        std::make_shared<usc::DBusConnectionThread>(dbus_loop);
162
54
};
163
55
 
164
56
}