← Back to branch summary

~thomas-voss/location-service/fix-1347887

« back to all changes in this revision

Viewing changes to tests/controller_test.cpp

This MP consolidates multiple related changes together, with the goal of:

(1.) Make the service instance accessible via a cli. Useful for testing scenarios.
(2.) To cut down time-to-first-fix (ttff) by:
  (2.1) Leveraging SUPL and other supplementary data downloaded over ordinary data connections.
  (2.2) Enabling network-based positioning providers to acquire fast position estimates.

In more detail:

* Added tests for daemon and cli.
* Unified daemon and cli header and implementation files.
* Add a command-line interface to the service.
* Split up provider selection policy to rely on an interface ProviderEnumerator to ease in testing.
* Trimmed down on types.
* Removed connectivity API draft to prepare for simpler approach.
* Refactored includes.
* Added a configuration option to handle cell and wifi ID reporting.
* Add a mock for a connectivity API exposed to providers and reporters.
* Add units for connectivity api.
* Refactor cell class into namespace radio. Fixes: 1226204, 1248973, 1281817

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/controller_test.cpp
15
15
 *
16
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
17
17
 */
18
 
#include "com/ubuntu/location/provider.h"
 
18
#include <com/ubuntu/location/provider.h>
19
19
 
20
20
#include <gmock/gmock.h>
21
21
#include <gtest/gtest.h>
26
26
{
27
27
struct MockProvider : public cul::Provider
28
28
{
29
 
        MockProvider() = default;
 
29
    MockProvider() : cul::Provider()
 
30
    {
 
31
    }
30
32
 
31
 
        MOCK_METHOD0(start_position_updates, void());
 
33
    MOCK_METHOD0(start_position_updates, void());
32
34
    MOCK_METHOD0(stop_position_updates, void());
33
35
 
34
36
    MOCK_METHOD0(start_heading_updates, void());
39
41
 
40
42
    void inject_update(const cul::Update<cul::Position>& update)
41
43
    {
42
 
        deliver_position_updates(update);
 
44
        mutable_updates().position(update);
43
45
    }
44
46
 
45
47
    void inject_update(const cul::Update<cul::Velocity>& update)
46
48
    {
47
 
        deliver_velocity_updates(update);
 
49
        mutable_updates().velocity(update);
48
50
    }
49
51
 
50
52
    void inject_update(const cul::Update<cul::Heading>& update)
51
53
    {
52
 
        deliver_heading_updates(update);
 
54
        mutable_updates().heading(update);
53
55
    }
54
56
};
55
57
 
78
80
};
79
81
}
80
82
 
81
 
TEST(CachedUpdates, a_default_constructed_cached_value_is_invalid)
82
 
{
83
 
        cul::Provider::Controller::Cache<int> cached_value;
84
 
        EXPECT_FALSE(cached_value.is_valid());
85
 
}
86
 
 
87
 
TEST(CachedUpdates, updating_with_value_results_in_valid_cached_value)
88
 
{
89
 
        cul::Provider::Controller::Cache<int> cached_value;
90
 
        cached_value.update(42);
91
 
        EXPECT_TRUE(cached_value.is_valid());
92
 
        EXPECT_EQ(42, cached_value.value());
93
 
}
94
 
 
95
 
TEST(CachedUpdates, invalidating_a_cached_value_results_in_cache_being_invalid)
96
 
{
97
 
        cul::Provider::Controller::Cache<int> cached_value;
98
 
        cached_value.update(42);
99
 
        EXPECT_TRUE(cached_value.is_valid());
100
 
        cached_value.invalidate();
101
 
        EXPECT_FALSE(cached_value.is_valid());
102
 
}
103
 
 
104
83
TEST(Controller, controller_starts_and_stops_updates_on_provider)
105
84
{
106
 
        using namespace ::testing;
107
 
 
108
 
        MockProvider provider;
109
 
 
110
 
        EXPECT_CALL(provider, start_position_updates()).Times(Exactly(1));
111
 
        EXPECT_CALL(provider, start_velocity_updates()).Times(Exactly(1));
112
 
        EXPECT_CALL(provider, start_heading_updates()).Times(Exactly(1));
113
 
        EXPECT_CALL(provider, stop_position_updates()).Times(Exactly(1));
114
 
        EXPECT_CALL(provider, stop_velocity_updates()).Times(Exactly(1));
115
 
        EXPECT_CALL(provider, stop_heading_updates()).Times(Exactly(1));
116
 
        
117
 
        auto controller = provider.state_controller();
118
 
 
119
 
        controller->start_position_updates();
120
 
        controller->start_velocity_updates();
121
 
        controller->start_heading_updates();
122
 
 
123
 
        EXPECT_TRUE(controller->are_position_updates_running());
124
 
        EXPECT_TRUE(controller->are_velocity_updates_running());
125
 
        EXPECT_TRUE(controller->are_heading_updates_running());
126
 
 
127
 
        controller->stop_position_updates();
128
 
        controller->stop_velocity_updates();
129
 
        controller->stop_heading_updates();
130
 
 
131
 
        EXPECT_FALSE(controller->are_position_updates_running());
132
 
        EXPECT_FALSE(controller->are_velocity_updates_running());
133
 
        EXPECT_FALSE(controller->are_heading_updates_running());        
134
 
}
135
 
 
136
 
