ui/events/gestures/motion_event_aura_unittest.cc

   1 // Copyright 2014 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 "testing/gtest/include/gtest/gtest.h"
   6 #include "ui/events/event.h"
   7 #include "ui/events/gestures/motion_event_aura.h"
   8
   9 namespace {
  10
  11 ui::TouchEvent TouchWithType(ui::EventType type, int id) {
  12   return ui::TouchEvent(
  13       type, gfx::PointF(0, 0), id, base::TimeDelta::FromMilliseconds(0));
  14 }
  15
  16 ui::TouchEvent TouchWithPosition(ui::EventType type,
  17                                  int id,
  18                                  float x,
  19                                  float y,
  20                                  float raw_x,
  21                                  float raw_y,
  22                                  float radius,
  23                                  float pressure) {
  24   ui::TouchEvent event(type,
  25                        gfx::PointF(x, y),
  26                        0,
  27                        id,
  28                        base::TimeDelta::FromMilliseconds(0),
  29                        radius,
  30                        radius,
  31                        0,
  32                        pressure);
  33   event.set_root_location(gfx::PointF(raw_x, raw_y));
  34   return event;
  35 }
  36
  37 ui::TouchEvent TouchWithTime(ui::EventType type, int id, int ms) {
  38   return ui::TouchEvent(
  39       type, gfx::PointF(0, 0), id, base::TimeDelta::FromMilliseconds(ms));
  40 }
  41
  42 base::TimeTicks MsToTicks(int ms) {
  43   return base::TimeTicks() + base::TimeDelta::FromMilliseconds(ms);
  44 }
  45
  46 }  // namespace
  47
  48 namespace ui {
  49
  50 TEST(MotionEventAuraTest, PointerCountAndIds) {
  51   // Test that |PointerCount()| returns the correct number of pointers, and ids
  52   // are assigned correctly.
  53   int ids[] = {4, 6, 1};
  54
  55   MotionEventAura event;
  56   EXPECT_EQ(0U, event.GetPointerCount());
  57
  58   TouchEvent press0 = TouchWithType(ET_TOUCH_PRESSED, ids[0]);
  59   event.OnTouch(press0);
  60   EXPECT_EQ(1U, event.GetPointerCount());
  61
  62   EXPECT_EQ(ids[0], event.GetPointerId(0));
  63
  64   TouchEvent press1 = TouchWithType(ET_TOUCH_PRESSED, ids[1]);
  65   event.OnTouch(press1);
  66   EXPECT_EQ(2U, event.GetPointerCount());
  67
  68   EXPECT_EQ(ids[0], event.GetPointerId(0));
  69   EXPECT_EQ(ids[1], event.GetPointerId(1));
  70
  71   TouchEvent press2 = TouchWithType(ET_TOUCH_PRESSED, ids[2]);
  72   event.OnTouch(press2);
  73   EXPECT_EQ(3U, event.GetPointerCount());
  74
  75   EXPECT_EQ(ids[0], event.GetPointerId(0));
  76   EXPECT_EQ(ids[1], event.GetPointerId(1));
  77   EXPECT_EQ(ids[2], event.GetPointerId(2));
  78
  79   TouchEvent release1 = TouchWithType(ET_TOUCH_RELEASED, ids[1]);
  80   event.OnTouch(release1);
  81   event.CleanupRemovedTouchPoints(release1);
  82   EXPECT_EQ(2U, event.GetPointerCount());
  83
  84   EXPECT_EQ(ids[0], event.GetPointerId(0));
  85   EXPECT_EQ(ids[2], event.GetPointerId(1));
  86
  87   // Test cloning of pointer count and id information.
  88   scoped_ptr<MotionEvent> clone = event.Clone();
  89   EXPECT_EQ(2U, clone->GetPointerCount());
  90   EXPECT_EQ(ids[0], clone->GetPointerId(0));
  91   EXPECT_EQ(ids[2], clone->GetPointerId(1));
  92
  93   TouchEvent release0 = TouchWithType(ET_TOUCH_RELEASED, ids[0]);
  94   event.OnTouch(release0);
  95   event.CleanupRemovedTouchPoints(release0);
  96   EXPECT_EQ(1U, event.GetPointerCount());
  97
  98   EXPECT_EQ(ids[2], event.GetPointerId(0));
  99
 100   TouchEvent release2 = TouchWithType(ET_TOUCH_RELEASED, ids[2]);
 101   event.OnTouch(release2);
 102   event.CleanupRemovedTouchPoints(release2);
 103   EXPECT_EQ(0U, event.GetPointerCount());
 104 }
 105
 106 TEST(MotionEventAuraTest, GetActionIndexAfterRemoval) {
 107   // Test that |GetActionIndex()| returns the correct index when points have
 108   // been removed.
 109   int ids[] = {4, 6, 9};
 110
 111   MotionEventAura event;
 112   EXPECT_EQ(0U, event.GetPointerCount());
 113
 114   TouchEvent press0 = TouchWithType(ET_TOUCH_PRESSED, ids[0]);
 115   event.OnTouch(press0);
 116   TouchEvent press1 = TouchWithType(ET_TOUCH_PRESSED, ids[1]);
 117   event.OnTouch(press1);
 118   TouchEvent press2 = TouchWithType(ET_TOUCH_PRESSED, ids[2]);
 119   event.OnTouch(press2);
 120   EXPECT_EQ(3U, event.GetPointerCount());
 121
 122   TouchEvent release1 = TouchWithType(ET_TOUCH_RELEASED, ids[1]);
 123   event.OnTouch(release1);
 124   event.CleanupRemovedTouchPoints(release1);
 125   EXPECT_EQ(1, event.GetActionIndex());
 126   EXPECT_EQ(2U, event.GetPointerCount());
 127
 128   TouchEvent release2 = TouchWithType(ET_TOUCH_RELEASED, ids[0]);
 129   event.OnTouch(release2);
 130   event.CleanupRemovedTouchPoints(release2);
 131   EXPECT_EQ(0, event.GetActionIndex());
 132   EXPECT_EQ(1U, event.GetPointerCount());
 133
 134   TouchEvent release0 = TouchWithType(ET_TOUCH_RELEASED, ids[2]);
 135   event.OnTouch(release0);
 136   event.CleanupRemovedTouchPoints(release0);
 137   EXPECT_EQ(0U, event.GetPointerCount());
 138 }
 139
 140 TEST(MotionEventAuraTest, PointerLocations) {
 141   // Test that location information is stored correctly.
 142   MotionEventAura event;
 143
 144   const float kRawOffsetX = 11.1f;
 145   const float kRawOffsetY = 13.3f;
 146
 147   int ids[] = {15, 13};
 148   float x;
 149   float y;
 150   float raw_x;
 151   float raw_y;
 152   float r;
 153   float p;
 154
 155   x = 14.4f;
 156   y = 17.3f;
 157   raw_x = x + kRawOffsetX;
 158   raw_y = y + kRawOffsetY;
 159   r = 25.7f;
 160   p = 48.2f;
 161   TouchEvent press0 =
 162       TouchWithPosition(ET_TOUCH_PRESSED, ids[0], x, y, raw_x, raw_y, r, p);
 163   event.OnTouch(press0);
 164
 165   EXPECT_EQ(1U, event.GetPointerCount());
 166   EXPECT_FLOAT_EQ(x, event.GetX(0));
 167   EXPECT_FLOAT_EQ(y, event.GetY(0));
 168   EXPECT_FLOAT_EQ(raw_x, event.GetRawX(0));
 169   EXPECT_FLOAT_EQ(raw_y, event.GetRawY(0));
 170   EXPECT_FLOAT_EQ(r, event.GetTouchMajor(0) / 2);
 171   EXPECT_FLOAT_EQ(p, event.GetPressure(0));
 172
 173   x = 17.8f;
 174   y = 12.1f;
 175   raw_x = x + kRawOffsetX;
 176   raw_y = y + kRawOffsetY;
 177   r = 21.2f;
 178   p = 18.4f;
 179   TouchEvent press1 =
 180       TouchWithPosition(ET_TOUCH_PRESSED, ids[1], x, y, raw_x, raw_y, r, p);
 181   event.OnTouch(press1);
 182
 183   EXPECT_EQ(2U, event.GetPointerCount());
 184   EXPECT_FLOAT_EQ(x, event.GetX(1));
 185   EXPECT_FLOAT_EQ(y, event.GetY(1));
 186   EXPECT_FLOAT_EQ(raw_x, event.GetRawX(1));
 187   EXPECT_FLOAT_EQ(raw_y, event.GetRawY(1));
 188   EXPECT_FLOAT_EQ(r, event.GetTouchMajor(1) / 2);
 189   EXPECT_FLOAT_EQ(p, event.GetPressure(1));
 190
 191   // Test cloning of pointer location information.
 192   scoped_ptr<MotionEvent> clone = event.Clone();
 193   EXPECT_EQ(2U, clone->GetPointerCount());
 194   EXPECT_FLOAT_EQ(x, clone->GetX(1));
 195   EXPECT_FLOAT_EQ(y, clone->GetY(1));
 196   EXPECT_FLOAT_EQ(raw_x, event.GetRawX(1));
 197   EXPECT_FLOAT_EQ(raw_y, event.GetRawY(1));
 198   EXPECT_FLOAT_EQ(r, clone->GetTouchMajor(1) / 2);
 199   EXPECT_FLOAT_EQ(p, clone->GetPressure(1));
 200
 201   x = 27.9f;
 202   y = 22.3f;
 203   raw_x = x + kRawOffsetX;
 204   raw_y = y + kRawOffsetY;
 205   r = 7.6f;
 206   p = 82.1f;
 207   TouchEvent move1 =
 208       TouchWithPosition(ET_TOUCH_MOVED, ids[1], x, y, raw_x, raw_y, r, p);
 209   event.OnTouch(move1);
 210
 211   EXPECT_FLOAT_EQ(x, event.GetX(1));
 212   EXPECT_FLOAT_EQ(y, event.GetY(1));
 213   EXPECT_FLOAT_EQ(raw_x, event.GetRawX(1));
 214   EXPECT_FLOAT_EQ(raw_y, event.GetRawY(1));
 215   EXPECT_FLOAT_EQ(r, event.GetTouchMajor(1) / 2);
 216   EXPECT_FLOAT_EQ(p, event.GetPressure(1));
 217
 218   x = 34.6f;
 219   y = 23.8f;
 220   raw_x = x + kRawOffsetX;
 221   raw_y = y + kRawOffsetY;
 222   r = 12.9f;
 223   p = 14.2f;
 224   TouchEvent move0 =
 225       TouchWithPosition(ET_TOUCH_MOVED, ids[0], x, y, raw_x, raw_y, r, p);
 226   event.OnTouch(move0);
 227
 228   EXPECT_FLOAT_EQ(x, event.GetX(0));
 229   EXPECT_FLOAT_EQ(y, event.GetY(0));
 230   EXPECT_FLOAT_EQ(raw_x, event.GetRawX(0));
 231   EXPECT_FLOAT_EQ(raw_y, event.GetRawY(0));
 232   EXPECT_FLOAT_EQ(r, event.GetTouchMajor(0) / 2);
 233   EXPECT_FLOAT_EQ(p, event.GetPressure(0));
 234 }
 235
 236 TEST(MotionEventAuraTest, Timestamps) {
 237   // Test that timestamp information is stored and converted correctly.
 238   MotionEventAura event;
 239   int ids[] = {7, 13};
 240   int times_in_ms[] = {59436, 60263, 82175};
 241
 242   TouchEvent press0 = TouchWithTime(
 243       ui::ET_TOUCH_PRESSED, ids[0], times_in_ms[0]);
 244   event.OnTouch(press0);
 245   EXPECT_EQ(MsToTicks(times_in_ms[0]), event.GetEventTime());
 246
 247   TouchEvent press1 = TouchWithTime(
 248       ui::ET_TOUCH_PRESSED, ids[1], times_in_ms[1]);
 249   event.OnTouch(press1);
 250   EXPECT_EQ(MsToTicks(times_in_ms[1]), event.GetEventTime());
 251
 252   TouchEvent move0 = TouchWithTime(
 253       ui::ET_TOUCH_MOVED, ids[0], times_in_ms[2]);
 254   event.OnTouch(move0);
 255   EXPECT_EQ(MsToTicks(times_in_ms[2]), event.GetEventTime());
 256
 257   // Test cloning of timestamp information.
 258   scoped_ptr<MotionEvent> clone = event.Clone();
 259   EXPECT_EQ(MsToTicks(times_in_ms[2]), clone->GetEventTime());
 260 }
 261
 262 TEST(MotionEventAuraTest, CachedAction) {
 263   // Test that the cached action and cached action index are correct.
 264   int ids[] = {4, 6};
 265   MotionEventAura event;
 266
 267   TouchEvent press0 = TouchWithType(ET_TOUCH_PRESSED, ids[0]);
 268   event.OnTouch(press0);
 269   EXPECT_EQ(MotionEvent::ACTION_DOWN, event.GetAction());
 270   EXPECT_EQ(1U, event.GetPointerCount());
 271
 272   TouchEvent press1 = TouchWithType(ET_TOUCH_PRESSED, ids[1]);
 273   event.OnTouch(press1);
 274   EXPECT_EQ(MotionEvent::ACTION_POINTER_DOWN, event.GetAction());
 275   EXPECT_EQ(1, event.GetActionIndex());
 276   EXPECT_EQ(2U, event.GetPointerCount());
 277
 278   // Test cloning of CachedAction information.
 279   scoped_ptr<MotionEvent> clone = event.Clone();
 280   EXPECT_EQ(MotionEvent::ACTION_POINTER_DOWN, clone->GetAction());
 281   EXPECT_EQ(1, clone->GetActionIndex());
 282
 283   TouchEvent move0 = TouchWithType(ET_TOUCH_MOVED, ids[0]);
 284   event.OnTouch(move0);
 285   EXPECT_EQ(MotionEvent::ACTION_MOVE, event.GetAction());
 286   EXPECT_EQ(2U, event.GetPointerCount());
 287
 288   TouchEvent release0 = TouchWithType(ET_TOUCH_RELEASED, ids[0]);
 289   event.OnTouch(release0);
 290   EXPECT_EQ(MotionEvent::ACTION_POINTER_UP, event.GetAction());
 291   EXPECT_EQ(2U, event.GetPointerCount());
 292   event.CleanupRemovedTouchPoints(release0);
 293   EXPECT_EQ(1U, event.GetPointerCount());
 294
 295   TouchEvent release1 = TouchWithType(ET_TOUCH_RELEASED, ids[1]);
 296   event.OnTouch(release1);
 297   EXPECT_EQ(MotionEvent::ACTION_UP, event.GetAction());
 298   EXPECT_EQ(1U, event.GetPointerCount());
 299   event.CleanupRemovedTouchPoints(release1);
 300   EXPECT_EQ(0U, event.GetPointerCount());
 301 }
 302
 303 TEST(MotionEventAuraTest, Cancel) {
 304   int ids[] = {4, 6};
 305   MotionEventAura event;
 306
 307   TouchEvent press0 = TouchWithType(ET_TOUCH_PRESSED, ids[0]);
 308   event.OnTouch(press0);
 309   EXPECT_EQ(MotionEvent::ACTION_DOWN, event.GetAction());
 310   EXPECT_EQ(1U, event.GetPointerCount());
 311
 312   TouchEvent press1 = TouchWithType(ET_TOUCH_PRESSED, ids[1]);
 313   event.OnTouch(press1);
 314   EXPECT_EQ(MotionEvent::ACTION_POINTER_DOWN, event.GetAction());
 315   EXPECT_EQ(1, event.GetActionIndex());
 316   EXPECT_EQ(2U, event.GetPointerCount());
 317
 318   scoped_ptr<MotionEvent> cancel = event.Cancel();
 319   EXPECT_EQ(MotionEvent::ACTION_CANCEL, cancel->GetAction());
 320   EXPECT_EQ(2U, static_cast<MotionEventAura*>(cancel.get())->GetPointerCount());
 321 }
 322
 323 TEST(MotionEventAuraTest, ToolType) {
 324   MotionEventAura event;
 325
 326   // For now, all pointers have an unknown tool type.
 327   // TODO(jdduke): Expand this test when ui::TouchEvent identifies the source
 328   // touch type, crbug.com/404128.
 329   event.OnTouch(TouchWithType(ET_TOUCH_PRESSED, 7));
 330   ASSERT_EQ(1U, event.GetPointerCount());
 331   EXPECT_EQ(MotionEvent::TOOL_TYPE_UNKNOWN, event.GetToolType(0));
 332 }
 333
 334 }  // namespace ui