Quelle TestTouchResampler.cpp Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */

#include <initializer_list>
#include "InputData.h"
#include "Units.h"
#include "gtest/gtest.h"
#include "mozilla/Maybe.h"
#include "mozilla/TimeStamp.h"
#include "TouchResampler.h"

using namespace mozilla;
using widget::TouchResampler;

class TouchResamplerTest : public ::testing::Test {
protected:
  virtual void SetUp() { baseTimeStamp = TimeStamp::Now(); }

  TimeStamp Time(double aMilliseconds) {
    return baseTimeStamp + TimeDuration::FromMilliseconds(aMilliseconds);
  }

  uint64_t ProcessEvent(
      MultiTouchInput::MultiTouchType aType,
      std::initializer_list<std::pair<TimeStamp, ScreenIntPoint>>
          aHistoricalData,
      const TimeStamp& aTimeStamp, const ScreenIntPoint& aPosition) {
    MultiTouchInput input(aType, 0, aTimeStamp, 0);
    input.mTouches.AppendElement(SingleTouchData(1, aPosition, {}, 0.0f, 0.0f));
    for (const auto& histData : aHistoricalData) {
      input.mTouches[0].mHistoricalData.AppendElement(
          SingleTouchData::HistoricalTouchData{
              histData.first, histData.second, {}, {}, 0.0f, 0.0f});
    }
    return resampler.ProcessEvent(std::move(input));
  }

  void CheckTime(const TimeStamp& aTimeStamp,
                 const TimeStamp& aExpectedTimeStamp) {
    EXPECT_EQ((aTimeStamp - baseTimeStamp).ToMilliseconds(),
              (aExpectedTimeStamp - baseTimeStamp).ToMilliseconds());
  }

  void CheckEvent(const MultiTouchInput& aEvent,
                  MultiTouchInput::MultiTouchType aExpectedType,
                  std::initializer_list<std::pair<TimeStamp, ScreenIntPoint>>
                      aExpectedHistoricalData,
                  const TimeStamp& aExpectedTimeStamp,
                  const ScreenIntPoint& aExpectedPosition) {
    EXPECT_EQ(aEvent.mType, aExpectedType);
    EXPECT_EQ(aEvent.mTouches.Length(), size_t(1));
    EXPECT_EQ(aEvent.mTouches[0].mHistoricalData.Length(),
              aExpectedHistoricalData.size());
    for (size_t i = 0; i < aExpectedHistoricalData.size(); i++) {
      CheckTime(aEvent.mTouches[0].mHistoricalData[i].mTimeStamp,
                aExpectedHistoricalData.begin()[i].first);
      EXPECT_EQ(aEvent.mTouches[0].mHistoricalData[i].mScreenPoint,
                aExpectedHistoricalData.begin()[i].second);
    }
    CheckTime(aEvent.mTimeStamp, aExpectedTimeStamp);
    EXPECT_EQ(aEvent.mTouches[0].mScreenPoint, aExpectedPosition);
  }

  struct ExpectedOutgoingEvent {
    Maybe<uint64_t> mEventId;
    MultiTouchInput::MultiTouchType mType = MultiTouchInput::MULTITOUCH_START;
    std::initializer_list<std::pair<TimeStamp, ScreenIntPoint>> mHistoricalData;
    TimeStamp mTimeStamp;
    ScreenIntPoint mPosition;
  };

  void CheckOutgoingEvents(
      std::initializer_list<ExpectedOutgoingEvent> aExpectedEvents) {
    auto outgoing = resampler.ConsumeOutgoingEvents();
    EXPECT_EQ(outgoing.size(), aExpectedEvents.size());
    for (const auto& expectedEvent : aExpectedEvents) {
      auto outgoingEvent = std::move(outgoing.front());
      outgoing.pop();

      EXPECT_EQ(outgoingEvent.mEventId, expectedEvent.mEventId);
      CheckEvent(outgoingEvent.mEvent, expectedEvent.mType,
                 expectedEvent.mHistoricalData, expectedEvent.mTimeStamp,
                 expectedEvent.mPosition);
    }
  }

  TimeStamp baseTimeStamp;
  TouchResampler resampler;
};

