← Back to branch summary

~oif-packaging/frame/debian

« back to all changes in this revision

Viewing changes to test/regular/backend.cpp

  • Committer: Daniel d'Andrada
  • Date: 2012-11-08 16:04:20 UTC
  • mto: This revision was merged to the branch mainline in revision 84.
  • Revision ID: daniel.dandrada@canonical.com-20121108160420-ql9g1jm5t9xifyxs
Tags: upstream-2.4.3
Import upstream version 2.4.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/regular/backend.cpp
 
1
#include <gtest/gtest.h>
 
2
#include "oif/frame_backend.h"
 
3
 
 
4
TEST(Backend, Touch)
 
5
{
 
6
  UFStatus status;
 
7
 
 
8
  UFBackendTouch touch_backend = frame_backend_touch_new();
 
9
  ASSERT_TRUE(touch_backend != nullptr);
 
10
 
 
11
  UFTouch touch = frame_backend_touch_get_touch(touch_backend);
 
12
  ASSERT_TRUE(touch != nullptr);
 
13
 
 
14
  ASSERT_EQ(UFTouchStateBegin, frame_touch_get_state(touch));
 
15
 
 
16
  frame_backend_touch_set_id(touch_backend, 123);
 
17
  ASSERT_EQ(123, frame_touch_get_id(touch));
 
18
 
 
19
  frame_backend_touch_set_ended(touch_backend);
 
20
  ASSERT_EQ(UFTouchStateEnd, frame_touch_get_state(touch));
 
21
 
 
22
  frame_backend_touch_set_window_pos(touch_backend, 1.2f, 3.4f);
 
23
  ASSERT_EQ(1.2f, frame_touch_get_window_x(touch));
 
24
  ASSERT_EQ(3.4f, frame_touch_get_window_y(touch));
 
25
 
 
26
  frame_backend_touch_set_time(touch_backend, 852);
 
27
  ASSERT_EQ(852, frame_touch_get_time(touch));
 
28
 
 
29
  frame_backend_touch_set_start_time(touch_backend, 555);
 
30
  ASSERT_EQ(555, frame_touch_get_start_time(touch));
 
31
 
 
32
  frame_backend_touch_set_owned(touch_backend, 1);
 
33
  int owned = 0;
 
34
  status = frame_touch_get_property(touch, UFTouchPropertyOwned, &owned);
 
35
  ASSERT_EQ(UFStatusSuccess, status);
 
36
  ASSERT_EQ(1, owned);
 
37
 
 
38
  frame_backend_touch_set_pending_end(touch_backend, 1);
 
39
  int pending_end = 0;
 
40
  status = frame_touch_get_property(touch, UFTouchPropertyPendingEnd, &pending_end);
 
41
  ASSERT_EQ(UFStatusSuccess, status);
 
42
  ASSERT_EQ(1, pending_end);
 
43
 
 
44
  frame_backend_touch_set_value(touch_backend, UFAxisTypeTouchMajor, 987.6f);
 
45
  float touch_major = 0.0f;
 
46
  status = frame_touch_get_value(touch, UFAxisTypeTouchMajor, &touch_major);
 
47
  ASSERT_EQ(UFStatusSuccess, status);
 
48
  ASSERT_EQ(987.6f, touch_major);
 
49
 
 
50
  /* clean up */
 
51
  UFBackendFrame frame = frame_backend_frame_new();
 
52
  frame_backend_frame_give_touch(frame, &touch_backend);
 
53
  frame_backend_frame_delete(frame);
 
54
}
 
55
 
 
56
TEST(Backend, Device)
 
