← Back to branch summary

~tatokis/unity/gcc-72-errors

« back to all changes in this revision

Viewing changes to tests/test_overlay_scrollbar.cpp

  • Committer: handsome_feng
  • Date: 2016-01-15 01:41:04 UTC
  • mfrom: (4067 unity)
  • mto: This revision was merged to the branch mainline in revision 4073.
  • Revision ID: 445865575@qq.com-20160115014104-i62hh5373ut0knfu
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_overlay_scrollbar.cpp
1
 
/*
2
 
 * Copyright 2012 Canonical Ltd.
3
 
 *
4
 
 * This program is free software: you can redistribute it and/or modify it
5
 
 * under the terms of the GNU Lesser General Public License version 3, as
6
 
 * published by the  Free Software Foundation.
7
 
 *
8
 
 * This program is distributed in the hope that it will be useful, but
9
 
 * WITHOUT ANY WARRANTY; without even the implied warranties of
10
 
 * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
11
 
 * PURPOSE.  See the applicable version of the GNU Lesser General Public
12
 
 * License for more details.
13
 
 *
14
 
 * You should have received a copy of both the GNU Lesser General Public
15
 
 * License version 3 along with this program.  If not, see
16
 
 * <http://www.gnu.org/licenses/>
17
 
 *
18
 
 * Authored by: Brandon Schaefer <brandon.schaefer@canonical.com>
19
 
 *
20
 
 */
21
 
 
22
 
#include <gtest/gtest.h>
23
 
 
24
 
#include <Nux/Nux.h>
25
 
#include <Nux/NuxTimerTickSource.h>
26
 
#include <Nux/VLayout.h>
27
 
#include <NuxCore/ObjectPtr.h>
28
 
#include <NuxCore/AnimationController.h>
29
 
 
30
 
 
31
 
#include "unity-shared/VScrollBarOverlayWindow.h"
32
 
#include "unity-shared/PlacesOverlayVScrollBar.h"
33
 
#include "unity-shared/UScreen.h"
34
 
 
35
 
using namespace unity::dash;
36
 
using namespace testing;
37
 
 
38
 
namespace unity
39
 