TEST_F(TouchResamplerTest, BasicExtrapolation) {
  // Execute the following sequence:
  //
  // 0----------10-------16-----20---------------32------------
  // * touchstart at (10, 10)
  //             * touchmove at (20, 20)
  //                      * frame
  //                             * touchend at (20, 20)
  //                                              * frame
  //
  // And expect the following output:
  //
  // 0----------10-------16-----20---------------32------------
  // * touchstart at (10, 10)
  //                      * touchmove at (26, 26)
  //                      * touchmove at (20, 20)
  //                             * touchend at (20, 20)
  //
  // The first frame should emit an extrapolated touchmove from the position
  // data in the touchstart and touchmove events.
  // The touchend should force a synthesized touchmove that returns back to a
  // non-resampled position.

  EXPECT_FALSE(resampler.InTouchingState());

  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(10, 10));
  EXPECT_TRUE(resampler.InTouchingState());
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE, {}, Time(10.0),
                              ScreenIntPoint(20, 20));

  resampler.NotifyFrame(Time(16.0));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(10, 10)},

      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(10.0), ScreenIntPoint(20, 20)}},
       Time(16.0),
       ScreenIntPoint(26, 26)},
  });

  auto idEnd2 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(20.0),
                             ScreenIntPoint(20, 20));

  EXPECT_FALSE(resampler.InTouchingState());

  CheckOutgoingEvents({
      {Nothing(),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(16.0),
       ScreenIntPoint(20, 20)},

      {Some(idEnd2),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(20.0),
       ScreenIntPoint(20, 20)},
  });

  // No more events should be produced from here on out.
  resampler.NotifyFrame(Time(32.0));
  auto outgoing = resampler.ConsumeOutgoingEvents();
  EXPECT_TRUE(outgoing.empty());
}

TEST_F(TouchResamplerTest, BasicInterpolation) {
  // Same test as BasicExtrapolation, but with a frame time that's 10ms earlier.
  //
  // Execute the following sequence:
  //
  // 0------6---10-----------20--22------------30-------------
  // * touchstart at (10, 10)
  //             * touchmove at (20, 20)
  //        * frame
  //                          * touchend at (20, 20)
  //                              * frame
  //
  // And expect the following output:
  //
  // 0------6---10-----------20--22------------30-------------
  // * touchstart at (10, 10)
  //        * touchmove (16, 16)
  //             * touchmove (20, 20)
  //                          * touchend at (20, 20)
  //
  // The first frame should emit an interpolated touchmove from the position
  // data in the touchstart and touchmove events.
  // The touchend should create a touchmove that returns back to a non-resampled
  // position.

  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(10, 10));
  EXPECT_TRUE(resampler.InTouchingState());
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE, {}, Time(10.0),
                              ScreenIntPoint(20, 20));

  resampler.NotifyFrame(Time(6.0));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(10, 10)},

      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(6.0),
       ScreenIntPoint(16, 16)},
  });

  auto idEnd2 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(20.0),
                             ScreenIntPoint(20, 20));
  EXPECT_FALSE(resampler.InTouchingState());

  CheckOutgoingEvents({
      {Nothing(),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(10.0),
       ScreenIntPoint(20, 20)},

      {Some(idEnd2),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(20.0),
       ScreenIntPoint(20, 20)},
  });

  // No more events should be produced from here on out.
  resampler.NotifyFrame(Time(22.0));
  auto outgoing = resampler.ConsumeOutgoingEvents();
  EXPECT_TRUE(outgoing.empty());
}