TEST(Controller, controller_starts_and_stops_updates_on_provider_only_once)
137
 
{
138
 
        using namespace ::testing;
139
 
 
140
 
        MockProvider provider;
141
 
 
142
 
        EXPECT_CALL(provider, start_position_updates()).Times(Exactly(1));
143
 
        EXPECT_CALL(provider, start_velocity_updates()).Times(Exactly(1));
144
 
        EXPECT_CALL(provider, start_heading_updates()).Times(Exactly(1));
145
 
        EXPECT_CALL(provider, stop_position_updates()).Times(Exactly(1));
146
 
        EXPECT_CALL(provider, stop_velocity_updates()).Times(Exactly(1));
147
 
        EXPECT_CALL(provider, stop_heading_updates()).Times(Exactly(1));
148
 
        
149
 
        auto controller = provider.state_controller();
150
 
 
151
 
        controller->start_position_updates();
152
 
        controller->start_velocity_updates();
153
 
        controller->start_heading_updates();
154
 
 
155
 
        EXPECT_TRUE(controller->are_position_updates_running());
156
 
        EXPECT_TRUE(controller->are_velocity_updates_running());
157
 
        EXPECT_TRUE(controller->are_heading_updates_running());
158
 
 
159
 
        controller->start_position_updates();
160
 
        controller->start_velocity_updates();
161
 
        controller->start_heading_updates();
162
 
 
163
 
        EXPECT_TRUE(controller->are_position_updates_running());
164
 
        EXPECT_TRUE(controller->are_velocity_updates_running());
165
 
        EXPECT_TRUE(controller->are_heading_updates_running());
166
 
 
167
 
        controller->stop_position_updates();
168
 
        controller->stop_velocity_updates();
169
 
        controller->stop_heading_updates();
170
 
 
171
 
        EXPECT_TRUE(controller->are_position_updates_running());
172
 
        EXPECT_TRUE(controller->are_velocity_updates_running());
173
 
        EXPECT_TRUE(controller->are_heading_updates_running());
174
 
 
175
 
        controller->stop_position_updates();
176
 
        controller->stop_velocity_updates();
177
 
        controller->stop_heading_updates();
178
 
 
179
 
        EXPECT_FALSE(controller->are_position_updates_running());
180
 
        EXPECT_FALSE(controller->are_velocity_updates_running());
181
 
        EXPECT_FALSE(controller->are_heading_updates_running());        
182
 
}
183
 
 
184
 
TEST(Controller, controller_remembers_cached_updates)
185
 
{
186
 
        using namespace ::testing;
187
 
 
188
 
        MockProvider provider;
189
 
        auto controller = provider.state_controller();
190
 
 
191
 
        EXPECT_FALSE(controller->cached_position_update().is_valid());
192
 
        EXPECT_FALSE(controller->cached_velocity_update().is_valid());
193
 
        EXPECT_FALSE(controller->cached_heading_update().is_valid());
194
 
 
195
 
        provider.inject_update(reference_position_update);
196
 
 
197
 
        EXPECT_TRUE(controller->cached_position_update().is_valid());
198
 
        EXPECT_EQ(reference_position_update, controller->cached_position_update().value());
199
 
        EXPECT_FALSE(controller->cached_velocity_update().is_valid());
200
 
        EXPECT_FALSE(controller->cached_heading_update().is_valid());
201
 
 
202
 
        provider.inject_update(reference_velocity_update);
203
 
 
204
 
        EXPECT_TRUE(controller->cached_position_update().is_valid());
205
 
        EXPECT_EQ(reference_position_update, controller->cached_position_update().value());
206
 
        EXPECT_TRUE(controller->cached_velocity_update().is_valid());
207
 
        EXPECT_EQ(reference_velocity_update, controller->cached_velocity_update().value());
208
 
        EXPECT_FALSE(controller->cached_heading_update().is_valid());
209
 
 
210
 
        provider.inject_update(reference_heading_update);
211
 
 
212
 
        EXPECT_TRUE(controller->cached_position_update().is_valid());
213
 
        EXPECT_EQ(reference_position_update, controller->cached_position_update().value());
214
 
        EXPECT_TRUE(controller->cached_velocity_update().is_valid());
215
 
        EXPECT_EQ(reference_velocity_update, controller->cached_velocity_update().value());
216
 
        EXPECT_TRUE(controller->cached_heading_update().is_valid());
217
 
        EXPECT_EQ(reference_heading_update, controller->cached_heading_update().value());
218
 
}
219
 
 
 
