← Back to branch summary

~brandontschaefer/unity/lp.1211501-fix

« back to all changes in this revision

Viewing changes to tests/test_edge_barrier_controller.cpp

  • Committer: Tarmac
  • Author(s): Andrea Azzarone
  • Date: 2013-08-11 10:41:29 UTC
  • mfrom: (3456.2.4 unity)
  • Revision ID: tarmac-20130811104129-bzq967y7jv1125ya
Add edge barriers to unity::panel::PanelView. Fixes: https://bugs.launchpad.net/bugs/931384.

Approved by PS Jenkins bot, Brandon Schaefer.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_edge_barrier_controller.cpp
1
1
/*
2
 
 * Copyright 2012 Canonical Ltd.
 
2
 * Copyright 2012-2013 Canonical Ltd.
3
3
 *
4
4
 * This program is free software: you can redistribute it and/or modify it
5
5
 * under the terms of the GNU General Public License version 3, as published
15
15
 * <http://www.gnu.org/licenses/>
16
16
 *
17
17
 * Authored by: Marco Trevisan (Treviño) <marco.trevisan@canonical.com>
 
18
 *              Andrea Azzarone <andrea.azzarone@canonical.com>
18
19
 *
19
20
 */
20
21
 
32
33
namespace
33
34
{
34
35
 
35
 
class MockPointerBarrier : public PointerBarrierWrapper
 
36
class MockPointerBarrierWrapper : public PointerBarrierWrapper
36
37
{
37
38
public:
38
 
  MockPointerBarrier(int monitor = 0, bool released_ = false)
 
39
  MockPointerBarrierWrapper(int monitor = 0, bool released_ = false, BarrierOrientation orientation_ = VERTICAL)
39
40
  {
40
41
    index = monitor;
41
42
    x1 = 1;
42
43
    released = released_;
 
44
    orientation = orientation_;
43
45
  }
44
46
 
45
47
  MOCK_METHOD0(ConstructBarrier, void());
80
82
    for (unsigned i = 0; i < monitors::MAX; ++i)
81
83
    {
82
84
      // By default we assume that no subscriber handles the events!!!
83
 
      bc.Subscribe(&subscribers_[i], i);
 
85
      bc.AddVerticalSubscriber(&vertical_subscribers_[i], i);
 
86
      bc.AddHorizontalSubscriber(&horizontal_subscribers_[i], i);
84
87
    }
85
88
  }
86
89
 
101
104
  }
102
105
 
103
106
 
104
 
  TestBarrierSubscriber subscribers_[monitors::MAX];
 
107
  TestBarrierSubscriber horizontal_subscribers_[monitors::MAX];
 
108
  TestBarrierSubscriber vertical_subscribers_[monitors::MAX];
105
109
  MockUScreen uscreen;
106
110
  EdgeBarrierController bc;
107
111
};
116
120
  EXPECT_TRUE(bc.sticky_edges);
117
121
 
118
122
  for (unsigned i = 0; i < monitors::MAX; ++i)
119
 
    ASSERT_EQ(bc.GetSubscriber(i), &subscribers_[i]);
120
 
}
121
 
 
122
 
TEST_F(TestEdgeBarrierController, Unsubscribe)
123
 
{
124
 
  for (unsigned i = 0; i < monitors::MAX; ++i)
125
 
  {
126
 
    bc.Unsubscribe(&subscribers_[i], i);
127
 
    ASSERT_EQ(bc.GetSubscriber(i), nullptr);
128
 
  }
129
 
}
130
 
 
131
 
TEST_F(TestEdgeBarrierController, UnsubscribeInvalid)
132
 
{
133
 
  bc.Unsubscribe(&subscribers_[2], 1);
134
 
  ASSERT_EQ(bc.GetSubscriber(2), &subscribers_[2]);
135
 
}
136
 
 
137
 
TEST_F(TestEdgeBarrierController, SubscriberReplace)
138
 
{
139
 
  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
140
 
  bc.Subscribe(&handling_subscriber, 0);
141
 
  EXPECT_EQ(bc.GetSubscriber(0), &handling_subscriber);
142
 
}
143
 
 
144
 