TEST_F(TouchResamplerTest, InterpolationFromHistoricalData) {
  // Interpolate from the historical data in a touch move event.
  //
  // Execute the following sequence:
  //
  // 0----------10-------16-----20-----------30--32------------
  // * touchstart at (10, 10)
  //             * [hist] at (20, 25) for
  //             `---------------* touchmove at (30, 30)
  //                      * frame
  //                                          * touchend at (30, 30)
  //                                              * frame
  //
  // And expect the following output:
  //
  // 0----------10-------16-----20-----------30--32------------
  // * touchstart at (10, 10)
  //             * [hist] at (20, 25) for
  //             `--------* touchmove at (26, 28)
  //                             * touchmove at (30, 30)
  //                                          * touchend at (30, 30)
  //
  // The first frame should emit an interpolated touchmove from the position
  // data in the touchmove event, and integrate the historical data point into
  // the resampled event.
  // The touchend should force a synthesized touchmove that returns back to a
  // non-resampled position.

  // This also tests that interpolation works for both x and y, by giving the
  // historical datapoint different values for x and y.
  // (26, 28) is 60% of the way from (20, 25) to (30, 30).

  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(10, 10));
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(10.0), ScreenIntPoint(20, 25)}},
                              Time(20.0), ScreenIntPoint(30, 30));
  resampler.NotifyFrame(Time(16.0));
  auto idEnd2 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(30.0),
                             ScreenIntPoint(30, 30));
  resampler.NotifyFrame(Time(32.0));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(10, 10)},

      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(10.0), ScreenIntPoint(20, 25)}},
       Time(16.0),
       ScreenIntPoint(26, 28)},

      {Nothing(),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(20.0),
       ScreenIntPoint(30, 30)},

      {Some(idEnd2),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(30.0),
       ScreenIntPoint(30, 30)},
  });
}