{
40
 
 
41
 
namespace
42
 
{
43
 
  const unsigned SCROLL_TICK = 1000 * 401;
44
 
  const unsigned SHOW_TICK = 1000 * 91;
45
 
}
46
 
 
47
 
class TestOverlayWindow : public Test
48
 
{
49
 
public:
50
 
  TestOverlayWindow()
51
 
    : show_tick_(0)
52
 
    , animation_controller_(tick_source_)
53
 
    , overlay_window_(new VScrollBarOverlayWindow(nux::Geometry(0,0,100,100)))
54
 
  {}
55
 
 
56
 
  int GetProxListSize() const
57
 
  {
58
 
    return nux::GetWindowThread()->GetWindowCompositor().GetProximityListSize();
59
 
  }
60
 
 
61
 
  void ShowAnimation()
62
 
  {
63
 
    // (tick_source_);
64
 
    show_tick_ += SHOW_TICK;
65
 
    tick_source_.tick(show_tick_);
66
 
  }
67
 
 
68
 
  unsigned show_tick_;
69
 
  nux::NuxTimerTickSource tick_source_;
70
 
  nux::animation::AnimationController animation_controller_;
71
 
  nux::ObjectPtr<VScrollBarOverlayWindow> overlay_window_;
72
 
};
73
 
 
74
 
namespace dash
75
 
{
76
 
 
77
 
class MockScrollBar : public unity::dash::PlacesOverlayVScrollBar
78
 
{
79
 
  public:
80
 
    MockScrollBar(NUX_FILE_LINE_DECL)
81
 
    : PlacesOverlayVScrollBar(NUX_FILE_LINE_PARAM)
82
 
    , animation_controller(tick_source_)
83
 
    , scroll_tick_(0)
84
 
    , scroll_dy_(0)
85
 
    , thumbs_height_(overlay_window_->GetThumbGeometry().height)
86
 
    , scroll_up_signal_(false)
87
 
    , scroll_down_signal_(false)
88
 
    {
89
 
      OnScrollUp.connect([&] (float step, int dy) {
90
 
        scroll_dy_ = dy;
91
 
        scroll_up_signal_ = true;
92
 
      });
93
 
 
94
 
      OnScrollDown.connect([&] (float step, int dy) {
95
 
        scroll_dy_ = dy;
96
 
        scroll_down_signal_ = true;
97
 
      });
98
 
    }
99
 
 
100
 
    virtual ~MockScrollBar() {}
101
 
 
102
 
    // ScrollDown/Up moves the mouse over the overlay scroll bar, then
103
 
    // moves it down/up by scroll_dy
104
 
    void ScrollDown(int scroll_dy)
105
 
    {
106
 
      UpdateStepY();
107
 
 
108
 
      auto geo = overlay_window_->GetThumbGeometry();
109
 
      int x = geo.x;
110
 
      int y = geo.y;
111
 
 
112
 
      MoveMouse(x, y);
113
 
      MoveDown(x, y);
114
 
 
115
 
      MoveMouse(x, y+scroll_dy);
116
 
      MoveUp(x, y+scroll_dy);
117
 
    }
118
 
 
119
 
    void ScrollUp(int scroll_dy)
120
 
    {
121
 
      UpdateStepY();
122
 
 
123
 
      auto geo = overlay_window_->GetThumbGeometry();
124
 
      int x = geo.x;
125
 
      int y = geo.y;
126
 
 
127
 
      MoveMouse(x, y);
128
 
      MoveDown(x, y);
129
 
 
130
 
      MoveMouse(x, y-scroll_dy);
131
 
      MoveUp(x, y-scroll_dy);
132
 
    }
133
 
 
134
 
    void MoveDown(int x, int y)
135
 
    {
136
 
      nux::Event event;
137
 
      event.type = nux::NUX_MOUSE_PRESSED;
138
 
      event.x = x;
139
 
      event.y = y;
140
 
      nux::GetWindowCompositor().ProcessEvent(event);
141
 
    }
142
 
 
143
 
    void MoveUp(int x, int y)
144
 
    {
145
 
      nux::Event event;
146
 
      event.type = nux::NUX_MOUSE_RELEASED;
147
 
      event.x = x;
148
 
      event.y = y;
149
 
      nux::GetWindowCompositor().ProcessEvent(event);
150
 
    }
151
 
 
152
 
    void MoveMouse(int x, int y)
153
 
    {
154
 
      nux::Event event;
155
 
      event.type = nux::NUX_MOUSE_MOVE;
156
 
      event.x = x;
157
 
      event.y = y;
158
 
      nux::GetWindowCompositor().ProcessEvent(event);
159
 
    }
160
 
 
161
 
    void MoveMouseNear()
162
 
    {
163
 
      auto geo = overlay_window_->GetThumbGeometry();
164
 
      MoveMouse(geo.x, geo.y);
165
 
    }
166
 
 
167
 
    void ScrollUpAnimation(int scroll_dy)
168
 
    {
169
 
      MoveMouseNear();
170
 
      UpdateStepY();
171
 
 
172
 
      StartScrollAnimation(ScrollDir::UP, scroll_dy);
173
 
      scroll_tick_ += SCROLL_TICK;
174
 
      tick_source_.tick(scroll_tick_);
175
 
    }
176
 
 
177
 
    void ScrollDownAnimation(int scroll_dy)
178
 
    {
179
 
      MoveMouseNear();
180
 
      UpdateStepY();
181
 
 
182
 
      StartScrollAnimation(ScrollDir::DOWN, scroll_dy);
183
 
      scroll_tick_ += SCROLL_TICK;
184
 
      tick_source_.tick(scroll_tick_);
185
 
    }
186
 
 
187
 
    void SetThumbOffset(int y)
188
 
    {
189
 
      overlay_window_->SetThumbOffsetY(y);
190
 
      UpdateConnectorPosition();
191
 
    }
192
 
 
193
 
    void StartScrollThenConnectorAnimation()
194
 
    {
195
 
      StartScrollAnimation(ScrollDir::DOWN, 20);
196
 
      MoveMouse(0,0);
197
 
      StartConnectorAnimation();
198
 
 
199
 
      scroll_tick_ += SCROLL_TICK;
200
 
      tick_source_.tick(scroll_tick_);
201
 
    }
202
 
 
203
 
    void FakeDragDown()
204
 
    {
205
 
      OnMouseDrag(0, overlay_window_->GetThumbOffsetY() + 1, 0, 5, 0, 0);
206
 
    }
207
 
 
208
 
    nux::NuxTimerTickSource tick_source_;
209
 
    nux::animation::AnimationController animation_controller;
210
 
 
211
 
    using PlacesOverlayVScrollBar::connector_height_;
212
 
    using VScrollBar::_slider;
213
 
 
214
 
    unsigned scroll_tick_;
215
 
    int scroll_dy_;
216
 
    int thumbs_height_;
217
 
    bool scroll_up_signal_;
218
 
    bool scroll_down_signal_;
219
 
};
220
 
 
221
 
}
222
 
 
223
 
class MockScrollView : public nux::ScrollView
224
 
{
225
 
public:
226
 
  MockScrollView(NUX_FILE_LINE_DECL)
227
 
  : nux::ScrollView(NUX_FILE_LINE_PARAM)
228
 
  {
229
 
    scroll_bar_ = new MockScrollBar(NUX_TRACKER_LOCATION);
230
 
    SetVScrollBar(scroll_bar_.GetPointer());
231
 
  }
232
 
 
233
 
  nux::ObjectPtr<MockScrollBar> scroll_bar_;
234
 
};
235
 
 
236
 
class TestOverlayVScrollBar : public Test
237
 
{
238
 
public:
239
 
  TestOverlayVScrollBar()
240
 
  {
241
 
    nux::VLayout* scroll_layout_ = new nux::VLayout(NUX_TRACKER_LOCATION);
242
 
    scroll_layout_->SetGeometry(0,0,1000,5000);
243
 
    scroll_layout_->SetScaleFactor(0);
244
 
 
245
 
    scroll_view_ = new MockScrollView(NUX_TRACKER_LOCATION);
246
 
    scroll_view_->EnableVerticalScrollBar(true);
247
 
    scroll_view_->EnableHorizontalScrollBar(false);
248
 
    scroll_view_->SetLayout(scroll_layout_);
249
 
 
250
 
    scroll_view_->scroll_bar_->SetContentSize(0, 0, 201, 2000);
251
 
    scroll_view_->scroll_bar_->SetContainerSize(0, 0, 202, 400);
252
 
  }
253
 
 
254
 
  nux::ObjectPtr<MockScrollView> scroll_view_;
255
 
};
256
 
 
257
 
TEST_F(TestOverlayWindow, TestOverlayShows)
258
 
{
259
 
  ASSERT_FALSE(overlay_window_->IsVisible());
260
 
  overlay_window_->MouseNear();
261
 
  EXPECT_TRUE(overlay_window_->IsVisible());
262
 
  EXPECT_DOUBLE_EQ(0.0f, overlay_window_->GetOpacity());
263
 
 
264
 
  ShowAnimation();
265
 
  EXPECT_DOUBLE_EQ(1.0f, overlay_window_->GetOpacity());
266
 
}
267
 
 
268
 
TEST_F(TestOverlayWindow, TestOverlayHides)
269
 
{
270
 
  overlay_window_->MouseNear();
271
 
  ShowAnimation();
272
 
  EXPECT_TRUE(overlay_window_->IsVisible());
273
 
 
274
 
  overlay_window_->MouseBeyond();
275
 
  ShowAnimation();
276
 
 
277
 
  overlay_window_->MouseLeave();
278
 
  ShowAnimation();
279
 
 
280
 
  EXPECT_FALSE(overlay_window_->IsVisible());
281
 
  EXPECT_DOUBLE_EQ(0.0f, overlay_window_->GetOpacity());
282
 
}
283
 
 
284
 
TEST_F(TestOverlayWindow, TestOverlayStaysOpenWhenMouseDown)
285
 
{
286
 
  overlay_window_->MouseNear();
287
 
  ShowAnimation();
288
 
 
289
 
  overlay_window_->MouseDown();
290
 
  ShowAnimation();
291
 
 
292
 
  overlay_window_->MouseBeyond();
293
 
  ShowAnimation();
294
 
 
295
 
  overlay_window_->MouseLeave();
296
 
  ShowAnimation();
297
 
 
298
 
  EXPECT_TRUE(overlay_window_->IsVisible());
299
 
}
300
 
 
301
 
TEST_F(TestOverlayWindow, TestOverlayMouseDrags)
302
 
{
303
 
  overlay_window_->MouseDown();
304
 
  EXPECT_FALSE(overlay_window_->IsMouseBeingDragged());
305
 
 
306
 
  overlay_window_->SetThumbOffsetY(10);
307
 
  EXPECT_TRUE(overlay_window_->IsMouseBeingDragged());
308
 
}
309
 
 
310
 
TEST_F(TestOverlayWindow, TestOverlayStopDraggingOnMouseUp)
311
 
{
312
 
  overlay_window_->MouseDown();
313
 
  EXPECT_FALSE(overlay_window_->IsMouseBeingDragged());
314
 
 
315
 
  overlay_window_->SetThumbOffsetY(10);
316
 
  EXPECT_TRUE(overlay_window_->IsMouseBeingDragged());
317
 
 
318
 
  overlay_window_->MouseUp();
319
 
  EXPECT_FALSE(overlay_window_->IsMouseBeingDragged());
320
 
}
321
 
 
322
 
TEST_F(TestOverlayWindow, TestOverlaySetsOffsetY)
323
 
{
324
 
  int const offset_y = 30;
325
 
 
326
 
  overlay_window_->SetThumbOffsetY(offset_y);
327
 
  EXPECT_EQ(overlay_window_->GetThumbOffsetY(), offset_y);
328
 
}
329
 
 
330
 
TEST_F(TestOverlayWindow, TestOverlaySetsOffsetYOutOfBoundsLower)
331
 
{
332
 
  int const offset_y = -40;
333
 
 
334
 
  overlay_window_->SetThumbOffsetY(offset_y);
335
 
  EXPECT_EQ(overlay_window_->GetThumbOffsetY(), 0);
336
 
}
337
 
 
338
 
TEST_F(TestOverlayWindow, TestOverlaySetsOffsetYOutOfBoundsUpper)
339
 
{
340
 
  int const offset_y = 1000;
341
 
  int const expected_offset = overlay_window_->GetBaseHeight() - overlay_window_->GetThumbHeight();
342
 
 
343
 
  overlay_window_->SetThumbOffsetY(offset_y);
344
 
  EXPECT_EQ(overlay_window_->GetThumbOffsetY(), expected_offset);
345
 
}
346
 
 
347
 
TEST_F(TestOverlayWindow, TestOverlayMouseIsInsideThumb)
348
 
{
349
 
  nux::Geometry const geo(0, 50, 50, 400);
350
 
 
351
 
  overlay_window_->UpdateGeometry(geo);
352
 
  EXPECT_TRUE(overlay_window_->IsMouseInsideThumb(0));
353
 
}
354
 
 
355
 
TEST_F(TestOverlayWindow, TestOverlayMouseIsInsideOnOffsetChange)
356
 
{
357
 
  nux::Geometry const geo(0, 50, 50, 400);
358
 
  int const offset_y = 50;
359
 
  int const thumb_height = overlay_window_->GetThumbHeight();
360
 
 
361
 
  overlay_window_->UpdateGeometry(geo);
362
 
  overlay_window_->SetThumbOffsetY(offset_y);
363
 
 
364
 
  EXPECT_FALSE(overlay_window_->IsMouseInsideThumb(offset_y - 1));
365
 
  EXPECT_TRUE(overlay_window_->IsMouseInsideThumb(offset_y + thumb_height/2));
366
 
  EXPECT_FALSE(overlay_window_->IsMouseInsideThumb(offset_y + thumb_height + 1));
367
 
}
368
 
 
369
 
 
370
 
TEST_F(TestOverlayVScrollBar, TestScrollDownSignal)
371
 
{
372
 
  scroll_view_->scroll_bar_->ScrollDown(10);
373
 
  EXPECT_TRUE(scroll_view_->scroll_bar_->scroll_down_signal_);
374
 
}
375
 
 
376
 
TEST_F(TestOverlayVScrollBar, TestScrollUpSignal)
377
 
{
378
 
  scroll_view_->scroll_bar_->ScrollDown(10);
379
 
  scroll_view_->scroll_bar_->ScrollUp(10);
380
 
  EXPECT_TRUE(scroll_view_->scroll_bar_->scroll_up_signal_);
381
 
}
382
 
 
383
 
TEST_F(TestOverlayVScrollBar, TestScrollDownDeltaY)
384
 
{
385
 
  int scroll_down = 15;
386
 
  scroll_view_->scroll_bar_->ScrollDown(scroll_down);
387
 
  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_down);
388
 
}
389
 
 
390
 