TEST_F(TestEdgeBarrierController, ProcessHandledEvent)
145
 
{
146
 
  int monitor = 0;
147
 
 
148
 
  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
149
 
  bc.Subscribe(&handling_subscriber, monitor);
150
 
 
151
 
  MockPointerBarrier owner(monitor);
152
 
  auto breaking_barrier_event = MakeBarrierEvent(0, true);
153
 
 
154
 
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
155
 
  ProcessBarrierEvent(&owner, breaking_barrier_event);
156
 
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
157
 
}
158
 
 
159
 
TEST_F(TestEdgeBarrierController, ProcessHandledEventOnReleasedBarrier)
160
 
{
161
 
  int monitor = monitors::MAX-1;
162
 
 
163
 
  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
164
 
  bc.Subscribe(&handling_subscriber, monitor);
165
 
 
166
 
  MockPointerBarrier owner(monitor, true);
167
 
  auto breaking_barrier_event = MakeBarrierEvent(5, true);
168
 
 
169
 
  EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
170
 
  ProcessBarrierEvent(&owner, breaking_barrier_event);
171
 
}
172
 
 
173
 
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrier)
174
 
{
175
 
  int monitor = 1;
176
 
 
177
 
  MockPointerBarrier owner(monitor);
178
 
  int breaking_id = 12345;
179
 
  auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
180
 
 
181
 
  EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
182
 
  ProcessBarrierEvent(&owner, breaking_barrier_event);
183
 
}
184
 
 
185
 
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitor)
186
 
{
187
 
  int monitor = monitors::MAX;
188
 
 
189
 
  MockPointerBarrier owner(monitor);
190
 
  auto breaking_barrier_event = MakeBarrierEvent(0, true);
191
 
 
192
 
  EXPECT_CALL(owner, ReleaseBarrier(_));
193
 
  ProcessBarrierEvent(&owner, breaking_barrier_event);
194
 
}
195
 
 
196
 
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrier)
197
 
{
198
 
  int monitor = 2;
199
 
 
200
 
  MockPointerBarrier owner(monitor);
201
 
  int not_breaking_id = 54321;
202
 
  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
203
 
 
204
 
  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
205
 
  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
206
 
}
207
 
 
208
 
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrier)
209
 
{
210
 
  int monitor = 2;
211
 
 
212
 
  MockPointerBarrier owner(monitor, true);
213
 
  int not_breaking_id = 345678;
214
 
  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
215
 
 
216
 
  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
217
 
  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
218
 
}
219
 
 
220
 
TEST_F(TestEdgeBarrierController, ProcessAlreadyHandledEvent)
221
 
{
222
 
  int monitor = g_random_int_range(0, monitors::MAX);
223
 
 
224
 
  MockPointerBarrier owner(monitor);
225
 
  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
226
 
 
227
 
  auto event = MakeBarrierEvent(g_random_int(), false);
228
 
 
229
 
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
230
 
  ProcessBarrierEvent(&owner, event);
231
 
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
232
 
}
233
 
 
234
 
TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithStickyEdges)
235
 
{
236
 
  int monitor = g_random_int_range(0, monitors::MAX);
237
 
 
238
 
  bc.sticky_edges = true;
239
 
  MockPointerBarrier owner(monitor);
240
 
  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
241
 
 
242
 
  auto event = MakeBarrierEvent(g_random_int(), false);
243
 
 
244
 
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
245
 
  ProcessBarrierEvent(&owner, event);
246
 
  EXPECT_FALSE(owner.released());
247
 
  EXPECT_FALSE(owner.release_once());
248
 
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
249
 
}
250
 
 
251
 
TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithOutStickyEdges)
252
 
{
253
 
  int monitor = g_random_int_range(0, monitors::MAX);
254
 
 
255
 
  bc.sticky_edges = false;
256
 
  MockPointerBarrier owner(monitor);
257
 
  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
258
 
 
259
 
  auto event = MakeBarrierEvent(g_random_int(), false);
260
 
 
261
 
  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
262
 
  ProcessBarrierEvent(&owner, event);
263
 
  EXPECT_TRUE(owner.released());
264
 
  EXPECT_TRUE(owner.release_once());
265
 
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
266
 
}
267
 
 
268
 