TEST_F(TouchResamplerTest, MultipleTouches) {
  EXPECT_FALSE(resampler.InTouchingState());

  // Touch start
  MultiTouchInput inputStart0(MultiTouchInput::MULTITOUCH_START, 0, Time(0.0),
                              0);
  inputStart0.mTouches.AppendElement(
      SingleTouchData(1, ScreenIntPoint(10, 10), {}, 0.0f, 0.0f));
  auto idStart0 = resampler.ProcessEvent(std::move(inputStart0));
  EXPECT_TRUE(resampler.InTouchingState());

  // Touch move
  MultiTouchInput inputMove1(MultiTouchInput::MULTITOUCH_MOVE, 0, Time(20.0),
                             0);
  inputMove1.mTouches.AppendElement(
      SingleTouchData(1, ScreenIntPoint(30, 30), {}, 0.0f, 0.0f));
  inputMove1.mTouches[0].mHistoricalData.AppendElement(
      SingleTouchData::HistoricalTouchData{
          Time(10.0), ScreenIntPoint(20, 25), {}, {}, 0.0f, 0.0f});
  auto idMove1 = resampler.ProcessEvent(std::move(inputMove1));
  EXPECT_TRUE(resampler.InTouchingState());

  // Frame
  resampler.NotifyFrame(Time(16.0));

  // Touch move
  MultiTouchInput inputMove2(MultiTouchInput::MULTITOUCH_MOVE, 0, Time(30.0),
                             0);
  inputMove2.mTouches.AppendElement(
      SingleTouchData(1, ScreenIntPoint(30, 40), {}, 0.0f, 0.0f));
  auto idMove2 = resampler.ProcessEvent(std::move(inputMove2));
  EXPECT_TRUE(resampler.InTouchingState());

  // Touch start
  MultiTouchInput inputStart3(MultiTouchInput::MULTITOUCH_START, 0, Time(30.0),
                              0);
  inputStart3.mTouches.AppendElement(
      SingleTouchData(2, ScreenIntPoint(100, 10), {}, 0.0f, 0.0f));
  inputStart3.mTouches.AppendElement(
      SingleTouchData(1, ScreenIntPoint(30, 40), {}, 0.0f, 0.0f));
  auto idStart3 = resampler.ProcessEvent(std::move(inputStart3));
  EXPECT_TRUE(resampler.InTouchingState());

  // Touch move
  MultiTouchInput inputMove4(MultiTouchInput::MULTITOUCH_MOVE, 0, Time(40.0),
                             0);
  inputMove4.mTouches.AppendElement(
      SingleTouchData(1, ScreenIntPoint(30, 50), {}, 0.0f, 0.0f));
  inputMove4.mTouches.AppendElement(
      SingleTouchData(2, ScreenIntPoint(100, 30), {}, 0.0f, 0.0f));
  auto idMove4 = resampler.ProcessEvent(std::move(inputMove4));
  EXPECT_TRUE(resampler.InTouchingState());

  // Frame
  resampler.NotifyFrame(Time(32.0));

  // Touch move
  MultiTouchInput inputMove5(MultiTouchInput::MULTITOUCH_MOVE, 0, Time(50.0),
                             0);
  inputMove5.mTouches.AppendElement(
      SingleTouchData(1, ScreenIntPoint(30, 60), {}, 0.0f, 0.0f));
  inputMove5.mTouches.AppendElement(
      SingleTouchData(2, ScreenIntPoint(100, 40), {}, 0.0f, 0.0f));
  auto idMove5 = resampler.ProcessEvent(std::move(inputMove5));
  EXPECT_TRUE(resampler.InTouchingState());

  // Touch end
  MultiTouchInput inputEnd6(MultiTouchInput::MULTITOUCH_END, 0, Time(50.0), 0);
  // Touch point with identifier 1 is lifted
  inputEnd6.mTouches.AppendElement(
      SingleTouchData(1, ScreenIntPoint(30, 60), {}, 0.0f, 0.0f));
  auto idEnd6 = resampler.ProcessEvent(std::move(inputEnd6));
  EXPECT_TRUE(resampler.InTouchingState());

  // Frame
  resampler.NotifyFrame(Time(48.0));

  // Touch move
  MultiTouchInput inputMove7(MultiTouchInput::MULTITOUCH_MOVE, 0, Time(60.0),
                             0);
  inputMove7.mTouches.AppendElement(
      SingleTouchData(2, ScreenIntPoint(100, 60), {}, 0.0f, 0.0f));
  auto idMove7 = resampler.ProcessEvent(std::move(inputMove7));
  EXPECT_TRUE(resampler.InTouchingState());

  // Frame
  resampler.NotifyFrame(Time(64.0));

  // Touch end
  MultiTouchInput inputEnd8(MultiTouchInput::MULTITOUCH_END, 0, Time(70.0), 0);
  // Touch point with identifier 2 is lifted
  inputEnd8.mTouches.AppendElement(
      SingleTouchData(2, ScreenIntPoint(100, 60), {}, 0.0f, 0.0f));
  auto idEnd8 = resampler.ProcessEvent(std::move(inputEnd8));
  EXPECT_FALSE(resampler.InTouchingState());

  // Check outgoing events
  auto outgoing = resampler.ConsumeOutgoingEvents();
  EXPECT_EQ(outgoing.size(), size_t(9));

  auto outgoingStart0 = std::move(outgoing.front());
  outgoing.pop();
  EXPECT_EQ(outgoingStart0.mEventId, Some(idStart0));
  CheckEvent(outgoingStart0.mEvent, MultiTouchInput::MULTITOUCH_START, {},
             Time(0.0), ScreenIntPoint(10, 10));

  auto outgoingMove1 = std::move(outgoing.front());
  outgoing.pop();
  EXPECT_EQ(outgoingMove1.mEventId, Some(idMove1));
  // (26, 28) is 60% of the way from (20, 25) to (30, 30).
  CheckEvent(outgoingMove1.mEvent, MultiTouchInput::MULTITOUCH_MOVE,
             {{Time(10.0), ScreenIntPoint(20, 25)}}, Time(16.0),
             ScreenIntPoint(26, 28));

  auto outgoingMove2 = std::move(outgoing.front());
  outgoing.pop();
  EXPECT_EQ(outgoingMove2.mEventId, Some(idMove2));
  CheckEvent(outgoingMove2.mEvent, MultiTouchInput::MULTITOUCH_MOVE,
             {{Time(20.0), ScreenIntPoint(30, 30)}}, Time(30.0),
             ScreenIntPoint(30, 40));

  auto outgoingStart3 = std::move(outgoing.front());
  outgoing.pop();
  EXPECT_EQ(outgoingStart3.mEventId, Some(idStart3));
  EXPECT_EQ(outgoingStart3.mEvent.mType, MultiTouchInput::MULTITOUCH_START);
  CheckTime(outgoingStart3.mEvent.mTimeStamp, Time(30.0));
  EXPECT_EQ(outgoingStart3.mEvent.mTouches.Length(), size_t(2));
  // touch order should be taken from the original touch start event
  EXPECT_EQ(outgoingStart3.mEvent.mTouches[0].mIdentifier, 2);
  EXPECT_EQ(outgoingStart3.mEvent.mTouches[0].mScreenPoint,
            ScreenIntPoint(100, 10));
  EXPECT_EQ(outgoingStart3.mEvent.mTouches[1].mIdentifier, 1);
  EXPECT_EQ(outgoingStart3.mEvent.mTouches[1].mScreenPoint,
            ScreenIntPoint(30, 40));

  auto outgoingMove4 = std::move(outgoing.front());
  outgoing.pop();
  EXPECT_EQ(outgoingMove4.mEventId, Some(idMove4));
  EXPECT_EQ(outgoingMove4.mEvent.mType, MultiTouchInput::MULTITOUCH_MOVE);
  CheckTime(outgoingMove4.mEvent.mTimeStamp, Time(32.0));
  EXPECT_EQ(outgoingMove4.mEvent.mTouches.Length(), size_t(2));
  // Touch order should be taken from the original touch move event.
  // Both touches should be resampled.
  EXPECT_EQ(outgoingMove4.mEvent.mTouches[0].mIdentifier, 1);
  EXPECT_EQ(outgoingMove4.mEvent.mTouches[0].mScreenPoint,
            ScreenIntPoint(30, 42));
  EXPECT_EQ(outgoingMove4.mEvent.mTouches[1].mIdentifier, 2);
  EXPECT_EQ(outgoingMove4.mEvent.mTouches[1].mScreenPoint,
            ScreenIntPoint(100, 14));

  auto outgoingMove5 = std::move(outgoing.front());
  outgoing.pop();
  EXPECT_EQ(outgoingMove5.mEventId, Some(idMove5));
  EXPECT_EQ(outgoingMove5.mEvent.mType, MultiTouchInput::MULTITOUCH_MOVE);
  CheckTime(outgoingMove5.mEvent.mTimeStamp, Time(50.0));
  EXPECT_EQ(outgoingMove5.mEvent.mTouches.Length(), size_t(2));
  // touch order should be taken from the original touch move event
  EXPECT_EQ(outgoingMove5.mEvent.mTouches[0].mIdentifier, 1);
  EXPECT_EQ(outgoingMove5.mEvent.mTouches[0].mScreenPoint,
            ScreenIntPoint(30, 60));
  EXPECT_EQ(outgoingMove5.mEvent.mTouches[0].mHistoricalData.Length(),
            size_t(1));
  CheckTime(outgoingMove5.mEvent.mTouches[0].mHistoricalData[0].mTimeStamp,
            Time(40.0));
  EXPECT_EQ(outgoingMove5.mEvent.mTouches[0].mHistoricalData[0].mScreenPoint,
            ScreenIntPoint(30, 50));
  EXPECT_EQ(outgoingMove5.mEvent.mTouches[1].mIdentifier, 2);
  EXPECT_EQ(outgoingMove5.mEvent.mTouches[1].mScreenPoint,
            ScreenIntPoint(100, 40));
  EXPECT_EQ(outgoingMove5.mEvent.mTouches[1].mHistoricalData.Length(),
            size_t(1));
  CheckTime(outgoingMove5.mEvent.mTouches[1].mHistoricalData[0].mTimeStamp,
            Time(40.0));
  EXPECT_EQ(outgoingMove5.mEvent.mTouches[1].mHistoricalData[0].mScreenPoint,
            ScreenIntPoint(100, 30));

  auto outgoingEnd6 = std::move(outgoing.front());
  outgoing.pop();
  EXPECT_EQ(outgoingEnd6.mEventId, Some(idEnd6));
  CheckEvent(outgoingEnd6.mEvent, MultiTouchInput::MULTITOUCH_END, {},
             Time(50.0), ScreenIntPoint(30, 60));

  auto outgoingMove7 = std::move(outgoing.front());
  outgoing.pop();
  EXPECT_EQ(outgoingMove7.mEventId, Some(idMove7));
  // No extrapolation because the frame at 64.0 cleared the data points because
  // there was no pending touch move event at that point
  CheckEvent(outgoingMove7.mEvent, MultiTouchInput::MULTITOUCH_MOVE, {},
             Time(60.0), ScreenIntPoint(100, 60));
  EXPECT_EQ(outgoingMove7.mEvent.mTouches[0].mIdentifier, 2);

  auto outgoingEnd8 = std::move(outgoing.front());
  outgoing.pop();
  EXPECT_EQ(outgoingEnd8.mEventId, Some(idEnd8));
  CheckEvent(outgoingEnd8.mEvent, MultiTouchInput::MULTITOUCH_END, {},
             Time(70.0), ScreenIntPoint(100, 60));
}