TEST_F(TestOverlayVScrollBar, TestScrollUpDeltaY)
391
 
{
392
 
  int scroll_up = 7;
393
 
  scroll_view_->scroll_bar_->ScrollDown(scroll_up+1);
394
 
  scroll_view_->scroll_bar_->ScrollUp(scroll_up);
395
 
  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_up);
396
 
}
397
 
 
398
 
TEST_F(TestOverlayVScrollBar, TestScrollDownBaseYMoves)
399
 
{
400
 
  int slider_y = scroll_view_->scroll_bar_->_slider->GetBaseY();
401
 
  int scroll_down = 10;
402
 
  scroll_view_->scroll_bar_->ScrollDown(scroll_down);
403
 
  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_down);
404
 
  EXPECT_GT(scroll_view_->scroll_bar_->_slider->GetBaseY(), slider_y);
405
 
}
406
 
 
407
 
TEST_F(TestOverlayVScrollBar, TestScrollUpBaseYMoves)
408
 
{
409
 
  int scroll_up = 10;
410
 
  scroll_view_->scroll_bar_->ScrollDown(scroll_up+1);
411
 
 
412
 
  int slider_y = scroll_view_->scroll_bar_->_slider->GetBaseY();
413
 
  scroll_view_->scroll_bar_->ScrollUp(scroll_up);
414
 
  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_up);