TEST_F(TestEdgeBarrierController, ProcessNeedsReleaseEvent)
269
 
{
270
 
  int monitor = g_random_int_range(0, monitors::MAX);
271
 
 
272
 
  MockPointerBarrier owner(monitor);
273
 
  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
274
 
 
275
 
  auto event = MakeBarrierEvent(g_random_int(), false);
276
 
 
277
 
  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
278
 
  ProcessBarrierEvent(&owner, event);
279
 
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
280
 
}
281
 
 
282
 
TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrier)
283
 
{
284
 
  MockPointerBarrier owner;
285
 
 
286
 
  EXPECT_CALL(owner, ReleaseBarrier(1));
287
 
  ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
288
 
  ASSERT_TRUE(owner.released());
289
 
 
290
 
  Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
291
 
  EXPECT_FALSE(owner.released());
292
 
}
293
 
 
294
 
TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEvents)
295
 
{
296
 
  MockPointerBarrier owner;
297
 
  int monitor = 0;
298
 
  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
299
 
 
300
 
  EXPECT_CALL(owner, ReleaseBarrier(5));
301
 
  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
302
 
  ASSERT_TRUE(owner.released());
303
 
 
304
 
  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
305
 
  EXPECT_CALL(owner, ReleaseBarrier(6));
306
 
  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
307
 
}
308
 
 
309
 
TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEvents)
310
 
{
311
 
  MockPointerBarrier owner;
312
 
  int monitor = 0;
313
 
  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
314
 
 
315
 
  EXPECT_CALL(owner, ReleaseBarrier(5));
316
 
  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
317
 
  ASSERT_TRUE(owner.released());
318
 
 
319
 
  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
 
123
  {
 
124
    ASSERT_EQ(bc.GetVerticalSubscriber(i), &vertical_subscribers_[i]);
 
125
    ASSERT_EQ(bc.GetHorizontalSubscriber(i), &horizontal_subscribers_[i]);
 
126
  }
 
127
}
 
128
 
 
129
TEST_F(TestEdgeBarrierController, RemoveVerticalSubscriber)
 
130
{
 
131
  for (unsigned i = 0; i < monitors::MAX; ++i)
 
132
  {
 
133
    bc.RemoveVerticalSubscriber(&vertical_subscribers_[i], i);
 
134
    ASSERT_EQ(bc.GetVerticalSubscriber(i), nullptr);
 
135
  }
 
136
}
 
137
 
 
138
TEST_F(TestEdgeBarrierController, RemoveHorizontalSubscriber)
 
139
{
 
140
  for (unsigned i = 0; i < monitors::MAX; ++i)
 
141
  {
 
142
    bc.RemoveHorizontalSubscriber(&horizontal_subscribers_[i], i);
 
143
    ASSERT_EQ(bc.GetHorizontalSubscriber(i), nullptr);
 
144
  }
 
145
}
 
146
 
 
147
TEST_F(TestEdgeBarrierController, RemoveVerticalSubscriberInvalid)
 
148
{
 
149
  bc.RemoveVerticalSubscriber(&vertical_subscribers_[2], 1);
 
150
  ASSERT_EQ(bc.GetVerticalSubscriber(2), &vertical_subscribers_[2]);
 
151
}
 
152
 
 
153
TEST_F(TestEdgeBarrierController, RemoveHorizontalSubscriberInvalid)
 
154
{
 
155
  bc.RemoveHorizontalSubscriber(&horizontal_subscribers_[2], 1);
 
156
  ASSERT_EQ(bc.GetHorizontalSubscriber(2), &horizontal_subscribers_[2]);
 
157
}
 
158
 
 
159
TEST_F(TestEdgeBarrierController, VerticalSubscriberReplace)
 
160
{
 
161
  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
 
162
  bc.AddVerticalSubscriber(&handling_subscriber, 0);
 
163
  EXPECT_EQ(bc.GetVerticalSubscriber(0), &handling_subscriber);
 
164
}
 
165
 
 
166
TEST_F(TestEdgeBarrierController, HorizontalSubscriberReplace)
 