57
{
 
58
  UFStatus status;
 
59
 
 
60
  UFBackendDevice device_backend = frame_backend_device_new();
 
61
  ASSERT_NE(nullptr, device_backend);
 
62
 
 
63
  UFDevice device = frame_backend_device_get_device(device_backend);
 
64
  ASSERT_NE(nullptr, device);
 
65
 
 
66
  const char *name = nullptr;
 
67
  status = frame_device_get_property(device, UFDevicePropertyName, &name);
 
68
  ASSERT_EQ(UFStatusErrorUnknownProperty, status);
 
69
  frame_backend_device_set_name(device_backend, "Hello World");
 
70
  status = frame_device_get_property(device, UFDevicePropertyName, &name);
 
71
  ASSERT_EQ(UFStatusSuccess, status);
 
72
  ASSERT_STREQ("Hello World", name);
 
73
 
 
74
  int direct = 0;
 
75
  status = frame_device_get_property(device, UFDevicePropertyDirect, &direct);
 
76
  ASSERT_EQ(UFStatusErrorUnknownProperty, status);
 
77
  frame_backend_device_set_direct(device_backend, 1);
 
78
  status = frame_device_get_property(device, UFDevicePropertyDirect, &direct);
 
79
  ASSERT_EQ(UFStatusSuccess, status);
 
80
  ASSERT_EQ(1, direct);
 
81
 
 
82
  int independent = 0;
 
83
  status = frame_device_get_property(device, UFDevicePropertyIndependent, &independent);
 
84
  ASSERT_EQ(UFStatusErrorUnknownProperty, status);
 
85
  frame_backend_device_set_independent(device_backend, 1);
 
86
  status = frame_device_get_property(device, UFDevicePropertyIndependent, &independent);
 
87
  ASSERT_EQ(UFStatusSuccess, status);
 
88
  ASSERT_EQ(1, independent);
 
89
 
 
90
  int semi_mt = 0;
 
91
  status = frame_device_get_property(device, UFDevicePropertySemiMT, &semi_mt);
 
92
  ASSERT_EQ(UFStatusErrorUnknownProperty, status);
 
93
  frame_backend_device_set_semi_mt(device_backend, 1);
 
94
  status = frame_device_get_property(device, UFDevicePropertySemiMT, &semi_mt);
 
95
  ASSERT_EQ(UFStatusSuccess, status);
 
96
  ASSERT_EQ(1, semi_mt);
 
97
 
 
98
  unsigned int max_touches = 0;
 
99
  status = frame_device_get_property(device, UFDevicePropertyMaxTouches, &max_touches);
 
100
  ASSERT_EQ(UFStatusErrorUnknownProperty, status);
 
101
  frame_backend_device_set_max_touches(device_backend, 5);
 
102
  status = frame_device_get_property(device, UFDevicePropertyMaxTouches, &max_touches);
 
103
  ASSERT_EQ(UFStatusSuccess, status);
 
104
  ASSERT_EQ(5, max_touches);
 
105
 
 
106
  frame_backend_device_set_window_resolution(device_backend, 1024.0f, 768.0f);
 
107
  ASSERT_EQ(1024.0f, frame_device_get_window_resolution_x(device));
 
108
  ASSERT_EQ(768.0f, frame_device_get_window_resolution_y(device));
 
109
 
 
110
  unsigned int num_axes = 0;
 
111
  status = frame_device_get_property(device, UFDevicePropertyNumAxes, &num_axes);
 
112
  ASSERT_EQ(UFStatusSuccess, status);
 
113
  ASSERT_EQ(0, num_axes);
 
114
  frame_backend_device_add_axis(device_backend,
 
115
                        UFAxisTypePressure, 1.0f, 1000.0f, 3.5f);
 
116
  status = frame_device_get_property(device, UFDevicePropertyNumAxes, &num_axes);
 
117
  ASSERT_EQ(UFStatusSuccess, status);
 
118
  ASSERT_EQ(1, num_axes);
 
119
  UFAxis axis = nullptr;
 
120
  status = frame_device_get_axis_by_type(device, UFAxisTypePressure, &axis);
 
121
  ASSERT_EQ(UFStatusSuccess, status);
 
122
  ASSERT_NE(nullptr, axis);
 
123
  ASSERT_EQ(UFAxisTypePressure, frame_axis_get_type(axis));
 
124
  ASSERT_EQ(1.0f, frame_axis_get_minimum(axis));
 
125
  ASSERT_EQ(1000.0f, frame_axis_get_maximum(axis));
 
126
  ASSERT_EQ(3.5f, frame_axis_get_resolution(axis));
 
127
 
 
128
  frame_backend_device_delete(device_backend);
 
129
}
 
130
 
 
131
TEST(Backend, Frame)
 