415
 
  EXPECT_LT(scroll_view_->scroll_bar_->_slider->GetBaseY(), slider_y);
416
 
}
417
 
 
418
 
TEST_F(TestOverlayVScrollBar, TestScrollsSlowlyDeltaY)
419
 
{
420
 
  int scroll_down = 10;
421
 
  for (int i = 0; i < scroll_down; i++)
422
 
  {
423
 
    scroll_view_->scroll_bar_->ScrollDown(1);
424
 
    EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, 1);
425
 
  }
426
 
}
427
 
 
428
 
TEST_F(TestOverlayVScrollBar, TestScrollUpAnimationMovesSlider)
429
 
{
430
 
  int scroll_up = 10;
431
 
  scroll_view_->scroll_bar_->ScrollDown(scroll_up+10);
432
 
 
433
 
  int slider_y = scroll_view_->scroll_bar_->_slider->GetBaseY();
434
 
  scroll_view_->scroll_bar_->ScrollUpAnimation(scroll_up);
435
 
 
436
 
  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_up);
437
 
  EXPECT_LT(scroll_view_->scroll_bar_->_slider->GetBaseY(), slider_y);
438
 
}
439
 
 
440
 
TEST_F(TestOverlayVScrollBar, TestScrollDownAnimationMovesSlider)
441
 