85
    using namespace ::testing;
 
86
 
 
87
    MockProvider provider;
 
88
 
 
89
    EXPECT_CALL(provider, start_position_updates()).Times(Exactly(1));
 
90
    EXPECT_CALL(provider, start_velocity_updates()).Times(Exactly(1));
 
91
    EXPECT_CALL(provider, start_heading_updates()).Times(Exactly(1));
 
92
    EXPECT_CALL(provider, stop_position_updates()).Times(Exactly(1));
 
93
    EXPECT_CALL(provider, stop_velocity_updates()).Times(Exactly(1));
 
94
    EXPECT_CALL(provider, stop_heading_updates()).Times(Exactly(1));
 
95
 
 
96
    auto controller = provider.state_controller();
 
97
 
 
98
    controller->start_position_updates();
 
99
    controller->start_velocity_updates();
 
100
    controller->start_heading_updates();
 
101
 
 
102
    EXPECT_TRUE(controller->are_position_updates_running());
 
103
    EXPECT_TRUE(controller->are_velocity_updates_running());
 
104
    EXPECT_TRUE(controller->are_heading_updates_running());
 
105
 
 
106
    controller->stop_position_updates();
 
107
    controller->stop_velocity_updates();
 
108
    controller->stop_heading_updates();
 
109
 
 
110
    EXPECT_FALSE(controller->are_position_updates_running());
 
111
    EXPECT_FALSE(controller->are_velocity_updates_running());
 
112
    EXPECT_FALSE(controller->are_heading_updates_running());
 
113
}
 
114
 
 
115
TEST(Controller, controller_starts_and_stops_updates_on_provider_only_once_requires_hardware)
 
116
{
 
117
    using namespace ::testing;
 
118
 
 
119
    MockProvider provider;
 
120
 
 
121
    EXPECT_CALL(provider, start_position_updates()).Times(Exactly(1));
 
122
    EXPECT_CALL(provider, start_velocity_updates()).Times(Exactly(1));
 
123
    EXPECT_CALL(provider, start_heading_updates()).Times(Exactly(1));
 
124
    EXPECT_CALL(provider, stop_position_updates()).Times(Exactly(1));
 
125
    EXPECT_CALL(provider, stop_velocity_updates()).Times(Exactly(1));
 
126
    EXPECT_CALL(provider, stop_heading_updates()).Times(Exactly(1));
 
127
 
 
128
    auto controller = provider.state_controller();
 
129
 
 
130
    controller->start_position_updates();
 
131
    controller->start_velocity_updates();
 
132
    controller->start_heading_updates();
 
133
 
 
134
    EXPECT_TRUE(controller->are_position_updates_running());
 
135
    EXPECT_TRUE(controller->are_velocity_updates_running());
 
136
    EXPECT_TRUE(controller->are_heading_updates_running());
 
137
 
 
138
    controller->start_position_updates();
 
139
    controller->start_velocity_updates();
 
140
    controller->start_heading_updates();
 
141
 
 
142
    EXPECT_TRUE(controller->are_position_updates_running());
 
143
    EXPECT_TRUE(controller->are_velocity_updates_running());
 
144
    EXPECT_TRUE(controller->are_heading_updates_running());
 
145
 
 
146
    controller->stop_position_updates();
 
147
    controller->stop_velocity_updates();
 
148
    controller->stop_heading_updates();
 
149
 
 
150
    EXPECT_TRUE(controller->are_position_updates_running());
 
151
    EXPECT_TRUE(controller->are_velocity_updates_running());
 
152
    EXPECT_TRUE(controller->are_heading_updates_running());
 
153
 
 
154
    controller->stop_position_updates();
 
155
    controller->stop_velocity_updates();
 
156
    controller->stop_heading_updates();
 
157
 
 
158
    EXPECT_FALSE(controller->are_position_updates_running());
 
159
    EXPECT_FALSE(controller->are_velocity_updates_running());
 
160
    EXPECT_FALSE(controller->are_heading_updates_running());
 
161
}