167
{
 
168
  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
 
169
  bc.AddHorizontalSubscriber(&handling_subscriber, 0);
 
170
  EXPECT_EQ(bc.GetHorizontalSubscriber(0), &handling_subscriber);
 
171
}
 
172
 
 
173
TEST_F(TestEdgeBarrierController, ProcessHandledEventForVerticalSubscriber)
 
174
{
 
175
  int monitor = 0;
 
176
 
 
177
  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
 
178
  bc.AddVerticalSubscriber(&handling_subscriber, monitor);
 
179
 
 
180
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
181
  auto breaking_barrier_event = MakeBarrierEvent(0, true);
 
182
 
 
183
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
 
184
  ProcessBarrierEvent(&owner, breaking_barrier_event);
 
185
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 
186
}
 
187
 
 
188
TEST_F(TestEdgeBarrierController, ProcessHandledEventForHorizontalSubscriber)
 
189
{
 
190
  int monitor = 0;
 
191
 
 
192
  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
 
193
  bc.AddHorizontalSubscriber(&handling_subscriber, monitor);
 
194
 
 
195
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
196
  auto breaking_barrier_event = MakeBarrierEvent(0, true);
 
197
 
 
198
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
 
199
  ProcessBarrierEvent(&owner, breaking_barrier_event);
 
200
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 
201
}
 
202
 
 
203
TEST_F(TestEdgeBarrierController, ProcessHandledEventOnReleasedBarrierForVerticalSubscriber)
 
204
{
 
205
  int monitor = monitors::MAX-1;
 
206
 
 
207
  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
 
208
  bc.AddVerticalSubscriber(&handling_subscriber, monitor);
 
209
 
 
210
  MockPointerBarrierWrapper owner(monitor, true, VERTICAL);
 
211
  auto breaking_barrier_event = MakeBarrierEvent(5, true);
 
212
 
 
213
  EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
 
214
  ProcessBarrierEvent(&owner, breaking_barrier_event);
 
215
}
 
216
 
 
217
TEST_F(TestEdgeBarrierController, ProcessHandledEventOnReleasedBarrierForHorizontalSubscriber)
 
218
{
 
219
  int monitor = monitors::MAX-1;
 
220
 
 
221
  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
 
222
  bc.AddHorizontalSubscriber(&handling_subscriber, monitor);
 
223
 
 
224
  MockPointerBarrierWrapper owner(monitor, true, HORIZONTAL);
 
225
  auto breaking_barrier_event = MakeBarrierEvent(5, true);
 
226
 
 
227
  EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
 
228
  ProcessBarrierEvent(&owner, breaking_barrier_event);
 
229
}
 
230
 
 
231
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierForVerticalSubscriber)
 
232
{
 
233
  int monitor = 1;
 
234
 
 
235
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
236
  int breaking_id = 12345;
 
237
  auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
 
238
 
 
239
  EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
 
240
  ProcessBarrierEvent(&owner, breaking_barrier_event);
 
241
}
 
242
 
 
243
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierForHorizontalSubscriber)
 
244
{
 
245
  int monitor = 1;
 
246
 
 
247
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
248
  int breaking_id = 12345;
 
249
  auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
 
250
 
 
251
  EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
 
252
  ProcessBarrierEvent(&owner, breaking_barrier_event);
 
253
}
 
254
 
 
255
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitorForVerticalSubscriber)
 
256
{
 
257
  int monitor = monitors::MAX;
 
258
 
 
259
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
260
  auto breaking_barrier_event = MakeBarrierEvent(0, true);
 
261
 
 
262
  EXPECT_CALL(owner, ReleaseBarrier(_));
 
263
  ProcessBarrierEvent(&owner, breaking_barrier_event);
 
264
}
 
265
 
 
266
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitorForHorizontalSubscriber)
 
267
{
 
268
  int monitor = monitors::MAX;
 
269
 
 
270
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
271
  auto breaking_barrier_event = MakeBarrierEvent(0, true);
 
272
 
 
273
  EXPECT_CALL(owner, ReleaseBarrier(_));
 
274
  ProcessBarrierEvent(&owner, breaking_barrier_event);
 
275
}
 
276
 
 
277
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrierForVerticalSubscriber)
 