TEST_F(TouchResamplerTest, MovingPauses) {
  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(10, 10));
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE, {}, Time(10.0),
                              ScreenIntPoint(20, 20));
  resampler.NotifyFrame(Time(16.0));
  auto idMove2 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE, {}, Time(30.0),
                              ScreenIntPoint(40, 40));
  resampler.NotifyFrame(Time(32.0));
  auto idMove3 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE, {}, Time(40.0),
                              ScreenIntPoint(50, 40));
  resampler.NotifyFrame(Time(48.0));
  resampler.NotifyFrame(Time(64.0));
  auto idEnd4 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(70.0),
                             ScreenIntPoint(50, 40));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(10, 10)},

      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(10.0), ScreenIntPoint(20, 20)}},
       Time(16.0),
       ScreenIntPoint(26, 26)},

      {Some(idMove2),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(30.0), ScreenIntPoint(40, 40)}},
       Time(32.0),
       ScreenIntPoint(42, 42)},

      {Some(idMove3),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(40.0), ScreenIntPoint(50, 40)}},
       Time(48.0),
       ScreenIntPoint(58, 40)},

      // There was no event between two frames here, so we expect a reset event,
      // so that we pause at a non-resampled position.
      {Nothing(),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(48.0),
       ScreenIntPoint(50, 40)},

      {Some(idEnd4),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(70.0),
       ScreenIntPoint(50, 40)},
  });
}