132
{
 
133
  UFStatus status;
 
134
 
 
135
  UFBackendFrame frame_backend = frame_backend_frame_new();
 
136
  ASSERT_NE(nullptr, frame_backend);
 
137
 
 
138
  UFFrame frame = frame_backend_frame_get_frame(frame_backend);
 
139
  ASSERT_NE(nullptr, frame);
 
140
 
 
141
  UFBackendDevice device_backend = frame_backend_device_new();
 
142
  UFDevice device = frame_backend_device_get_device(device_backend);
 
143
 
 
144
  frame_backend_frame_set_device(frame_backend, device_backend);
 
145
  ASSERT_EQ(device, frame_frame_get_device(frame));
 
146
 
 
147
  frame_backend_frame_set_window_id(frame_backend, 123);
 
148
  ASSERT_EQ(123, frame_frame_get_window_id(frame));
 
149
 
 
150
 
 
151
  unsigned int active_touches = 0;
 
152
  UFBackendTouch touch_backend = frame_backend_touch_new();
 
153
  UFTouch touch = frame_backend_touch_get_touch(touch_backend);
 
154
  frame_backend_touch_set_id(touch_backend, 10);
 
155
  UFTouch touch_retrieved = nullptr;
 
156
  ASSERT_EQ(0, frame_frame_get_num_touches(frame));
 
157
  status = frame_frame_get_property(frame, UFFramePropertyActiveTouches, &active_touches);
 
158
  ASSERT_EQ(UFStatusSuccess, status);
 
159
  ASSERT_EQ(0, active_touches);
 
160
  status = frame_backend_frame_give_touch(frame_backend, &touch_backend);
 
161
  ASSERT_EQ(UFStatusSuccess, status);
 
162
  ASSERT_EQ(nullptr, touch_backend);
 
163
  ASSERT_EQ(1, frame_frame_get_num_touches(frame));
 
164
  status = frame_frame_get_property(frame, UFFramePropertyActiveTouches, &active_touches);
 
165
  ASSERT_EQ(UFStatusSuccess, status);
 
166
  ASSERT_EQ(1, active_touches);
 
167
  status = frame_frame_get_touch_by_id(frame, 10, &touch_retrieved);
 
168
  ASSERT_EQ(UFStatusSuccess, status);
 
169
  ASSERT_EQ(touch, touch_retrieved);
 
170
 
 
171
  frame_backend_frame_set_active_touches(frame_backend, 3);
 
172
  status = frame_frame_get_property(frame, UFFramePropertyActiveTouches, &active_touches);
 
173
  ASSERT_EQ(UFStatusSuccess, status);
 
174
  ASSERT_EQ(3, active_touches);
 
175
 
 
176
  frame_backend_frame_delete(frame_backend);
 
177
  frame_backend_device_delete(device_backend);
 
178
}
 
179
 
 
180
TEST(Backend, FrameBorrowInexistentTouch)
 
181
{
 
182
  UFStatus status;
 
183
 
 
184
  UFBackendFrame frame_backend = frame_backend_frame_new();
 
185
 
 
186
  UFBackendTouch touch_backend;
 
187
  status = frame_backend_frame_borrow_touch_by_id(frame_backend, 123, &touch_backend);
 
188
  ASSERT_EQ(UFStatusErrorInvalidTouch, status);
 
189
 
 
190
  /* clean up */
 
191
  frame_backend_frame_delete(frame_backend);
 
192
}
 
193
 
 
194
TEST(Backend, FrameCreateNext)
 
