touch_keyboard/statemachine/statemachine_test.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2016 The Chromium OS 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 "touch_keyboard/statemachine/statemachine.h"
 #include <gtest/gtest.h>

 namespace mtstatemachine {

 // These values are used to test "finger" number 1.
 constexpr int kTestSlot1 = 1;
 constexpr int kTestTID1 = 11;
 constexpr int kTestX1 = 101;
 constexpr int kTestY1 = 201;
 constexpr int kTestP1 = 301;

 // These values are used to test "finger" number 1.
 constexpr int kTestSlot2 = 2;
 constexpr int kTestTID2 = 12;
 constexpr int kTestX2 = 102;
 constexpr int kTestY2 = 202;
 constexpr int kTestP2 = 302;

 class StateMachineTest : public ::testing::Test {
  protected:
   struct input_event CreateInputEvent(int type, int code, int value) const {
     // Create a dummy input_event struct to pass to an MtStateMachine.
     // Don't bother filling in the "time" field of the struct -- it's unused.
     struct input_event ev;
     ev.type = type;
     ev.code = code;
     ev.value = value;
     return ev;
   }
 };

 TEST_F(StateMachineTest, BasicOneFingerTest) {
   // Test to confirm that a single, well behaived finger is understood as it
   // arrives, moves, then leaves.
   MtStateMachine sm;
   std::map<int, struct MtFinger> snapshot;

   // The snapshot should start empty.  Confirm this before starting.
   EXPECT_TRUE(snapshot.empty());

   // Adding events shouldn't return true or alter the snapshot until the
   // whole batch is in and we send a SYN event.
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID,
                                             kTestTID1), &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX1),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY1),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP1),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());

   // Sending a SYN event should return true and populate the snapshot object.
   // The snapshot should match the values in the events we added to the
   // state machine earlier.  (ie: one finger with the above values)
   EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
   EXPECT_FALSE(snapshot.empty());
   EXPECT_EQ(snapshot.size(), 1);
   EXPECT_NE(snapshot.find(kTestTID1), snapshot.end());
   EXPECT_EQ(snapshot[kTestTID1].x, kTestX1);
   EXPECT_EQ(snapshot[kTestTID1].y, kTestY1);
   EXPECT_EQ(snapshot[kTestTID1].p, kTestP1);

   // Now, we update the x value to simulate the finger moving 1 pixel right.
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X,
                                             kTestX1 + 1), &snapshot));

   // A SYN event tells the state machine that all values have updated, and we
   // can check the contents of the snapshot again to make sure that X (and only
   // X) was updated.
   EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
   EXPECT_FALSE(snapshot.empty());
   EXPECT_EQ(snapshot.size(), 1);
   EXPECT_NE(snapshot.find(kTestTID1), snapshot.end());
   EXPECT_EQ(snapshot[kTestTID1].x, kTestX1 + 1);
   EXPECT_EQ(snapshot[kTestTID1].y, kTestY1);
   EXPECT_EQ(snapshot[kTestTID1].p, kTestP1);

   // Now, make the finger leave by marking it's TID as invalid (-1).
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, -1),
                            &snapshot));
   // After a SYN, we should see the snapshot emptied out.
   EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
   EXPECT_TRUE(snapshot.empty());
 }

 TEST_F(StateMachineTest, BasicTwoFingerTest) {
   // This is a test to confirm that a two well behaived fingers are understood
   // as they arrive, move, then finally leave.
   MtStateMachine sm;
   std::map<int, struct MtFinger> snapshot;

   // The snapshot should start empty.  Confirm this before starting.
   EXPECT_TRUE(snapshot.empty());

   // Adding events shouldn't return true or alter the snapshot until the
   // whole batch is in and we send a SYN event.
   // Establish values for finger 1.
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID,
                                             kTestTID1), &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX1),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY1),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP1),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());

   // Establish values for finger 2.
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot2),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID,
                                             kTestTID2), &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX2),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY2),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP2),
                            &snapshot));
   EXPECT_TRUE(snapshot.empty());

   // Sending a SYN event should return true and populate the snapshot object
   // with data from both of the fingers.
   EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
   EXPECT_FALSE(snapshot.empty());

   // The snapshot should match the values in the events we added to the
   // state machine earlier.  (ie: two fingers with the above values)
   EXPECT_EQ(snapshot.size(), 2);
   EXPECT_NE(snapshot.find(kTestTID1), snapshot.end());
   EXPECT_EQ(snapshot[kTestTID1].x, kTestX1);
   EXPECT_EQ(snapshot[kTestTID1].y, kTestY1);
   EXPECT_EQ(snapshot[kTestTID1].p, kTestP1);
   EXPECT_NE(snapshot.find(kTestTID2), snapshot.end());
   EXPECT_EQ(snapshot[kTestTID2].x, kTestX2);
   EXPECT_EQ(snapshot[kTestTID2].y, kTestY2);
   EXPECT_EQ(snapshot[kTestTID2].p, kTestP2);

   // Next, simulate them both moving a bit by updating a couple of their values.
   // Confirm that the values are updated in the snapshot after a SYN event.
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1),
                            &snapshot));
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y,
                                             kTestY1 + 1), &snapshot));
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot2),
                            &snapshot));
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE,
                                             kTestP2 + 1), &snapshot));
   EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
   EXPECT_EQ(snapshot.size(), 2);
   EXPECT_NE(snapshot.find(kTestTID1), snapshot.end());
   EXPECT_EQ(snapshot[kTestTID1].x, kTestX1);
   EXPECT_EQ(snapshot[kTestTID1].y, kTestY1 + 1);
   EXPECT_EQ(snapshot[kTestTID1].p, kTestP1);
   EXPECT_NE(snapshot.find(kTestTID2), snapshot.end());
   EXPECT_EQ(snapshot[kTestTID2].x, kTestX2);
   EXPECT_EQ(snapshot[kTestTID2].y, kTestY2);
   EXPECT_EQ(snapshot[kTestTID2].p, kTestP2 + 1);

   // Now mark each finger's tracking ID as -1 in turn -- indicating that the
   // finger has left checking that the state machine understands.
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1),
                            &snapshot));
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, -1),
                            &snapshot));
   EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
   EXPECT_EQ(snapshot.size(), 1);
   EXPECT_EQ(snapshot.find(kTestTID1), snapshot.end());
   EXPECT_NE(snapshot.find(kTestTID2), snapshot.end());
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot2),
                            &snapshot));
   EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, -1),
                            &snapshot));
   EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
   EXPECT_TRUE(snapshot.empty());
   EXPECT_EQ(snapshot.find(kTestTID1), snapshot.end());
   EXPECT_EQ(snapshot.find(kTestTID2), snapshot.end());
 }

 TEST_F(StateMachineTest, RepeatedUpdateTest) {
   // This tests how the state machine handles the situation where a single
   // value is updated repeatedly without SYNs between them.  This is an
   // unexpected behavior, but it is observed occasionally in the field with
   // poorly written touch firmware.
   MtStateMachine sm;
   std::map<int, struct MtFinger> snapshot;

   // Set up a finger with valid values in the state machine, but send two
   // different pressure values before the SYN and confirm that only the
   // last value sent is reported in the snapshot.
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, kTestTID1),
               &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP2), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot);

   // The snapshot should include the finger, plus the latter pressure value
   // kTestP2 should have completely overwritten kTestP1.
   EXPECT_NE(snapshot.find(kTestTID1), snapshot.end());
   EXPECT_EQ(snapshot[kTestTID1].p, kTestP2);
 }

 TEST_F(StateMachineTest, DeltaCompressionTest) {
   // When a finger leaves, it's values remained stored in its slot -- so if
   // by chance the next finger that is assigned to that slot happens to have
   // the same value for something the kernel will delta-compress that event
   // away entirely.  This state machine needs to handle this case.
   MtStateMachine sm;
   std::map<int, struct MtFinger> snapshot;

   // Set up a finger with valid values in the state machine and issue a SYN.
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, kTestTID1),
               &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot);

   // Now show that finger leaving the pad by invalidating it's tracking ID.
   // The other values should remain unchanged in the internal state of its slot.
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, -1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot);

   // When a new finger arrives, if it's assigned to the same slot, the old
   // values remain until they are overwritten, so we'll update all the values
   // for the new contact, except one and make sure the value that we skipped
   // retains the old value from the previous finger.
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, kTestTID2),
               &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY2), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP2), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot);
   EXPECT_EQ(snapshot.find(kTestTID1), snapshot.end());
   EXPECT_NE(snapshot.find(kTestTID2), snapshot.end());
   EXPECT_EQ(snapshot[kTestTID2].x, kTestX1);
   EXPECT_EQ(snapshot[kTestTID2].y, kTestY2);
   EXPECT_EQ(snapshot[kTestTID2].p, kTestP2);
 }

 TEST_F(StateMachineTest, BadTrackingIdTest) {
   // Even if a finger has valid data, a bad tracking ID should indicate that
   // it's not a valid finger and should never be included in a snapshot.
   MtStateMachine sm;
   std::map<int, struct MtFinger> snapshot;

   // Set up a finger with valid values for everything but the tracking ID
   // in the state machine and issue a SYN.
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP1), &snapshot);
   sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot);

   // The snapshot should be empty because we didn't add a tracking ID
   EXPECT_TRUE(snapshot.empty());
 }

 }  // namespace mtstatemachine

 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
	// Copyright 2016 The Chromium OS 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 "touch_keyboard/statemachine/statemachine.h"
	#include <gtest/gtest.h>

	namespace mtstatemachine {

	// These values are used to test "finger" number 1.
	constexpr int kTestSlot1 = 1;
	constexpr int kTestTID1 = 11;
	constexpr int kTestX1 = 101;
	constexpr int kTestY1 = 201;
	constexpr int kTestP1 = 301;

	// These values are used to test "finger" number 1.
	constexpr int kTestSlot2 = 2;
	constexpr int kTestTID2 = 12;
	constexpr int kTestX2 = 102;
	constexpr int kTestY2 = 202;
	constexpr int kTestP2 = 302;

	class StateMachineTest : public ::testing::Test {
	protected:
	struct input_event CreateInputEvent(int type, int code, int value) const {
	// Create a dummy input_event struct to pass to an MtStateMachine.
	// Don't bother filling in the "time" field of the struct -- it's unused.
	struct input_event ev;
	ev.type = type;
	ev.code = code;
	ev.value = value;
	return ev;
	}
	};

	TEST_F(StateMachineTest, BasicOneFingerTest) {
	// Test to confirm that a single, well behaived finger is understood as it
	// arrives, moves, then leaves.
	MtStateMachine sm;
	std::map<int, struct MtFinger> snapshot;

	// The snapshot should start empty. Confirm this before starting.
	EXPECT_TRUE(snapshot.empty());

	// Adding events shouldn't return true or alter the snapshot until the
	// whole batch is in and we send a SYN event.
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID,
	kTestTID1), &snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX1),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY1),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP1),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());

	// Sending a SYN event should return true and populate the snapshot object.
	// The snapshot should match the values in the events we added to the
	// state machine earlier. (ie: one finger with the above values)
	EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
	EXPECT_FALSE(snapshot.empty());
	EXPECT_EQ(snapshot.size(), 1);
	EXPECT_NE(snapshot.find(kTestTID1), snapshot.end());
	EXPECT_EQ(snapshot[kTestTID1].x, kTestX1);
	EXPECT_EQ(snapshot[kTestTID1].y, kTestY1);
	EXPECT_EQ(snapshot[kTestTID1].p, kTestP1);

	// Now, we update the x value to simulate the finger moving 1 pixel right.
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X,
	kTestX1 + 1), &snapshot));

	// A SYN event tells the state machine that all values have updated, and we
	// can check the contents of the snapshot again to make sure that X (and only
	// X) was updated.
	EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
	EXPECT_FALSE(snapshot.empty());
	EXPECT_EQ(snapshot.size(), 1);
	EXPECT_NE(snapshot.find(kTestTID1), snapshot.end());
	EXPECT_EQ(snapshot[kTestTID1].x, kTestX1 + 1);
	EXPECT_EQ(snapshot[kTestTID1].y, kTestY1);
	EXPECT_EQ(snapshot[kTestTID1].p, kTestP1);

	// Now, make the finger leave by marking it's TID as invalid (-1).
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, -1),
	&snapshot));
	// After a SYN, we should see the snapshot emptied out.
	EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
	EXPECT_TRUE(snapshot.empty());
	}

	TEST_F(StateMachineTest, BasicTwoFingerTest) {
	// This is a test to confirm that a two well behaived fingers are understood
	// as they arrive, move, then finally leave.
	MtStateMachine sm;
	std::map<int, struct MtFinger> snapshot;

	// The snapshot should start empty. Confirm this before starting.
	EXPECT_TRUE(snapshot.empty());

	// Adding events shouldn't return true or alter the snapshot until the
	// whole batch is in and we send a SYN event.
	// Establish values for finger 1.
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID,
	kTestTID1), &snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX1),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY1),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP1),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());

	// Establish values for finger 2.
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot2),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID,
	kTestTID2), &snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX2),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY2),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP2),
	&snapshot));
	EXPECT_TRUE(snapshot.empty());

	// Sending a SYN event should return true and populate the snapshot object
	// with data from both of the fingers.
	EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
	EXPECT_FALSE(snapshot.empty());

	// The snapshot should match the values in the events we added to the
	// state machine earlier. (ie: two fingers with the above values)
	EXPECT_EQ(snapshot.size(), 2);
	EXPECT_NE(snapshot.find(kTestTID1), snapshot.end());
	EXPECT_EQ(snapshot[kTestTID1].x, kTestX1);
	EXPECT_EQ(snapshot[kTestTID1].y, kTestY1);
	EXPECT_EQ(snapshot[kTestTID1].p, kTestP1);
	EXPECT_NE(snapshot.find(kTestTID2), snapshot.end());
	EXPECT_EQ(snapshot[kTestTID2].x, kTestX2);
	EXPECT_EQ(snapshot[kTestTID2].y, kTestY2);
	EXPECT_EQ(snapshot[kTestTID2].p, kTestP2);

	// Next, simulate them both moving a bit by updating a couple of their values.
	// Confirm that the values are updated in the snapshot after a SYN event.
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1),
	&snapshot));
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y,
	kTestY1 + 1), &snapshot));
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot2),
	&snapshot));
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE,
	kTestP2 + 1), &snapshot));
	EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
	EXPECT_EQ(snapshot.size(), 2);
	EXPECT_NE(snapshot.find(kTestTID1), snapshot.end());
	EXPECT_EQ(snapshot[kTestTID1].x, kTestX1);
	EXPECT_EQ(snapshot[kTestTID1].y, kTestY1 + 1);
	EXPECT_EQ(snapshot[kTestTID1].p, kTestP1);
	EXPECT_NE(snapshot.find(kTestTID2), snapshot.end());
	EXPECT_EQ(snapshot[kTestTID2].x, kTestX2);
	EXPECT_EQ(snapshot[kTestTID2].y, kTestY2);
	EXPECT_EQ(snapshot[kTestTID2].p, kTestP2 + 1);

	// Now mark each finger's tracking ID as -1 in turn -- indicating that the
	// finger has left checking that the state machine understands.
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1),
	&snapshot));
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, -1),
	&snapshot));
	EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
	EXPECT_EQ(snapshot.size(), 1);
	EXPECT_EQ(snapshot.find(kTestTID1), snapshot.end());
	EXPECT_NE(snapshot.find(kTestTID2), snapshot.end());
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot2),
	&snapshot));
	EXPECT_FALSE(sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, -1),
	&snapshot));
	EXPECT_TRUE(sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot));
	EXPECT_TRUE(snapshot.empty());
	EXPECT_EQ(snapshot.find(kTestTID1), snapshot.end());
	EXPECT_EQ(snapshot.find(kTestTID2), snapshot.end());
	}

	TEST_F(StateMachineTest, RepeatedUpdateTest) {
	// This tests how the state machine handles the situation where a single
	// value is updated repeatedly without SYNs between them. This is an
	// unexpected behavior, but it is observed occasionally in the field with
	// poorly written touch firmware.
	MtStateMachine sm;
	std::map<int, struct MtFinger> snapshot;

	// Set up a finger with valid values in the state machine, but send two
	// different pressure values before the SYN and confirm that only the
	// last value sent is reported in the snapshot.
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, kTestTID1),
	&snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP2), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot);

	// The snapshot should include the finger, plus the latter pressure value
	// kTestP2 should have completely overwritten kTestP1.
	EXPECT_NE(snapshot.find(kTestTID1), snapshot.end());
	EXPECT_EQ(snapshot[kTestTID1].p, kTestP2);
	}

	TEST_F(StateMachineTest, DeltaCompressionTest) {
	// When a finger leaves, it's values remained stored in its slot -- so if
	// by chance the next finger that is assigned to that slot happens to have
	// the same value for something the kernel will delta-compress that event
	// away entirely. This state machine needs to handle this case.
	MtStateMachine sm;
	std::map<int, struct MtFinger> snapshot;

	// Set up a finger with valid values in the state machine and issue a SYN.
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, kTestTID1),
	&snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot);

	// Now show that finger leaving the pad by invalidating it's tracking ID.
	// The other values should remain unchanged in the internal state of its slot.
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, -1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot);

	// When a new finger arrives, if it's assigned to the same slot, the old
	// values remain until they are overwritten, so we'll update all the values
	// for the new contact, except one and make sure the value that we skipped
	// retains the old value from the previous finger.
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_TRACKING_ID, kTestTID2),
	&snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY2), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP2), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot);
	EXPECT_EQ(snapshot.find(kTestTID1), snapshot.end());
	EXPECT_NE(snapshot.find(kTestTID2), snapshot.end());
	EXPECT_EQ(snapshot[kTestTID2].x, kTestX1);
	EXPECT_EQ(snapshot[kTestTID2].y, kTestY2);
	EXPECT_EQ(snapshot[kTestTID2].p, kTestP2);
	}

	TEST_F(StateMachineTest, BadTrackingIdTest) {
	// Even if a finger has valid data, a bad tracking ID should indicate that
	// it's not a valid finger and should never be included in a snapshot.
	MtStateMachine sm;
	std::map<int, struct MtFinger> snapshot;

	// Set up a finger with valid values for everything but the tracking ID
	// in the state machine and issue a SYN.
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_SLOT, kTestSlot1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_X, kTestX1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_POSITION_Y, kTestY1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_ABS, ABS_MT_PRESSURE, kTestP1), &snapshot);
	sm.AddEvent(CreateInputEvent(EV_SYN, SYN_REPORT, 0), &snapshot);

	// The snapshot should be empty because we didn't add a tracking ID
	EXPECT_TRUE(snapshot.empty());
	}

	} // namespace mtstatemachine

	int main(int argc, char** argv) {
	::testing::InitGoogleTest(&argc, argv);
	return RUN_ALL_TESTS();
	}