TEST_F(TouchResamplerTest, MixedInterAndExtrapolation) {
  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(0, 0));
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE, {}, Time(10.0),
                              ScreenIntPoint(0, 10));
  resampler.NotifyFrame(Time(11.0));  // 16 - 5
  auto idMove2 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(20.0), ScreenIntPoint(0, 20)}}, Time(30.0),
                              ScreenIntPoint(0, 30));
  resampler.NotifyFrame(Time(27.0));  // 32 - 5
  auto idMove3 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE, {}, Time(40.0),
                              ScreenIntPoint(0, 40));
  resampler.NotifyFrame(Time(43.0));  // 48 - 5
  auto idMove4 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(50.0), ScreenIntPoint(0, 50)}}, Time(60.0),
                              ScreenIntPoint(0, 60));
  resampler.NotifyFrame(Time(59.0));  // 64 - 5
  auto idEnd5 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(70.0),
                             ScreenIntPoint(0, 60));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(0, 0)},

      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(10.0), ScreenIntPoint(0, 10)}},
       Time(11.0),
       ScreenIntPoint(0, 11)},

      {Some(idMove2),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(20.0), ScreenIntPoint(0, 20)}},
       Time(27.0),
       ScreenIntPoint(0, 27)},

      {Some(idMove3),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(30.0), ScreenIntPoint(0, 30)},
        {Time(40.0), ScreenIntPoint(0, 40)}},
       Time(43.0),
       ScreenIntPoint(0, 43)},

      {Some(idMove4),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(50.0), ScreenIntPoint(0, 50)}},
       Time(59.0),
       ScreenIntPoint(0, 59)},

      {Nothing(),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(60.0),
       ScreenIntPoint(0, 60)},

      {Some(idEnd5),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(70.0),
       ScreenIntPoint(0, 60)},
  });
}