278
{
 
279
  int monitor = 2;
 
280
 
 
281
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
282
  int not_breaking_id = 54321;
 
283
  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
 
284
 
 
285
  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
 
286
  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
 
287
}
 
288
 
 
289
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrierForHorizontalSubscriber)
 
290
{
 
291
  int monitor = 2;
 
292
 
 
293
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
294
  int not_breaking_id = 54321;
 
295
  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
 
296
 
 
297
  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
 
298
  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
 
299
}
 
300
 
 
301
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrierForVerticalSubscriber)
 
302
{
 
303
  int monitor = 2;
 
304
 
 
305
  MockPointerBarrierWrapper owner(monitor, true, VERTICAL);
 
306
  int not_breaking_id = 345678;
 
307
  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
 
308
 
 
309
  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
 
310
  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
 
311
}
 
312
 
 
313
TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrierForHorizontalSubscriber)
 
314
{
 
315
  int monitor = 2;
 
316
 
 
317
  MockPointerBarrierWrapper owner(monitor, true, HORIZONTAL);
 
318
  int not_breaking_id = 345678;
 
319
  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
 
320
 
 
321
  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
 
322
  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
 
323
}
 
324
 
 
325
TEST_F(TestEdgeBarrierController, ProcessAlreadyHandledEventForVerticalSubscriber)
 
326
{
 
327
  int monitor = g_random_int_range(0, monitors::MAX);
 
328
 
 
329
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
330
  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
 
331
 
 
332
  auto event = MakeBarrierEvent(g_random_int(), false);
 
333
 
 
334
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
 
335
  ProcessBarrierEvent(&owner, event);
 
336
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
 
337
}
 
338
 
 
339
TEST_F(TestEdgeBarrierController, ProcessAlreadyHandledEventForHorizontalSubscriber)
 
340
{
 
341
  int monitor = g_random_int_range(0, monitors::MAX);
 
342
 
 
343
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
344
  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
 
345
 
 
346
  auto event = MakeBarrierEvent(g_random_int(), false);
 
347
 
 
348
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
 
349
  ProcessBarrierEvent(&owner, event);
 
350
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
 
351
}
 
352
 
 
353
TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithStickyEdgesForVerticalSubscriber)
 
354
{
 
355
  int monitor = g_random_int_range(0, monitors::MAX);
 
356
 
 
357
  bc.sticky_edges = true;
 
358
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
359
  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
360
 
 
361
  auto event = MakeBarrierEvent(g_random_int(), false);
 
362
 
 
363
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
 
364
  ProcessBarrierEvent(&owner, event);
 
365
  EXPECT_FALSE(owner.released());
 
366
  EXPECT_FALSE(owner.release_once());
 
367
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
 
368
}
 
369
 
 
370
TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithStickyEdgesForHorizontalSubscriber)
 
371
{
 
372
  int monitor = g_random_int_range(0, monitors::MAX);
 
373
 
 
374
  bc.sticky_edges = true;
 
375
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
376
  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
377
 
 
378
  auto event = MakeBarrierEvent(g_random_int(), false);
 
379
 
 
380
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
 
381
  ProcessBarrierEvent(&owner, event);
 
382
  EXPECT_FALSE(owner.released());
 
383
  EXPECT_FALSE(owner.release_once());
 
384
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
 
385
}
 
386
 
 
387
TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithOutStickyEdgesForVerticalSubscriber)
 
388
{
 
389
  int monitor = g_random_int_range(0, monitors::MAX);
 
390
 
 
391
  bc.sticky_edges = false;
 
392
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
393
  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
394
 
 
395
  auto event = MakeBarrierEvent(g_random_int(), false);
 
396
 
 
397
  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
 
398
  ProcessBarrierEvent(&owner, event);
 
399
  EXPECT_TRUE(owner.released());
 
400
  EXPECT_TRUE(owner.release_once());
 
401
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 
402
}
 
403
 
 
404
TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithOutStickyEdgesForHoriziontalSubscriber)
 
