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