TEST_F(TouchResamplerTest, MultipleMoveEvents) {
  // Test what happens if multiple touch move events appear between two frames.
  // This scenario shouldn't occur on Android but we should be able to deal with
  // it anyway. Check that we don't discard any event IDs.
  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(0, 0));
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE, {}, Time(10.0),
                              ScreenIntPoint(0, 10));
  resampler.NotifyFrame(Time(11.0));  // 16 - 5
  auto idMove2 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(20.0), ScreenIntPoint(0, 20)}}, Time(30.0),
                              ScreenIntPoint(0, 30));
  auto idMove3 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE, {}, Time(40.0),
                              ScreenIntPoint(0, 40));
  auto idMove4 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(45.0), ScreenIntPoint(0, 45)}}, Time(50.0),
                              ScreenIntPoint(0, 50));
  auto idMove5 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE, {}, Time(55.0),
                              ScreenIntPoint(0, 55));
  resampler.NotifyFrame(Time(43.0));  // 48 - 5
  resampler.NotifyFrame(Time(59.0));  // 64 - 5
  auto idEnd5 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(70.0),
                             ScreenIntPoint(0, 60));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(0, 0)},

      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(10.0), ScreenIntPoint(0, 10)}},
       Time(11.0),
       ScreenIntPoint(0, 11)},

      {Some(idMove2),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(20.0), ScreenIntPoint(0, 20)}},
       Time(30.0),
       ScreenIntPoint(0, 30)},

      {Some(idMove3),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(40.0),
       ScreenIntPoint(0, 40)},

      {Some(idMove4),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(43.0),
       ScreenIntPoint(0, 43)},

      {Some(idMove5),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(45.0), ScreenIntPoint(0, 45)},
        {Time(50.0), ScreenIntPoint(0, 50)},
        {Time(55.0), ScreenIntPoint(0, 55)}},
       Time(59.0),
       ScreenIntPoint(0, 59)},

      {Nothing(),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(59.0),
       ScreenIntPoint(0, 55)},

      {Some(idEnd5),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(70.0),
       ScreenIntPoint(0, 60)},
  });
}

TEST_F(TouchResamplerTest, LimitFuturePrediction) {
  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(0, 0));
  // Fingers move until time 44, then pause. UI thread is occupied until 64.
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(20.0), ScreenIntPoint(0, 20)},
                               {Time(32.0), ScreenIntPoint(0, 32)}},
                              Time(44.0), ScreenIntPoint(0, 44));
  resampler.NotifyFrame(Time(59.0));  // 64 - 5
  auto idEnd2 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(70.0),
                             ScreenIntPoint(0, 44));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(0, 0)},

      // kTouchResampleMaxPredictMs == 8
      // Refuse to predict more than 8ms into the future, the fingers might have
      // paused. Make an event for time 52 (= 44 + 8) instead of 59.
      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(20.0), ScreenIntPoint(0, 20)},
        {Time(32.0), ScreenIntPoint(0, 32)},
        {Time(44.0), ScreenIntPoint(0, 44)}},
       Time(52.0),
       ScreenIntPoint(0, 52)},

      {Nothing(),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(52.0),
       ScreenIntPoint(0, 44)},

      {Some(idEnd2),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(70.0),
       ScreenIntPoint(0, 44)},
  });
}

TEST_F(TouchResamplerTest, LimitBacksampling) {
  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(0, 0));
  // Fingers move until time 44, then pause. UI thread is occupied until 64.
  // Then we get a frame callback with a very outdated frametime.
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(20.0), ScreenIntPoint(0, 20)},
                               {Time(32.0), ScreenIntPoint(0, 32)}},
                              Time(44.0), ScreenIntPoint(0, 44));
  resampler.NotifyFrame(Time(11.0));  // 16 - 5
  auto idEnd2 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(70.0),
                             ScreenIntPoint(0, 44));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(0, 0)},

      // kTouchResampleMaxBacksampleMs == 20
      // Refuse to sample further back than 20ms before the last data point.
      // Make an event for time 24 (= 44 - 20) instead of time 11.
      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(20.0), ScreenIntPoint(0, 20)}},
       Time(24.0),
       ScreenIntPoint(0, 24)},

      {Nothing(),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(32.0), ScreenIntPoint(0, 32)}},
       Time(44.0),
       ScreenIntPoint(0, 44)},

      {Some(idEnd2),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(70.0),
       ScreenIntPoint(0, 44)},
  });
}