{
442
 
  int scroll_down = 10;
443
 
  int slider_y = scroll_view_->scroll_bar_->_slider->GetBaseY();
444
 
 
445
 
  scroll_view_->scroll_bar_->ScrollDownAnimation(scroll_down);
446
 
 
447
 
  EXPECT_EQ(scroll_view_->scroll_bar_->scroll_dy_, scroll_down);
448
 
  EXPECT_GT(scroll_view_->scroll_bar_->_slider->GetBaseY(), slider_y);
449
 
}
450
 
 
451
 
TEST_F(TestOverlayVScrollBar, TestConnectorResetsDuringScrollAnimation)
452
 
{
453
 
  scroll_view_->scroll_bar_->MoveMouseNear();
454
 
  scroll_view_->scroll_bar_->SetThumbOffset(100);
455
 
 
456
 
  int connector_height = scroll_view_->scroll_bar_->connector_height_;
457
 
  EXPECT_GT(connector_height, 0);
458
 
 
459
 
  scroll_view_->scroll_bar_->StartScrollThenConnectorAnimation();
460
 
 
461
 
  connector_height = scroll_view_->scroll_bar_->connector_height_;
462
 
  EXPECT_EQ(connector_height, 0);
463
 
}
464
 
 
465
 
 
466
 
TEST_F(TestOverlayVScrollBar, TestAllowDragIfOverlayIsAtMaximum)
467
 
{
468
 
  // Offset that sets the thumb at the bottom of the scrollbar
469
 
  int thumb_offset = scroll_view_->scroll_bar_->GetHeight() -
470
 
                     scroll_view_->scroll_bar_->thumbs_height_;
471
 
 
472
 
  scroll_view_->scroll_bar_->SetThumbOffset(thumb_offset);
473
 
  scroll_view_->scroll_bar_->FakeDragDown();
474
 
  EXPECT_TRUE(scroll_view_->scroll_bar_->scroll_down_signal_);
475
 
}
476
 
 
477
 
}
478