ui/events/gesture_detection/velocity_tracker_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 "base/basictypes.h"
   6 #include "base/logging.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/time/time.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "ui/events/gesture_detection/velocity_tracker_state.h"
  11 #include "ui/events/test/mock_motion_event.h"
  12 #include "ui/gfx/geometry/point_f.h"
  13 #include "ui/gfx/geometry/vector2d_f.h"
  14
  15 using base::TimeDelta;
  16 using base::TimeTicks;
  17 using ui::test::MockMotionEvent;
  18
  19 namespace ui {
  20 namespace {
  21
  22 const TimeDelta kTenMillis = TimeDelta::FromMilliseconds(10);
  23 const TimeDelta kOneSecond = TimeDelta::FromSeconds(1);
  24 const float kEpsilson = .01f;
  25
  26 const char* GetStrategyName(VelocityTracker::Strategy strategy) {
  27   switch (strategy) {
  28     case VelocityTracker::LSQ1: return "LSQ1";
  29     case VelocityTracker::LSQ2: return "LSQ2";
  30     case VelocityTracker::LSQ3: return "LSQ3";
  31     case VelocityTracker::WLSQ2_DELTA: return "WLSQ2_DELTA";
  32     case VelocityTracker::WLSQ2_CENTRAL: return "WLSQ2_CENTRAL";
  33     case VelocityTracker::WLSQ2_RECENT: return "WLSQ2_RECENT";
  34     case VelocityTracker::INT1: return "INT1";
  35     case VelocityTracker::INT2: return "INT2";
  36   };
  37   NOTREACHED() << "Invalid strategy";
  38   return "";
  39 }
  40
  41 }  // namespace
  42
  43 class VelocityTrackerTest : public testing::Test {
  44  public:
  45   VelocityTrackerTest() {}
  46   virtual ~VelocityTrackerTest() {}
  47
  48  protected:
  49   static MockMotionEvent Sample(MotionEvent::Action action,
  50                                 gfx::PointF p0,
  51                                 TimeTicks t0,
  52                                 gfx::Vector2dF v,
  53                                 TimeDelta dt) {
  54     const gfx::PointF p = p0 + ScaleVector2d(v, dt.InSecondsF());
  55     return MockMotionEvent(action, t0 + dt, p.x(), p.y());
  56   }
  57
  58   static void ApplyMovementSequence(VelocityTrackerState* state,
  59                                     gfx::PointF p0,
  60                                     gfx::Vector2dF v,
  61                                     TimeTicks t0,
  62                                     TimeDelta t,
  63                                     size_t samples) {
  64     EXPECT_TRUE(!!samples);
  65     if (!samples)
  66       return;
  67     const base::TimeDelta dt = t / samples;
  68     state->AddMovement(Sample(MotionEvent::ACTION_DOWN, p0, t0, v, dt * 0));
  69     ApplyMovement(state, p0, v, t0, t, samples);
  70     state->AddMovement(Sample(MotionEvent::ACTION_UP, p0, t0, v, t));
  71   }
  72
  73   static void ApplyMovement(VelocityTrackerState* state,
  74                             gfx::PointF p0,
  75                             gfx::Vector2dF v,
  76                             TimeTicks t0,
  77                             TimeDelta t,
  78                             size_t samples) {
  79     EXPECT_TRUE(!!samples);
  80     if (!samples)
  81       return;
  82     const base::TimeDelta dt = t / samples;
  83     for (size_t i = 0; i < samples; ++i)
  84       state->AddMovement(Sample(MotionEvent::ACTION_MOVE, p0, t0, v, dt * i));
  85   }
  86 };
  87
  88 TEST_F(VelocityTrackerTest, Basic) {
  89   const gfx::PointF p0(0, 0);
  90   const gfx::Vector2dF v(0, 500);
  91   const size_t samples = 60;
  92
  93   for (int i = 0; i <= VelocityTracker::STRATEGY_MAX; ++i) {
  94     VelocityTracker::Strategy strategy =
  95         static_cast<VelocityTracker::Strategy>(i);
  96
  97     SCOPED_TRACE(GetStrategyName(strategy));
  98     VelocityTrackerState state(strategy);
  99
 100     // Default state should report zero velocity.
 101     EXPECT_EQ(0, state.GetXVelocity(0));
 102     EXPECT_EQ(0, state.GetYVelocity(0));
 103
 104     // Sample a constant velocity sequence.
 105     ApplyMovementSequence(&state, p0, v, TimeTicks::Now(), kOneSecond, samples);
 106
 107     // The computed velocity should match that of the input.
 108     state.ComputeCurrentVelocity(1000, 20000);
 109     EXPECT_NEAR(v.x(), state.GetXVelocity(0), kEpsilson * v.x());
 110     EXPECT_NEAR(v.y(), state.GetYVelocity(0), kEpsilson * v.y());
 111
 112     // A pointer ID of -1 should report the velocity of the active pointer.
 113     EXPECT_NEAR(v.x(), state.GetXVelocity(-1), kEpsilson * v.x());
 114     EXPECT_NEAR(v.y(), state.GetYVelocity(-1), kEpsilson * v.y());
 115
 116     // Invalid pointer ID's should report zero velocity.
 117     EXPECT_EQ(0, state.GetXVelocity(1));
 118     EXPECT_EQ(0, state.GetYVelocity(1));
 119     EXPECT_EQ(0, state.GetXVelocity(7));
 120     EXPECT_EQ(0, state.GetYVelocity(7));
 121   }
 122 }
 123
 124 TEST_F(VelocityTrackerTest, MaxVelocity) {
 125   const gfx::PointF p0(0, 0);
 126   const gfx::Vector2dF v(-50000, 50000);
 127   const size_t samples = 3;
 128   const base::TimeDelta dt = kTenMillis * 2;
 129
 130   VelocityTrackerState state;
 131   ApplyMovementSequence(&state, p0, v, TimeTicks::Now(), dt, samples);
 132
 133   // The computed velocity should be restricted to the provided maximum.
 134   state.ComputeCurrentVelocity(1000, 100);
 135   EXPECT_NEAR(-100, state.GetXVelocity(0), kEpsilson);
 136   EXPECT_NEAR(100, state.GetYVelocity(0), kEpsilson);
 137
 138   state.ComputeCurrentVelocity(1000, 1000);
 139   EXPECT_NEAR(-1000, state.GetXVelocity(0), kEpsilson);
 140   EXPECT_NEAR(1000, state.GetYVelocity(0), kEpsilson);
 141 }
 142
 143 TEST_F(VelocityTrackerTest, VaryingVelocity) {
 144   const gfx::PointF p0(0, 0);
 145   const gfx::Vector2dF vFast(0, 500);
 146   const gfx::Vector2dF vSlow = ScaleVector2d(vFast, 0.5f);
 147   const size_t samples = 12;
 148
 149   for (int i = 0; i <= VelocityTracker::STRATEGY_MAX; ++i) {
 150     VelocityTracker::Strategy strategy =
 151         static_cast<VelocityTracker::Strategy>(i);
 152
 153     SCOPED_TRACE(GetStrategyName(strategy));
 154     VelocityTrackerState state(strategy);
 155
 156     base::TimeTicks t0 = base::TimeTicks::Now();
 157     base::TimeDelta dt = kTenMillis * 10;
 158     state.AddMovement(
 159         Sample(MotionEvent::ACTION_DOWN, p0, t0, vFast, base::TimeDelta()));
 160
 161     // Apply some fast movement and compute the velocity.
 162     gfx::PointF pCurr = p0;
 163     base::TimeTicks tCurr = t0;
 164     ApplyMovement(&state, pCurr, vFast, tCurr, dt, samples);
 165     state.ComputeCurrentVelocity(1000, 20000);
 166     float vOldY = state.GetYVelocity(0);
 167
 168     // Apply some slow movement.
 169     pCurr += ScaleVector2d(vFast, dt.InSecondsF());
 170     tCurr += dt;
 171     ApplyMovement(&state, pCurr, vSlow, tCurr, dt, samples);
 172
 173     // The computed velocity should have decreased.
 174     state.ComputeCurrentVelocity(1000, 20000);
 175     float vCurrentY = state.GetYVelocity(0);
 176     EXPECT_GT(vFast.y(), vCurrentY);
 177     EXPECT_GT(vOldY, vCurrentY);
 178     vOldY = vCurrentY;
 179
 180     // Apply some additional fast movement.
 181     pCurr += ScaleVector2d(vSlow, dt.InSecondsF());
 182     tCurr += dt;
 183     ApplyMovement(&state, pCurr, vFast, tCurr, dt, samples);
 184
 185     // The computed velocity should have increased.
 186     state.ComputeCurrentVelocity(1000, 20000);
 187     vCurrentY = state.GetYVelocity(0);
 188     EXPECT_LT(vSlow.y(), vCurrentY);
 189     EXPECT_LT(vOldY, vCurrentY);
 190   }
 191 }
 192
 193 TEST_F(VelocityTrackerTest, DelayedActionUp) {
 194   const gfx::PointF p0(0, 0);
 195   const gfx::Vector2dF v(-50000, 50000);
 196   const size_t samples = 10;
 197   const base::TimeTicks t0 = base::TimeTicks::Now();
 198   const base::TimeDelta dt = kTenMillis * 2;
 199
 200   VelocityTrackerState state;
 201   state.AddMovement(
 202       Sample(MotionEvent::ACTION_DOWN, p0, t0, v, base::TimeDelta()));
 203
 204   // Apply the movement and verify a (non-zero) velocity.
 205   ApplyMovement(&state, p0, v, t0, dt, samples);
 206   state.ComputeCurrentVelocity(1000, 1000);
 207   EXPECT_NEAR(-1000, state.GetXVelocity(0), kEpsilson);
 208   EXPECT_NEAR(1000, state.GetYVelocity(0), kEpsilson);
 209
 210   // Apply the delayed ACTION_UP.
 211   const gfx::PointF p1 = p0 + ScaleVector2d(v, dt.InSecondsF());
 212   const base::TimeTicks t1 = t0 + dt + kTenMillis * 10;
 213   state.AddMovement(Sample(
 214       MotionEvent::ACTION_UP, p1, t1, v, base::TimeDelta()));
 215
 216   // The tracked velocity should have been reset.
 217   state.ComputeCurrentVelocity(1000, 1000);
 218   EXPECT_EQ(0.f, state.GetXVelocity(0));
 219   EXPECT_EQ(0.f, state.GetYVelocity(0));
 220 }
 221
 222 }  // namespace ui