TEST_F(TouchResamplerTest, DontExtrapolateFromOldTouch) {
  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(0, 0));
  // Fingers move until time 40, then pause. UI thread is occupied until 64.
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(20.0), ScreenIntPoint(0, 20)},
                               {Time(30.0), ScreenIntPoint(0, 30)}},
                              Time(40.0), ScreenIntPoint(0, 40));
  resampler.NotifyFrame(Time(59.0));  // 64 - 5
  auto idEnd2 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(70.0),
                             ScreenIntPoint(0, 44));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(0, 0)},

      // kTouchResampleOldTouchThresholdMs == 17
      // Refuse to extrapolate from a data point that's more than 17ms older
      // than the frame time.
      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(20.0), ScreenIntPoint(0, 20)},
        {Time(30.0), ScreenIntPoint(0, 30)}},
       Time(40.0),
       ScreenIntPoint(0, 40)},

      {Some(idEnd2),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(70.0),
       ScreenIntPoint(0, 44)},
  });
}

TEST_F(TouchResamplerTest, DontExtrapolateIfTooOld) {
  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(0, 0));
  // Fingers move until time 10, pause, and move again at 55.
  // UI thread is occupied until 64.
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(10.0), ScreenIntPoint(0, 10)}}, Time(55.0),
                              ScreenIntPoint(0, 55));
  resampler.NotifyFrame(Time(59.0));  // 64 - 5
  auto idEnd2 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(70.0),
                             ScreenIntPoint(0, 60));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(0, 0)},

      // kTouchResampleWindowSize == 40
      // Refuse to resample between two data points that are more than 40ms
      // apart.
      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(10.0), ScreenIntPoint(0, 10)}},
       Time(55.0),
       ScreenIntPoint(0, 55)},

      {Some(idEnd2),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(70.0),
       ScreenIntPoint(0, 60)},
  });
}

TEST_F(TouchResamplerTest, DontInterpolateIfTooOld) {
  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(0, 0));
  // Fingers move until time 10, pause, and move again at 60.
  // UI thread is occupied until 64.
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(10.0), ScreenIntPoint(0, 10)}}, Time(60.0),
                              ScreenIntPoint(0, 60));
  resampler.NotifyFrame(Time(59.0));  // 64 - 5
  auto idEnd2 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(70.0),
                             ScreenIntPoint(0, 60));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(0, 0)},

      // kTouchResampleWindowSize == 40
      // Refuse to resample between two data points that are more than 40ms
      // apart.
      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(10.0), ScreenIntPoint(0, 10)}},
       Time(60.0),
       ScreenIntPoint(0, 60)},

      {Some(idEnd2),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(70.0),
       ScreenIntPoint(0, 60)},
  });
}

TEST_F(TouchResamplerTest, DiscardOutdatedHistoricalData) {
  auto idStart0 = ProcessEvent(MultiTouchInput::MULTITOUCH_START, {}, Time(0.0),
                               ScreenIntPoint(0, 0));
  auto idMove1 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(10.0), ScreenIntPoint(0, 10)}}, Time(16.0),
                              ScreenIntPoint(0, 16));
  resampler.NotifyFrame(Time(20.0));
  auto idMove2 = ProcessEvent(MultiTouchInput::MULTITOUCH_MOVE,
                              {{Time(18.0), ScreenIntPoint(0, 18)}}, Time(25.0),
                              ScreenIntPoint(0, 25));
  auto idEnd3 = ProcessEvent(MultiTouchInput::MULTITOUCH_END, {}, Time(35.0),
                             ScreenIntPoint(0, 25));

  CheckOutgoingEvents({
      {Some(idStart0),
       MultiTouchInput::MULTITOUCH_START,
       {},
       Time(0.0),
       ScreenIntPoint(0, 0)},

      {Some(idMove1),
       MultiTouchInput::MULTITOUCH_MOVE,
       {{Time(10.0), ScreenIntPoint(0, 10)},
        {Time(16.0), ScreenIntPoint(0, 16)}},
       Time(20.0),
       ScreenIntPoint(0, 20)},

      // Discard the historical data point from time 18, because we've already
      // sent out an event with time 20 and don't want to go back before that.
      {Some(idMove2),
       MultiTouchInput::MULTITOUCH_MOVE,
       {},
       Time(25.0),
       ScreenIntPoint(0, 25)},

      {Some(idEnd3),
       MultiTouchInput::MULTITOUCH_END,
       {},
       Time(35.0),
       ScreenIntPoint(0, 25)},
  });
}

quality94%

¤ Dauer der Verarbeitung: 0.16 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.