ui/events/gesture_detection/velocity_tracker_unittest.cc - codesearch/chromium/src - Git at Google

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <stddef.h>

 #include <memory>

 #include "base/logging.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/gesture_detection/velocity_tracker_state.h"
 #include "ui/events/test/motion_event_test_utils.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/vector2d_f.h"

 using base::TimeDelta;
 using base::TimeTicks;
 using ui::test::MockMotionEvent;

 namespace ui {
 namespace {

 const TimeDelta kTenMillis = TimeDelta::FromMilliseconds(10);
 const TimeDelta kOneSecond = TimeDelta::FromSeconds(1);
 const float kEpsilson = .01f;

 const char* GetStrategyName(VelocityTracker::Strategy strategy) {
   switch (strategy) {
     case VelocityTracker::LSQ1: return "LSQ1";
     case VelocityTracker::LSQ2: return "LSQ2";
     case VelocityTracker::LSQ2_RESTRICTED: return "LSQ2_RESTRICTED";
     case VelocityTracker::LSQ3: return "LSQ3";
     case VelocityTracker::WLSQ2_DELTA: return "WLSQ2_DELTA";
     case VelocityTracker::WLSQ2_CENTRAL: return "WLSQ2_CENTRAL";
     case VelocityTracker::WLSQ2_RECENT: return "WLSQ2_RECENT";
     case VelocityTracker::INT1: return "INT1";
     case VelocityTracker::INT2: return "INT2";
   }
   NOTREACHED() << "Invalid strategy";
   return "";
 }

 }  // namespace

 class VelocityTrackerTest : public testing::Test {
  public:
   VelocityTrackerTest() {}
   ~VelocityTrackerTest() override {}

  protected:
   static MockMotionEvent Sample(MotionEvent::Action action,
                                 const gfx::PointF& p0,
                                 TimeTicks t0,
                                 const gfx::Vector2dF& v,
                                 TimeDelta dt) {
     const gfx::PointF p = p0 + ScaleVector2d(v, dt.InSecondsF());
     return MockMotionEvent(action, t0 + dt, p.x(), p.y());
   }

   static void ApplyMovementSequence(VelocityTrackerState* state,
                                     const gfx::PointF& p0,
                                     const gfx::Vector2dF& v,
                                     TimeTicks t0,
                                     TimeDelta t,
                                     size_t samples) {
     EXPECT_TRUE(samples);
     if (!samples)
       return;
     const base::TimeDelta dt = t / samples;
     state->AddMovement(Sample(MotionEvent::Action::DOWN, p0, t0, v, dt * 0));
     ApplyMovement(state, p0, v, t0, t, samples);
     state->AddMovement(Sample(MotionEvent::Action::UP, p0, t0, v, t));
   }

   static void ApplyMovement(VelocityTrackerState* state,
                             const gfx::PointF& p0,
                             const gfx::Vector2dF& v,
                             TimeTicks t0,
                             TimeDelta t,
                             size_t samples) {
     EXPECT_TRUE(samples);
     if (!samples)
       return;
     const base::TimeDelta dt = t / samples;
     for (size_t i = 0; i < samples; ++i)
       state->AddMovement(Sample(MotionEvent::Action::MOVE, p0, t0, v, dt * i));
   }
 };

 TEST_F(VelocityTrackerTest, Basic) {
   const gfx::PointF p0(0, 0);
   const gfx::Vector2dF v(0, 500);
   const size_t samples = 60;

   for (int i = 0; i <= VelocityTracker::STRATEGY_MAX; ++i) {
     VelocityTracker::Strategy strategy =
         static_cast<VelocityTracker::Strategy>(i);

     SCOPED_TRACE(GetStrategyName(strategy));
     VelocityTrackerState state(strategy);

     // Default state should report zero velocity.
     EXPECT_EQ(0, state.GetXVelocity(0));
     EXPECT_EQ(0, state.GetYVelocity(0));

     // Sample a constant velocity sequence.
     ApplyMovementSequence(&state, p0, v, TimeTicks::Now(), kOneSecond, samples);

     // The computed velocity should match that of the input.
     state.ComputeCurrentVelocity(1000, 20000);
     EXPECT_NEAR(v.x(), state.GetXVelocity(0), kEpsilson * v.x());
     EXPECT_NEAR(v.y(), state.GetYVelocity(0), kEpsilson * v.y());

     // A pointer ID of -1 should report the velocity of the active pointer.
     EXPECT_NEAR(v.x(), state.GetXVelocity(-1), kEpsilson * v.x());
     EXPECT_NEAR(v.y(), state.GetYVelocity(-1), kEpsilson * v.y());

     // Invalid pointer ID's should report zero velocity.
     EXPECT_EQ(0, state.GetXVelocity(1));
     EXPECT_EQ(0, state.GetYVelocity(1));
     EXPECT_EQ(0, state.GetXVelocity(7));
     EXPECT_EQ(0, state.GetYVelocity(7));
   }
 }

 TEST_F(VelocityTrackerTest, MaxVelocity) {
   const gfx::PointF p0(0, 0);
   const gfx::Vector2dF v(-50000, 50000);
   const size_t samples = 3;
   const base::TimeDelta dt = kTenMillis * 2;

   VelocityTrackerState state(VelocityTracker::Strategy::LSQ2);
   ApplyMovementSequence(&state, p0, v, TimeTicks::Now(), dt, samples);

   // The computed velocity should be restricted to the provided maximum.
   state.ComputeCurrentVelocity(1000, 100);
   EXPECT_NEAR(-100, state.GetXVelocity(0), kEpsilson);
   EXPECT_NEAR(100, state.GetYVelocity(0), kEpsilson);

   state.ComputeCurrentVelocity(1000, 1000);
   EXPECT_NEAR(-1000, state.GetXVelocity(0), kEpsilson);
   EXPECT_NEAR(1000, state.GetYVelocity(0), kEpsilson);
 }

 TEST_F(VelocityTrackerTest, VaryingVelocity) {
   const gfx::PointF p0(0, 0);
   const gfx::Vector2dF vFast(0, 500);
   const gfx::Vector2dF vSlow = ScaleVector2d(vFast, 0.5f);
   const size_t samples = 12;

   for (int i = 0; i <= VelocityTracker::STRATEGY_MAX; ++i) {
     VelocityTracker::Strategy strategy =
         static_cast<VelocityTracker::Strategy>(i);

     SCOPED_TRACE(GetStrategyName(strategy));
     VelocityTrackerState state(strategy);

     base::TimeTicks t0 = base::TimeTicks::Now();
     base::TimeDelta dt = kTenMillis * 10;
     state.AddMovement(
         Sample(MotionEvent::Action::DOWN, p0, t0, vFast, base::TimeDelta()));

     // Apply some fast movement and compute the velocity.
     gfx::PointF pCurr = p0;
     base::TimeTicks tCurr = t0;
     ApplyMovement(&state, pCurr, vFast, tCurr, dt, samples);
     state.ComputeCurrentVelocity(1000, 20000);
     float vOldY = state.GetYVelocity(0);

     // Apply some slow movement.
     pCurr += ScaleVector2d(vFast, dt.InSecondsF());
     tCurr += dt;
     ApplyMovement(&state, pCurr, vSlow, tCurr, dt, samples);

     // The computed velocity should have decreased.
     state.ComputeCurrentVelocity(1000, 20000);
     float vCurrentY = state.GetYVelocity(0);
     EXPECT_GT(vFast.y(), vCurrentY);
     EXPECT_GT(vOldY, vCurrentY);
     vOldY = vCurrentY;

     // Apply some additional fast movement.
     pCurr += ScaleVector2d(vSlow, dt.InSecondsF());
     tCurr += dt;
     ApplyMovement(&state, pCurr, vFast, tCurr, dt, samples);

     // The computed velocity should have increased.
     state.ComputeCurrentVelocity(1000, 20000);
     vCurrentY = state.GetYVelocity(0);
     EXPECT_LT(vSlow.y(), vCurrentY);
     EXPECT_LT(vOldY, vCurrentY);
   }
 }

 TEST_F(VelocityTrackerTest, DelayedActionUp) {
   const gfx::PointF p0(0, 0);
   const gfx::Vector2dF v(-50000, 50000);
   const size_t samples = 10;
   const base::TimeTicks t0 = base::TimeTicks::Now();
   const base::TimeDelta dt = kTenMillis * 2;

   VelocityTrackerState state(VelocityTracker::Strategy::LSQ2);
   state.AddMovement(
       Sample(MotionEvent::Action::DOWN, p0, t0, v, base::TimeDelta()));

   // Apply the movement and verify a (non-zero) velocity.
   ApplyMovement(&state, p0, v, t0, dt, samples);
   state.ComputeCurrentVelocity(1000, 1000);
   EXPECT_NEAR(-1000, state.GetXVelocity(0), kEpsilson);
   EXPECT_NEAR(1000, state.GetYVelocity(0), kEpsilson);

   // Apply the delayed Action::UP.
   const gfx::PointF p1 = p0 + ScaleVector2d(v, dt.InSecondsF());
   const base::TimeTicks t1 = t0 + dt + kTenMillis * 10;
   state.AddMovement(
       Sample(MotionEvent::Action::UP, p1, t1, v, base::TimeDelta()));

   // The tracked velocity should have been reset.
   state.ComputeCurrentVelocity(1000, 1000);
   EXPECT_EQ(0.f, state.GetXVelocity(0));
   EXPECT_EQ(0.f, state.GetYVelocity(0));
 }

 // Tests that a rapid deceleration won't result in a velocity going in the
 // opposite direction to the pointers primary movement, with the LSQ_RESTRICTED
 // strategy. See crbug.com/417855.
 TEST_F(VelocityTrackerTest, NoDirectionReversal) {
   VelocityTrackerState state_unrestricted(VelocityTracker::LSQ2);
   VelocityTrackerState state_restricted(VelocityTracker::LSQ2_RESTRICTED);
   const base::TimeTicks t0 = base::TimeTicks::Now();
   const base::TimeDelta dt = base::TimeDelta::FromMilliseconds(1);
   const size_t samples = 60;

   gfx::PointF p(0, 0);

   MockMotionEvent m1(MotionEvent::Action::DOWN, t0, p.x(), p.y());
   state_unrestricted.AddMovement(m1);
   state_restricted.AddMovement(m1);

   for (size_t i = 0; i < samples; ++i) {
     if (i < 50)
       p.set_y(p.y() + 10);
     MockMotionEvent mi(MotionEvent::Action::MOVE, t0 + dt * i, p.x(), p.y());
     state_unrestricted.AddMovement(mi);
     state_restricted.AddMovement(mi);
   }

   // The computed velocity be zero, as we stopped at the end of the gesture. In
   // particular, it should not be negative, as all movement was in the positive
   // direction.
   state_restricted.ComputeCurrentVelocity(1000, 20000);
   EXPECT_EQ(0, state_restricted.GetXVelocity(0));
   EXPECT_EQ(0, state_restricted.GetYVelocity(0));

   // This does not hold for the unrestricted LSQ2 strategy.
   state_unrestricted.ComputeCurrentVelocity(1000, 20000);
   EXPECT_EQ(0, state_unrestricted.GetXVelocity(0));
   // Y velocity is negative, despite the fact that the finger only moved in the
   // positive y direction.
   EXPECT_GT(0, state_unrestricted.GetYVelocity(0));
 }

 }  // namespace ui
	// Copyright 2014 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <stddef.h>

	#include <memory>

	#include "base/logging.h"
	#include "base/time/time.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "ui/events/gesture_detection/velocity_tracker_state.h"
	#include "ui/events/test/motion_event_test_utils.h"
	#include "ui/gfx/geometry/point_f.h"
	#include "ui/gfx/geometry/vector2d_f.h"

	using base::TimeDelta;
	using base::TimeTicks;
	using ui::test::MockMotionEvent;

	namespace ui {
	namespace {

	const TimeDelta kTenMillis = TimeDelta::FromMilliseconds(10);
	const TimeDelta kOneSecond = TimeDelta::FromSeconds(1);
	const float kEpsilson = .01f;

	const char* GetStrategyName(VelocityTracker::Strategy strategy) {
	switch (strategy) {
	case VelocityTracker::LSQ1: return "LSQ1";
	case VelocityTracker::LSQ2: return "LSQ2";
	case VelocityTracker::LSQ2_RESTRICTED: return "LSQ2_RESTRICTED";
	case VelocityTracker::LSQ3: return "LSQ3";
	case VelocityTracker::WLSQ2_DELTA: return "WLSQ2_DELTA";
	case VelocityTracker::WLSQ2_CENTRAL: return "WLSQ2_CENTRAL";
	case VelocityTracker::WLSQ2_RECENT: return "WLSQ2_RECENT";
	case VelocityTracker::INT1: return "INT1";
	case VelocityTracker::INT2: return "INT2";
	}
	NOTREACHED() << "Invalid strategy";
	return "";
	}

	} // namespace

	class VelocityTrackerTest : public testing::Test {
	public:
	VelocityTrackerTest() {}
	~VelocityTrackerTest() override {}

	protected:
	static MockMotionEvent Sample(MotionEvent::Action action,
	const gfx::PointF& p0,
	TimeTicks t0,
	const gfx::Vector2dF& v,
	TimeDelta dt) {
	const gfx::PointF p = p0 + ScaleVector2d(v, dt.InSecondsF());
	return MockMotionEvent(action, t0 + dt, p.x(), p.y());
	}

	static void ApplyMovementSequence(VelocityTrackerState* state,
	const gfx::PointF& p0,
	const gfx::Vector2dF& v,
	TimeTicks t0,
	TimeDelta t,
	size_t samples) {
	EXPECT_TRUE(samples);
	if (!samples)
	return;
	const base::TimeDelta dt = t / samples;
	state->AddMovement(Sample(MotionEvent::Action::DOWN, p0, t0, v, dt * 0));
	ApplyMovement(state, p0, v, t0, t, samples);
	state->AddMovement(Sample(MotionEvent::Action::UP, p0, t0, v, t));
	}

	static void ApplyMovement(VelocityTrackerState* state,
	const gfx::PointF& p0,
	const gfx::Vector2dF& v,
	TimeTicks t0,
	TimeDelta t,
	size_t samples) {
	EXPECT_TRUE(samples);
	if (!samples)
	return;
	const base::TimeDelta dt = t / samples;
	for (size_t i = 0; i < samples; ++i)
	state->AddMovement(Sample(MotionEvent::Action::MOVE, p0, t0, v, dt * i));
	}
	};

	TEST_F(VelocityTrackerTest, Basic) {
	const gfx::PointF p0(0, 0);
	const gfx::Vector2dF v(0, 500);
	const size_t samples = 60;

	for (int i = 0; i <= VelocityTracker::STRATEGY_MAX; ++i) {
	VelocityTracker::Strategy strategy =
	static_cast<VelocityTracker::Strategy>(i);

	SCOPED_TRACE(GetStrategyName(strategy));
	VelocityTrackerState state(strategy);

	// Default state should report zero velocity.
	EXPECT_EQ(0, state.GetXVelocity(0));
	EXPECT_EQ(0, state.GetYVelocity(0));

	// Sample a constant velocity sequence.
	ApplyMovementSequence(&state, p0, v, TimeTicks::Now(), kOneSecond, samples);

	// The computed velocity should match that of the input.
	state.ComputeCurrentVelocity(1000, 20000);
	EXPECT_NEAR(v.x(), state.GetXVelocity(0), kEpsilson * v.x());
	EXPECT_NEAR(v.y(), state.GetYVelocity(0), kEpsilson * v.y());

	// A pointer ID of -1 should report the velocity of the active pointer.
	EXPECT_NEAR(v.x(), state.GetXVelocity(-1), kEpsilson * v.x());
	EXPECT_NEAR(v.y(), state.GetYVelocity(-1), kEpsilson * v.y());

	// Invalid pointer ID's should report zero velocity.
	EXPECT_EQ(0, state.GetXVelocity(1));
	EXPECT_EQ(0, state.GetYVelocity(1));
	EXPECT_EQ(0, state.GetXVelocity(7));
	EXPECT_EQ(0, state.GetYVelocity(7));
	}
	}

	TEST_F(VelocityTrackerTest, MaxVelocity) {
	const gfx::PointF p0(0, 0);
	const gfx::Vector2dF v(-50000, 50000);
	const size_t samples = 3;
	const base::TimeDelta dt = kTenMillis * 2;

	VelocityTrackerState state(VelocityTracker::Strategy::LSQ2);
	ApplyMovementSequence(&state, p0, v, TimeTicks::Now(), dt, samples);

	// The computed velocity should be restricted to the provided maximum.
	state.ComputeCurrentVelocity(1000, 100);
	EXPECT_NEAR(-100, state.GetXVelocity(0), kEpsilson);
	EXPECT_NEAR(100, state.GetYVelocity(0), kEpsilson);

	state.ComputeCurrentVelocity(1000, 1000);
	EXPECT_NEAR(-1000, state.GetXVelocity(0), kEpsilson);
	EXPECT_NEAR(1000, state.GetYVelocity(0), kEpsilson);
	}

	TEST_F(VelocityTrackerTest, VaryingVelocity) {
	const gfx::PointF p0(0, 0);
	const gfx::Vector2dF vFast(0, 500);
	const gfx::Vector2dF vSlow = ScaleVector2d(vFast, 0.5f);
	const size_t samples = 12;

	for (int i = 0; i <= VelocityTracker::STRATEGY_MAX; ++i) {
	VelocityTracker::Strategy strategy =
	static_cast<VelocityTracker::Strategy>(i);

	SCOPED_TRACE(GetStrategyName(strategy));
	VelocityTrackerState state(strategy);

	base::TimeTicks t0 = base::TimeTicks::Now();
	base::TimeDelta dt = kTenMillis * 10;
	state.AddMovement(
	Sample(MotionEvent::Action::DOWN, p0, t0, vFast, base::TimeDelta()));

	// Apply some fast movement and compute the velocity.
	gfx::PointF pCurr = p0;
	base::TimeTicks tCurr = t0;
	ApplyMovement(&state, pCurr, vFast, tCurr, dt, samples);
	state.ComputeCurrentVelocity(1000, 20000);
	float vOldY = state.GetYVelocity(0);

	// Apply some slow movement.
	pCurr += ScaleVector2d(vFast, dt.InSecondsF());
	tCurr += dt;
	ApplyMovement(&state, pCurr, vSlow, tCurr, dt, samples);

	// The computed velocity should have decreased.
	state.ComputeCurrentVelocity(1000, 20000);
	float vCurrentY = state.GetYVelocity(0);
	EXPECT_GT(vFast.y(), vCurrentY);
	EXPECT_GT(vOldY, vCurrentY);
	vOldY = vCurrentY;

	// Apply some additional fast movement.
	pCurr += ScaleVector2d(vSlow, dt.InSecondsF());
	tCurr += dt;
	ApplyMovement(&state, pCurr, vFast, tCurr, dt, samples);

	// The computed velocity should have increased.
	state.ComputeCurrentVelocity(1000, 20000);
	vCurrentY = state.GetYVelocity(0);
	EXPECT_LT(vSlow.y(), vCurrentY);
	EXPECT_LT(vOldY, vCurrentY);
	}
	}

	TEST_F(VelocityTrackerTest, DelayedActionUp) {
	const gfx::PointF p0(0, 0);
	const gfx::Vector2dF v(-50000, 50000);
	const size_t samples = 10;
	const base::TimeTicks t0 = base::TimeTicks::Now();
	const base::TimeDelta dt = kTenMillis * 2;

	VelocityTrackerState state(VelocityTracker::Strategy::LSQ2);
	state.AddMovement(
	Sample(MotionEvent::Action::DOWN, p0, t0, v, base::TimeDelta()));

	// Apply the movement and verify a (non-zero) velocity.
	ApplyMovement(&state, p0, v, t0, dt, samples);
	state.ComputeCurrentVelocity(1000, 1000);
	EXPECT_NEAR(-1000, state.GetXVelocity(0), kEpsilson);
	EXPECT_NEAR(1000, state.GetYVelocity(0), kEpsilson);

	// Apply the delayed Action::UP.
	const gfx::PointF p1 = p0 + ScaleVector2d(v, dt.InSecondsF());
	const base::TimeTicks t1 = t0 + dt + kTenMillis * 10;
	state.AddMovement(
	Sample(MotionEvent::Action::UP, p1, t1, v, base::TimeDelta()));

	// The tracked velocity should have been reset.
	state.ComputeCurrentVelocity(1000, 1000);
	EXPECT_EQ(0.f, state.GetXVelocity(0));
	EXPECT_EQ(0.f, state.GetYVelocity(0));
	}

	// Tests that a rapid deceleration won't result in a velocity going in the
	// opposite direction to the pointers primary movement, with the LSQ_RESTRICTED
	// strategy. See crbug.com/417855.
	TEST_F(VelocityTrackerTest, NoDirectionReversal) {
	VelocityTrackerState state_unrestricted(VelocityTracker::LSQ2);
	VelocityTrackerState state_restricted(VelocityTracker::LSQ2_RESTRICTED);
	const base::TimeTicks t0 = base::TimeTicks::Now();
	const base::TimeDelta dt = base::TimeDelta::FromMilliseconds(1);
	const size_t samples = 60;

	gfx::PointF p(0, 0);

	MockMotionEvent m1(MotionEvent::Action::DOWN, t0, p.x(), p.y());
	state_unrestricted.AddMovement(m1);
	state_restricted.AddMovement(m1);

	for (size_t i = 0; i < samples; ++i) {
	if (i < 50)
	p.set_y(p.y() + 10);
	MockMotionEvent mi(MotionEvent::Action::MOVE, t0 + dt * i, p.x(), p.y());
	state_unrestricted.AddMovement(mi);
	state_restricted.AddMovement(mi);
	}

	// The computed velocity be zero, as we stopped at the end of the gesture. In
	// particular, it should not be negative, as all movement was in the positive
	// direction.
	state_restricted.ComputeCurrentVelocity(1000, 20000);
	EXPECT_EQ(0, state_restricted.GetXVelocity(0));
	EXPECT_EQ(0, state_restricted.GetYVelocity(0));

	// This does not hold for the unrestricted LSQ2 strategy.
	state_unrestricted.ComputeCurrentVelocity(1000, 20000);
	EXPECT_EQ(0, state_unrestricted.GetXVelocity(0));
	// Y velocity is negative, despite the fact that the finger only moved in the
	// positive y direction.
	EXPECT_GT(0, state_unrestricted.GetYVelocity(0));
	}

	} // namespace ui