405
{
 
406
  int monitor = g_random_int_range(0, monitors::MAX);
 
407
 
 
408
  bc.sticky_edges = false;
 
409
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
410
  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
411
 
 
412
  auto event = MakeBarrierEvent(g_random_int(), false);
 
413
 
 
414
  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
 
415
  ProcessBarrierEvent(&owner, event);
 
416
  EXPECT_TRUE(owner.released());
 
417
  EXPECT_TRUE(owner.release_once());
 
418
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 
419
}
 
420
 
 
421
TEST_F(TestEdgeBarrierController, ProcessNeedsReleaseEventForVerticalSubscriber)
 
422
{
 
423
  int monitor = g_random_int_range(0, monitors::MAX);
 
424
 
 
425
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
426
  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
 
427
 
 
428
  auto event = MakeBarrierEvent(g_random_int(), false);
 
429
 
 
430
  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
 
431
  ProcessBarrierEvent(&owner, event);
 
432
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 
433
}
 
434
 
 
435
TEST_F(TestEdgeBarrierController, ProcessNeedsReleaseEventForHorizontalSubscriber)
 
436
{
 
437
  int monitor = g_random_int_range(0, monitors::MAX);
 
438
 
 
439
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
440
  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
 
441
 
 
442
  auto event = MakeBarrierEvent(g_random_int(), false);
 
443
 
 
444
  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
 
445
  ProcessBarrierEvent(&owner, event);
 
446
  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
 
447
}
 
448
 
 
449
TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForVerticalSubscriber)
 
450
{
 
451
  int monitor = g_random_int_range(0, monitors::MAX);
 
452
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
453
 
 
454
  EXPECT_CALL(owner, ReleaseBarrier(1));
 
455
  ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
 
456
  ASSERT_TRUE(owner.released());
 
457
 
 
458
  Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
 
459
  EXPECT_FALSE(owner.released());
 
460
}
 
461
 
 
462
TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHoriziontalSubscriber)
 
463
{
 
464
  int monitor = g_random_int_range(0, monitors::MAX);
 
465
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
466
 
 
467
  EXPECT_CALL(owner, ReleaseBarrier(1));
 
468
  ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
 
469
  ASSERT_TRUE(owner.released());
 
470
 
 
471
  Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
 
472
  EXPECT_FALSE(owner.released());
 
473
}
 
474
 
 
475
TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEventsForVerticalSubscriber)
 
476
{
 
477
  int monitor = 0;
 
478
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
479
  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
480
 
 
481
  EXPECT_CALL(owner, ReleaseBarrier(5));
 
482
  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
 
483
  ASSERT_TRUE(owner.released());
 
484
 
 
485
  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
486
  EXPECT_CALL(owner, ReleaseBarrier(6));
 
487
  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
 
488
}
 
489
 
 
490
TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEventsForHorizontalSubscriber)
 
491
{
 
492
  int monitor = 0;
 
493
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
494
  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
495
 
 
496
  EXPECT_CALL(owner, ReleaseBarrier(5));
 
497
  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
 
498
  ASSERT_TRUE(owner.released());
 
499
 
 
500
  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
501
  EXPECT_CALL(owner, ReleaseBarrier(6));
 
502
  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
 
503
}
 
504
 
 
505
TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEventsForVerticalSubscriber)
 
506
{
 
507
  int monitor = 0;
 
508
  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
 
509
  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
510
 
 
511
  EXPECT_CALL(owner, ReleaseBarrier(5));
 
512
  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
 
513
  ASSERT_TRUE(owner.released());
 
514
 
 
515
  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
 
516
  EXPECT_CALL(owner, ReleaseBarrier(6)).Times(1);
 
517
  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
 
518
}
 
519
 
 
520
TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEventsForHoriziontalSubscriber)
 
521
{
 
522
  int monitor = 0;
 
523
  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
 
524
  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
 
525
 
 
526
  EXPECT_CALL(owner, ReleaseBarrier(5));
 
527
  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
 
528
  ASSERT_TRUE(owner.released());
 
529
 
 
530
  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
320
531
  EXPECT_CALL(owner, ReleaseBarrier(6)).Times(1);
321
532
  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
322
533
}
338
549
 
339
550
TEST_F(TestEdgeBarrierController, TestTheDirectionIsAlawysSetToBothSides)
340
551
{
341
 
  for (auto barrier : GetPrivateImpl()->barriers_)
 
552
  for (auto barrier : GetPrivateImpl()->vertical_barriers_)
342
553
    ASSERT_EQ(barrier->direction, BarrierDirection::BOTH);
343
554
}
344
555
 