195
{
 
196
  UFStatus status;
 
197
 
 
198
  /* frame 1  */
 
199
  UFBackendTouch touch_backend = frame_backend_touch_new();
 
200
  frame_backend_touch_set_id(touch_backend, 1);
 
201
  UFTouch frame1_touch = frame_backend_touch_get_touch(touch_backend);
 
202
 
 
203
  UFBackendFrame frame1_backend = frame_backend_frame_new();
 
204
  status = frame_backend_frame_give_touch(frame1_backend, &touch_backend);
 
205
  ASSERT_EQ(UFStatusSuccess, status);
 
206
 
 
207
  /* frame 2 */
 
208
  UFBackendFrame frame2_backend = frame_backend_frame_create_next(frame1_backend);
 
209
  UFFrame frame2 = frame_backend_frame_get_frame(frame2_backend);
 
210
 
 
211
  UFTouch frame2_touch;
 
212
  status = frame_frame_get_touch_by_id(frame2, 1, &frame2_touch);
 
213
  ASSERT_EQ(UFStatusSuccess, status);
 
214
 
 
215
  /* frame 3 */
 
216
  UFBackendFrame frame3_backend = frame_backend_frame_create_next(frame2_backend);
 
217
  UFFrame frame3 = frame_backend_frame_get_frame(frame3_backend);
 
218
 
 
219
  UFTouch frame3_touch;
 
220
  status = frame_frame_get_touch_by_id(frame3, 1, &frame3_touch);
 
221
  ASSERT_EQ(UFStatusSuccess, status);
 
222
 
 
223
  /* frame 4 */
 
224
  UFBackendFrame frame4_backend = frame_backend_frame_create_next(frame3_backend);
 
225
 
 
226
  status = frame_backend_frame_borrow_touch_by_id(frame4_backend, 1, &touch_backend);
 
227
  ASSERT_EQ(UFStatusSuccess, status);
 
228
  frame_backend_touch_set_ended(touch_backend);
 
229
  status = frame_backend_frame_give_touch(frame4_backend, &touch_backend);
 
230
  ASSERT_EQ(UFStatusSuccess, status);
 
231
 
 
232
  UFFrame frame4 = frame_backend_frame_get_frame(frame4_backend);
 
233
  UFTouch frame4_touch;
 
234
  status = frame_frame_get_touch_by_id(frame4, 1, &frame4_touch);
 
235
  ASSERT_EQ(UFStatusSuccess, status);
 
236
 
 
237
  /* frame 5 */
 
238
  UFBackendFrame frame5_backend = frame_backend_frame_create_next(frame4_backend);
 
239
  UFFrame frame5 = frame_backend_frame_get_frame(frame5_backend);
 
240
 
 
241
  /* Test the status of touch 1 throughout all frames */
 
242
  ASSERT_EQ(UFTouchStateBegin, frame_touch_get_state(frame1_touch));
 
243
  ASSERT_EQ(UFTouchStateUpdate, frame_touch_get_state(frame2_touch));
 
244
  ASSERT_EQ(UFTouchStateUpdate, frame_touch_get_state(frame3_touch));
 
245
  ASSERT_EQ(frame2_touch, frame3_touch);
 
246
  ASSERT_EQ(UFTouchStateEnd, frame_touch_get_state(frame4_touch));
 
247
  ASSERT_EQ(0, frame_frame_get_num_touches(frame5));
 
248
 
 
249
  /* clean up */
 
250
  frame_backend_frame_delete(frame1_backend);
 
251
  frame_backend_frame_delete(frame2_backend);
 
252
  frame_backend_frame_delete(frame3_backend);
 
253
  frame_backend_frame_delete(frame4_backend);
 
254
  frame_backend_frame_delete(frame5_backend);
 
255
}
 
256
 
 
257
TEST(Backend, Event)
 
258
{
 
259
  UFStatus status;
 
260
 
 
261
  UFEvent event = frame_event_new();
 
262
  ASSERT_NE(nullptr, event);
 
263
 
 
264
  frame_event_set_type(event, UFEventTypeDeviceRemoved);
 
265
  ASSERT_EQ(UFEventTypeDeviceRemoved, frame_event_get_type(event));
 
266
 
 
267
  UFBackendDevice device_backend = frame_backend_device_new();
 
268
  UFDevice device = frame_backend_device_get_device(device_backend);
 
269
  UFDevice device_retrieved = nullptr;
 
270
  frame_event_set_device(event, device_backend);
 
271
  status = frame_event_get_property(event, UFEventPropertyDevice, &device_retrieved);
 
272
  ASSERT_EQ(UFStatusSuccess, status);
 
273
  ASSERT_EQ(device, device_retrieved);
 
274
 
 
275
  UFBackendFrame frame_backend = frame_backend_frame_new();
 
276
  UFFrame frame = frame_backend_frame_get_frame(frame_backend);
 
277
  UFFrame frame_retrieved = nullptr;
 
278
  frame_event_set_frame(event, frame_backend);
 
279
  status = frame_event_get_property(event, UFEventPropertyFrame, &frame_retrieved);
 
280
  ASSERT_EQ(UFStatusSuccess, status);
 
281
  ASSERT_EQ(frame, frame_retrieved);
 
282
 
 
283
  frame_event_set_time(event, 1234);
 
284
  ASSERT_EQ(1234, frame_event_get_time(event));
 
285
 
 
286
  frame_event_unref(event);
 
287
  frame_backend_device_delete(device_backend);
 
288
  frame_backend_frame_delete(frame_backend);
 
289
}