← Back to branch summary

~3v1n0/unity/input-monitor-lockscreen-panel

« back to all changes in this revision

Viewing changes to tests/test_pointer_barrier.cpp

  • Committer: Marco Trevisan (Treviño)
  • Date: 2016-08-17 10:48:32 UTC
  • mfrom: (3788.13.362 unity)
  • Revision ID: mail@3v1n0.net-20160817104832-y30tlo85r713uti3
Merging with trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_pointer_barrier.cpp
79
79
 
80
80
TEST(TestPointerBarrier, HandleHitNotifyEvents)
81
81
{
82
 
  MockPointerBarrier pb;
83
 
  pb.threshold = 1000;
 
82
  auto pb = std::make_shared<MockPointerBarrier>();
 
83
  pb->threshold = 1000;
84
84
  XIBarrierEvent ev = GetGenericEvent(0xdeadbeef);
85
85
 
86
86
  bool got_event = false;
87
87
 
88
 
  pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
 
88
  pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
89
89
    if (!pbw->IsFirstEvent())
90
90
    {
91
91
      got_event = true;
92
92
 
93
 
      EXPECT_EQ(pbw, &pb);
 
93
      EXPECT_EQ(pbw.get(), pb.get());
94
94
      EXPECT_EQ(bev->x, ev.root_x);
95
95
      EXPECT_EQ(bev->y, ev.root_y);
96
 
      EXPECT_EQ(bev->velocity, 600 * pb.max_velocity_multiplier);
 
96
      EXPECT_EQ(bev->velocity, 600 * pb->max_velocity_multiplier);
97
97
      EXPECT_EQ(bev->event_id, ev.eventid);
98
98
     }
99
99
  });
100
100
 
101
 
  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
 
101
  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
102
102
  EXPECT_FALSE(got_event);
103
103
 
104
 
  Utils::WaitForTimeoutMSec(pb.smoothing());
 
104
  Utils::WaitForTimeoutMSec(pb->smoothing());
105
105
 
106
106
  EXPECT_TRUE(got_event);
107
107
}
108
108
 
109
109
TEST(TestPointerBarrier, HandleHitNotifyReleasedEvents)
110
110
{
111
 
  MockPointerBarrier pb;
112
 
  pb.threshold = 1000;
 
111
  auto pb = std::make_shared<MockPointerBarrier>();
 
112
  pb->threshold = 1000;
113
113
  XIBarrierEvent ev = GetGenericEvent(0xabba);
114
114
  bool got_event = false;
115
115
 
116
 
  pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
 
116
  pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
117
117
    got_event = true;
118
118
 
119
 
    EXPECT_EQ(pbw, &pb);
 
119
    EXPECT_EQ(pbw.get(), pb.get());
120
120
    EXPECT_EQ(bev->x, ev.root_x);
121
121
    EXPECT_EQ(bev->y, ev.root_y);
122
122
    EXPECT_GT(bev->velocity, 0);
123
123
    EXPECT_EQ(bev->event_id, ev.eventid);
124
124
  });
125
125
 
126
 
  pb.released = true;
127
 
  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
 
126
  pb->released = true;
 
127
  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
128
128
  EXPECT_TRUE(got_event);
129
129
}
130
130
 
131
131
TEST(TestPointerBarrier, ReciveFirstEvent)
132
132
{
133
 
  MockPointerBarrier pb;
134
 
  pb.threshold = 1000;
 
133
  auto pb = std::make_shared<MockPointerBarrier>();
 
134
  pb->threshold = 1000;
135
135
  XIBarrierEvent ev = GetGenericEvent(0xabba);
136
136
 
137
137
  bool first_is_true = false;
138
138
 
139
 
  pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
 
139
  pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
140
140
    first_is_true = true;
141
141
  });
142
142
 
143
 
  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
 
143
  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
144
144
  EXPECT_TRUE(first_is_true);
145
145
}
146
146
 
147
147
TEST(TestPointerBarrier, ReciveSecondEventFirstFalse)
148
148
{
149
 
  MockPointerBarrier pb;
150
 
  pb.threshold = 1000;
 
149
  auto pb = std::make_shared<MockPointerBarrier>();
 
150
  pb->threshold = 1000;
151
151
  XIBarrierEvent ev = GetGenericEvent(0xabba);
152
152
  int events_recived = 0;
153
153
 
154
 
  pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
 
154
  pb->barrier_event.connect([&] (PointerBarrierWrapper::Ptr const& pbw, BarrierEvent::Ptr bev) {
155
155
      events_recived++;
156
156
 
157
157
      if (events_recived == 1)
160
160
        EXPECT_FALSE(pbw->IsFirstEvent());
161
161
  });
162
162
 
163
 
  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
 
163
  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
164
164
 
165
 
  Utils::WaitForTimeoutMSec(pb.smoothing());
 
165
  Utils::WaitForTimeoutMSec(pb->smoothing());
166
166
 
167
167
  EXPECT_EQ(events_recived, 2);
168
168
}
169
169
 
170
170
TEST(TestPointerBarrier, DontReleaseBarrierOnEmptyDTime)
171
171
{
172
 
  MockPointerBarrier pb;
173
 
  pb.threshold = 1000;
 
172
  auto pb = std::make_shared<MockPointerBarrier>();
 
173
  pb->threshold = 1000;
174
174
  XIBarrierEvent ev = GetGenericEvent(0xabba);
175
175
  ev.dtime = 0;
176
176
 
177
177
  {
178
178
    InSequence sequence;
179
 
    EXPECT_CALL(pb, ReleaseBarrier(0xabba)).Times(0);
 
179
    EXPECT_CALL(*pb, ReleaseBarrier(0xabba)).Times(0);
180
180
  }
181
181
 
182
 
  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
 
182
  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
183
183
 
184
 
  Utils::WaitForTimeoutMSec(pb.smoothing());
 
184
  Utils::WaitForTimeoutMSec(pb->smoothing());
185
185
}
186
186
 
187
187
TEST(TestPointerBarrier, ReleaseBarrierIfOverThreshold)
188
188
{
189
 
  MockPointerBarrier pb;
190
 
  pb.threshold = 500;
 
189
  auto pb = std::make_shared<MockPointerBarrier>();
 
190
  pb->threshold = 500;
191
191
  XIBarrierEvent ev = GetGenericEvent(0xabba);
192
192
 
193
193
  {
194
194
    InSequence sequence;
195
 
    EXPECT_CALL(pb, ReleaseBarrier(0xabba)).Times(1);
 
195
    EXPECT_CALL(*pb, ReleaseBarrier(0xabba)).Times(1);
196
196
  }
197
197
 
198
 
  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
 
198
  EXPECT_TRUE(pb->HandleBarrierEvent(&ev));
199
199
 
200
 
  Utils::WaitForTimeoutMSec(pb.smoothing());
 
200
  Utils::WaitForTimeoutMSec(pb->smoothing());
201
201
}
202
202
 
203
203
}