345
 
TEST_F(TestEdgeBarrierController, BarrierDoesNotBreakIfYEventToFarApart)
346
 
{
347
 
  MockPointerBarrier owner;
 
556
TEST_F(TestEdgeBarrierController, TestTheDirectionIsAlawysSetToUp)
 
557
{
 
558
  for (auto barrier : GetPrivateImpl()->horizontal_barriers_)
 
559
    ASSERT_EQ(barrier->direction, BarrierDirection::UP);
 
560
}
 
561
 
 
562
TEST_F(TestEdgeBarrierController, VerticalBarrierDoesNotBreakIfYEventToFarApart)
 
563
{
 
564
  MockPointerBarrierWrapper owner(0, false, VERTICAL);
348
565
 
349
566
  int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
350
567
  auto firstEvent = std::make_shared<BarrierEvent>(0, 50, velocity, 10);
355
572
  ProcessBarrierEvent(&owner, secondEvent);
356
573
}
357
574
 
358
 
TEST_F(TestEdgeBarrierController, BarrierBreaksInYBreakZone)
359
 
{
360
 
  MockPointerBarrier owner;
 
575
TEST_F(TestEdgeBarrierController, HorizontalBarrierDoesNotBreakIfXEventToFarApart)
 
576
{
 
577
  MockPointerBarrierWrapper owner(0, false, HORIZONTAL);
 
578
 
 
579
  int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
 
580
  auto firstEvent = std::make_shared<BarrierEvent>(50, 0, velocity, 10);
 
581
  auto secondEvent = std::make_shared<BarrierEvent>(150, 0, velocity, 11);
 
582
 
 
583
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
 
584
  ProcessBarrierEvent(&owner, firstEvent);
 
585
  ProcessBarrierEvent(&owner, secondEvent);
 
586
}
 
587
 
 
588
TEST_F(TestEdgeBarrierController, VerticalBarrierBreaksInYBreakZone)
 
589
{
 
590
  MockPointerBarrierWrapper owner(0, false, VERTICAL);
361
591
 
362
592
  int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
363
593
  auto firstEvent = std::make_shared<BarrierEvent>(0, 50, velocity, 10);
367
597
  ProcessBarrierEvent(&owner, firstEvent);
368
598
}
369
599
 
370
 
TEST_F(TestEdgeBarrierController, BarrierReleaseIfNoSubscriberForMonitor)
371
 
{
372
 
  MockPointerBarrier owner(monitors::MAX);
 
600
TEST_F(TestEdgeBarrierController, HorizontalBarrierBreaksInXBreakZone)
 
601
{
 
602
  MockPointerBarrierWrapper owner(0, false, HORIZONTAL);
 
603
 
 
604
  int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
 
605
  auto firstEvent = std::make_shared<BarrierEvent>(50, 0, velocity, 10);
 
606
 
 
607
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
 
608
  ProcessBarrierEvent(&owner, firstEvent);
 
609
  ProcessBarrierEvent(&owner, firstEvent);
 
610
}
 
611
 
 
612
TEST_F(TestEdgeBarrierController, VerticalBarrierReleaseIfNoSubscriberForMonitor)
 
613
{
 
614
  MockPointerBarrierWrapper owner(monitors::MAX, false, VERTICAL);
373
615
  auto firstEvent = std::make_shared<BarrierEvent>(0, 50, 1, 10);
374
616
 
375
617
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
376
618
  ProcessBarrierEvent(&owner, firstEvent);
377
619
}
378
620
 
 
621
TEST_F(TestEdgeBarrierController, HorizontalBarrierReleaseIfNoSubscriberForMonitor)
 
622
{
 
623
  MockPointerBarrierWrapper owner(monitors::MAX, false, HORIZONTAL);
 
624
  auto firstEvent = std::make_shared<BarrierEvent>(50, 0, 1, 10);
 
625
 
 
626
  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
 
627
  ProcessBarrierEvent(&owner, firstEvent);
 
628
}
 
629
 
379
630
}