1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "ui/views/controls/slider.h" 6 7 #include <string> 8 9 #include "base/memory/scoped_ptr.h" 10 #include "base/strings/string_util.h" 11 #include "base/strings/utf_string_conversions.h" 12 #include "base/time/time.h" 13 #include "testing/gtest/include/gtest/gtest.h" 14 #include "ui/aura/test/event_generator.h" 15 #include "ui/aura/window.h" 16 #include "ui/base/l10n/l10n_util.h" 17 #include "ui/events/event.h" 18 #include "ui/events/gesture_event_details.h" 19 #include "ui/views/test/slider_test_api.h" 20 #include "ui/views/test/views_test_base.h" 21 #include "ui/views/view.h" 22 #include "ui/views/widget/widget.h" 23 #include "ui/views/widget/widget_delegate.h" 24 25 namespace { 26 27 // A views::SliderListener that tracks simple event call history. 28 class TestSliderListener : public views::SliderListener { 29 public: 30 TestSliderListener(); 31 virtual ~TestSliderListener(); 32 33 int last_event_epoch() { 34 return last_event_epoch_; 35 } 36 37 int last_drag_started_epoch() { 38 return last_drag_started_epoch_; 39 } 40 41 int last_drag_ended_epoch() { 42 return last_drag_ended_epoch_; 43 } 44 45 views::Slider* last_drag_started_sender() { 46 return last_drag_started_sender_; 47 } 48 49 views::Slider* last_drag_ended_sender() { 50 return last_drag_ended_sender_; 51 } 52 53 // Resets the state of this as if it were newly created. 54 virtual void ResetCallHistory(); 55 56 // views::SliderListener: 57 virtual void SliderValueChanged(views::Slider* sender, 58 float value, 59 float old_value, 60 views::SliderChangeReason reason) OVERRIDE; 61 virtual void SliderDragStarted(views::Slider* sender) OVERRIDE; 62 virtual void SliderDragEnded(views::Slider* sender) OVERRIDE; 63 64 private: 65 // The epoch of the last event. 66 int last_event_epoch_; 67 // The epoch of the last time SliderDragStarted was called. 68 int last_drag_started_epoch_; 69 // The epoch of the last time SliderDragEnded was called. 70 int last_drag_ended_epoch_; 71 // The sender from the last SliderDragStarted call. 72 views::Slider* last_drag_started_sender_; 73 // The sender from the last SliderDragEnded call. 74 views::Slider* last_drag_ended_sender_; 75 76 DISALLOW_COPY_AND_ASSIGN(TestSliderListener); 77 }; 78 79 TestSliderListener::TestSliderListener() 80 : last_event_epoch_(0), 81 last_drag_started_epoch_(-1), 82 last_drag_ended_epoch_(-1), 83 last_drag_started_sender_(NULL), 84 last_drag_ended_sender_(NULL) { 85 } 86 87 TestSliderListener::~TestSliderListener() { 88 last_drag_started_sender_ = NULL; 89 last_drag_ended_sender_ = NULL; 90 } 91 92 void TestSliderListener::ResetCallHistory() { 93 last_event_epoch_ = 0; 94 last_drag_started_epoch_ = -1; 95 last_drag_ended_epoch_ = -1; 96 last_drag_started_sender_ = NULL; 97 last_drag_ended_sender_ = NULL; 98 } 99 100 void TestSliderListener::SliderValueChanged(views::Slider* sender, 101 float value, 102 float old_value, 103 views::SliderChangeReason reason) { 104 ++last_event_epoch_; 105 } 106 107 void TestSliderListener::SliderDragStarted(views::Slider* sender) { 108 last_drag_started_sender_ = sender; 109 last_drag_started_epoch_ = ++last_event_epoch_; 110 } 111 112 void TestSliderListener::SliderDragEnded(views::Slider* sender) { 113 last_drag_ended_sender_ = sender; 114 last_drag_ended_epoch_ = ++last_event_epoch_; 115 } 116 117 } // namespace 118 119 namespace views { 120 121 // Base test fixture for Slider tests. 122 class SliderTest : public views::ViewsTestBase { 123 public: 124 explicit SliderTest(Slider::Orientation orientation); 125 virtual ~SliderTest(); 126 127 protected: 128 Slider* slider() { 129 return slider_; 130 } 131 132 TestSliderListener& slider_listener() { 133 return slider_listener_; 134 } 135 136 int max_x() { 137 return max_x_; 138 } 139 140 int max_y() { 141 return max_y_; 142 } 143 144 virtual void ClickAt(int x, int y); 145 146 // testing::Test: 147 virtual void SetUp() OVERRIDE; 148 virtual void TearDown() OVERRIDE; 149 150 aura::test::EventGenerator* event_generator() { 151 return event_generator_.get(); 152 } 153 154 private: 155 // The Slider's orientation 156 Slider::Orientation orientation_; 157 // The Slider to be tested. 158 Slider* slider_; 159 // A simple SliderListener test double. 160 TestSliderListener slider_listener_; 161 // Stores the default locale at test setup so it can be restored 162 // during test teardown. 163 std::string default_locale_; 164 // The maximum x value within the bounds of the slider. 165 int max_x_; 166 // The maximum y value within the bounds of the slider. 167 int max_y_; 168 // The widget container for the slider being tested. 169 views::Widget* widget_; 170 // An event generator. 171 scoped_ptr<aura::test::EventGenerator> event_generator_; 172 173 DISALLOW_COPY_AND_ASSIGN(SliderTest); 174 }; 175 176 SliderTest::SliderTest(Slider::Orientation orientation) 177 : orientation_(orientation), 178 slider_(NULL), 179 default_locale_(""), 180 max_x_(0), 181 max_y_(0) { 182 } 183 184 SliderTest::~SliderTest() { 185 } 186 187 void SliderTest::SetUp() { 188 views::ViewsTestBase::SetUp(); 189 190 slider_ = new Slider(NULL, orientation_); 191 View* view = slider_; 192 gfx::Size size = view->GetPreferredSize(); 193 view->SetSize(size); 194 max_x_ = size.width() - 1; 195 max_y_ = size.height() - 1; 196 default_locale_ = l10n_util::GetApplicationLocale(""); 197 198 views::Widget::InitParams init_params(CreateParams( 199 views::Widget::InitParams::TYPE_WINDOW_FRAMELESS)); 200 init_params.bounds = gfx::Rect(size); 201 202 widget_ = new views::Widget(); 203 widget_->Init(init_params); 204 widget_->SetContentsView(slider_); 205 widget_->Show(); 206 207 aura::Window* native_window = widget_->GetNativeWindow(); 208 event_generator_.reset(new aura::test::EventGenerator( 209 native_window->GetRootWindow())); 210 } 211 212 void SliderTest::TearDown() { 213 if (widget_ && !widget_->IsClosed()) 214 widget_->Close(); 215 216 base::i18n::SetICUDefaultLocale(default_locale_); 217 218 views::ViewsTestBase::TearDown(); 219 } 220 221 void SliderTest::ClickAt(int x, int y) { 222 gfx::Point point(x, y); 223 event_generator_->MoveMouseTo(point); 224 event_generator_->ClickLeftButton(); 225 } 226 227 // Test fixture for horizontally oriented slider tests. 228 class HorizontalSliderTest : public SliderTest { 229 public: 230 HorizontalSliderTest(); 231 virtual ~HorizontalSliderTest(); 232 233 private: 234 DISALLOW_COPY_AND_ASSIGN(HorizontalSliderTest); 235 }; 236 237 HorizontalSliderTest::HorizontalSliderTest() 238 : SliderTest(Slider::HORIZONTAL) { 239 } 240 241 HorizontalSliderTest::~HorizontalSliderTest() { 242 } 243 244 // Test fixture for vertically oriented slider tests. 245 class VerticalSliderTest : public SliderTest { 246 public: 247 VerticalSliderTest(); 248 virtual ~VerticalSliderTest(); 249 250 private: 251 DISALLOW_COPY_AND_ASSIGN(VerticalSliderTest); 252 }; 253 254 VerticalSliderTest::VerticalSliderTest() 255 : SliderTest(Slider::VERTICAL) { 256 } 257 258 VerticalSliderTest::~VerticalSliderTest() { 259 } 260 261 TEST_F(HorizontalSliderTest, UpdateFromClickHorizontal) { 262 ClickAt(0, 0); 263 EXPECT_EQ(0.0f, slider()->value()); 264 265 ClickAt(max_x(), 0); 266 EXPECT_EQ(1.0f, slider()->value()); 267 } 268 269 TEST_F(VerticalSliderTest, UpdateFromClickVertical) { 270 ClickAt(0, 0); 271 EXPECT_EQ(1.0f, slider()->value()); 272 273 ClickAt(0, max_y()); 274 EXPECT_EQ(0.0f, slider()->value()); 275 } 276 277 TEST_F(HorizontalSliderTest, UpdateFromClickRTLHorizontal) { 278 base::i18n::SetICUDefaultLocale("he"); 279 280 ClickAt(0, 0); 281 EXPECT_EQ(1.0f, slider()->value()); 282 283 ClickAt(max_x(), 0); 284 EXPECT_EQ(0.0f, slider()->value()); 285 } 286 287 // Test the slider location after a tap gesture. 288 TEST_F(HorizontalSliderTest, SliderValueForTapGesture) { 289 // Tap below the minimum. 290 slider()->SetValue(0.5); 291 event_generator()->GestureTapAt(gfx::Point(0, 0)); 292 EXPECT_FLOAT_EQ(0, slider()->value()); 293 294 // Tap above the maximum. 295 slider()->SetValue(0.5); 296 event_generator()->GestureTapAt(gfx::Point(max_x(), max_y())); 297 EXPECT_FLOAT_EQ(1, slider()->value()); 298 299 // Tap somwhere in the middle. 300 slider()->SetValue(0.5); 301 event_generator()->GestureTapAt(gfx::Point(0.75 * max_x(), 0.75 * max_y())); 302 EXPECT_NEAR(0.75, slider()->value(), 0.03); 303 } 304 305 // Test the slider location after a scroll gesture. 306 TEST_F(HorizontalSliderTest, SliderValueForScrollGesture) { 307 // Scroll below the minimum. 308 slider()->SetValue(0.5); 309 event_generator()->GestureScrollSequence( 310 gfx::Point(0.5 * max_x(), 0.5 * max_y()), 311 gfx::Point(0, 0), 312 base::TimeDelta::FromMilliseconds(10), 313 5 /* steps */); 314 EXPECT_EQ(0, slider()->value()); 315 316 // Scroll above the maximum. 317 slider()->SetValue(0.5); 318 event_generator()->GestureScrollSequence( 319 gfx::Point(0.5 * max_x(), 0.5 * max_y()), 320 gfx::Point(max_x(), max_y()), 321 base::TimeDelta::FromMilliseconds(10), 322 5 /* steps */); 323 EXPECT_EQ(1, slider()->value()); 324 325 // Scroll somewhere in the middle. 326 slider()->SetValue(0.25); 327 event_generator()->GestureScrollSequence( 328 gfx::Point(0.25 * max_x(), 0.25 * max_y()), 329 gfx::Point(0.75 * max_x(), 0.75 * max_y()), 330 base::TimeDelta::FromMilliseconds(10), 331 5 /* steps */); 332 EXPECT_NEAR(0.75, slider()->value(), 0.03); 333 } 334 335 // Verifies the correct SliderListener events are raised for a tap gesture. 336 TEST_F(HorizontalSliderTest, SliderListenerEventsForTapGesture) { 337 test::SliderTestApi slider_test_api(slider()); 338 slider_test_api.SetListener(&slider_listener()); 339 340 event_generator()->GestureTapAt(gfx::Point(0, 0)); 341 EXPECT_EQ(1, slider_listener().last_drag_started_epoch()); 342 EXPECT_EQ(2, slider_listener().last_drag_ended_epoch()); 343 EXPECT_EQ(slider(), slider_listener().last_drag_started_sender()); 344 EXPECT_EQ(slider(), slider_listener().last_drag_ended_sender()); 345 } 346 347 // Verifies the correct SliderListener events are raised for a scroll gesture. 348 TEST_F(HorizontalSliderTest, SliderListenerEventsForScrollGesture) { 349 test::SliderTestApi slider_test_api(slider()); 350 slider_test_api.SetListener(&slider_listener()); 351 352 event_generator()->GestureScrollSequence( 353 gfx::Point(0.25 * max_x(), 0.25 * max_y()), 354 gfx::Point(0.75 * max_x(), 0.75 * max_y()), 355 base::TimeDelta::FromMilliseconds(0), 356 5 /* steps */); 357 358 EXPECT_EQ(1, slider_listener().last_drag_started_epoch()); 359 EXPECT_GT(slider_listener().last_drag_ended_epoch(), 360 slider_listener().last_drag_started_epoch()); 361 EXPECT_EQ(slider(), slider_listener().last_drag_started_sender()); 362 EXPECT_EQ(slider(), slider_listener().last_drag_ended_sender()); 363 } 364 365 // Verifies the correct SliderListener events are raised for a multi 366 // finger scroll gesture. 367 TEST_F(HorizontalSliderTest, SliderListenerEventsForMultiFingerScrollGesture) { 368 test::SliderTestApi slider_test_api(slider()); 369 slider_test_api.SetListener(&slider_listener()); 370 371 gfx::Point points[] = {gfx::Point(0, 0.1 * max_y()), 372 gfx::Point(0, 0.2 * max_y())}; 373 event_generator()->GestureMultiFingerScroll(2 /* count */, points, 374 0 /* event_separation_time_ms */, 5 /* steps */, 375 2 /* move_x */, 0 /* move_y */); 376 377 EXPECT_EQ(1, slider_listener().last_drag_started_epoch()); 378 EXPECT_GT(slider_listener().last_drag_ended_epoch(), 379 slider_listener().last_drag_started_epoch()); 380 EXPECT_EQ(slider(), slider_listener().last_drag_started_sender()); 381 EXPECT_EQ(slider(), slider_listener().last_drag_ended_sender()); 382 } 383 384 } // namespace views 385
