Move all protocol event matchers to test_event_matchers.h

remoting/client/plugin/touch_input_scaler_unittest.cc

 // Copyright 2015 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 "remoting/client/plugin/touch_input_scaler.h"
 
 #include <cmath>
 
 #include "remoting/protocol/protocol_mock_objects.h"
+#include "remoting/protocol/test_event_matchers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::_;
+using ::testing::AllOf;
+using ::testing::PrintToString;
+
 namespace remoting {
 
-using ::testing::_;
-using ::testing::PrintToString;
 using protocol::MockInputStub;
 using protocol::TouchEvent;
 using protocol::TouchEventPoint;
+using protocol::test::EqualsTouchPointCoordinates;
+using protocol::test::EqualsTouchPointRadii;
 
 namespace {
 
-// If the rounding error for the coordinates checked in TouchPoint* matcher are
-// within 1 pixel diff, it should be acceptable.
-const float kEpsilon = 1.0f;
-
-void LogNumTouchPointMismatchError(int expected_size, int actual_size) {
-  DVLOG(1) << "Expected number of touch points (" << expected_size
-           << ") does not match the actual size (" << actual_size << ").";
-}
-
-void LogPointMismatchError(const std::string& field_name,
-                           int point_index,
-                           float expected,
-                           float actual) {
-  DVLOG(1) << "Point " << point_index << ": expected " << field_name
-           << " to be " << expected << ", actual " << actual
-           << " (not within rounding error grace " << kEpsilon << ").";
-}
-
-MATCHER_P(TouchPointCoordinateEqual,
-          expected_event,
-          "Expect point coordinates equal.") {
-  if (arg.touch_points().size() != expected_event.touch_points().size()) {
-    LogNumTouchPointMismatchError(expected_event.touch_points().size(),
-                                  arg.touch_points().size());
-    return false;
-  }
-
-  for (int i = 0; i < expected_event.touch_points().size(); ++i) {
-    const TouchEventPoint& arg_point = arg.touch_points(i);
-    const TouchEventPoint& expected_point = expected_event.touch_points(i);
-    if (std::abs(expected_point.x() - arg_point.x()) >= kEpsilon) {
-      LogPointMismatchError("X", i, expected_point.x(), arg_point.x());
-      return false;
-    }
-
-    if (std::abs(expected_point.y() - arg_point.y()) >= kEpsilon) {
-      LogPointMismatchError("Y", i, expected_point.y(), arg_point.y());
-      return false;
-    }
-  }
-  return true;
-}
-
-MATCHER_P(TouchPointRadiiEqual, expected_event, "Expected point radii equal.") {
-  if (arg.touch_points().size() != expected_event.touch_points().size()) {
-    LogNumTouchPointMismatchError(expected_event.touch_points().size(),
-                                  arg.touch_points().size());
-    return false;
-  }
-
-  for (int i = 0; i < expected_event.touch_points().size(); ++i) {
-    const TouchEventPoint& arg_point = arg.touch_points(i);
-    const TouchEventPoint& expected_point = expected_event.touch_points(i);
-    if (std::abs(expected_point.radius_x() - arg_point.radius_x()) >=
-        kEpsilon) {
-      LogPointMismatchError("radius X", i, expected_point.radius_x(),
-                            arg_point.radius_x());
-      return false;
-    }
-
-    if (std::abs(expected_point.radius_y() - arg_point.radius_y()) >=
-        kEpsilon) {
-      LogPointMismatchError("radius Y", i, expected_point.radius_y(),
-                            arg_point.radius_y());
-      return false;
-    }
-  }
-  return true;
-}
-
 const float kDefaultRadius = 30.0f;
 const float kDefaultXCoord = 1.0f;
 const float kDefaultYCoord = 1.0f;
 
 struct PointInfo {
   PointInfo(float x, float y)
       : PointInfo(x, y, kDefaultRadius, kDefaultRadius) {}
   PointInfo(float x, float y, float radius_x, float radius_y)
       : x(x), y(y), radius_x(radius_x), radius_y(radius_y) {}
 
@@ skipping 90 matching lines @@
   SetInputDimensions(50, 60);
   SetOutputDimensions(50, 60);
 
   AddInputCoordinate({10.0f, 15.0f});
   TouchEvent expected_out;
   TouchEventPoint* point = expected_out.add_touch_points();
   point->set_x(10.0f);
   point->set_y(15.0f);
 
   EXPECT_CALL(mock_stub_,
-              InjectTouchEvent(TouchPointCoordinateEqual(expected_out)));
+              InjectTouchEvent(EqualsTouchPointCoordinates(expected_out)));
   InjectTestTouchEvent();
 }
 
 // Make sure clamping works.
 TEST_F(TouchInputScalerTest, ClampingNoScaling) {
   SetInputDimensions(50, 60);
   SetOutputDimensions(50, 60);
 
   // Note that this could happen if touch started in the chromoting window but
   // the finger moved off the windows.
   AddInputCoordinate({-1.0f, 1.0f});
   TouchEvent expected_out;
   TouchEventPoint* point = expected_out.add_touch_points();
   point->set_x(0.0f);
   point->set_y(1.0f);
 
   EXPECT_CALL(mock_stub_,
-              InjectTouchEvent(TouchPointCoordinateEqual(expected_out)));
+              InjectTouchEvent(EqualsTouchPointCoordinates(expected_out)));
   InjectTestTouchEvent();
 }
 
 TEST_F(TouchInputScalerTest, ClampingMultiplePointsNoScaling) {
   SetInputDimensions(50, 60);
   SetOutputDimensions(50, 60);
 
   AddInputCoordinate({-1.0f, 1.0f});  // Fall off left.
   TouchEvent expected_out;
   TouchEventPoint* point = expected_out.add_touch_points();
@@ skipping 14 matching lines @@
   point = expected_out.add_touch_points();
   point->set_x(3.0f);
   point->set_y(0.0f);
 
   AddInputCoordinate({10.0f, 200.0f});  // Fall off below.
   point = expected_out.add_touch_points();
   point->set_x(10.0f);
   point->set_y(59.0f);
 
   EXPECT_CALL(mock_stub_,
-              InjectTouchEvent(TouchPointCoordinateEqual(expected_out)));
+              InjectTouchEvent(EqualsTouchPointCoordinates(expected_out)));
   InjectTestTouchEvent();
 }
 
 // Verify up-scaling works. All coordinates should fall inside the output
 // dimensions after scaling.
 TEST_F(TouchInputScalerTest, UpScalingNoClamping) {
   SetInputDimensions(20, 20);
   SetOutputDimensions(40, 40);
 
   AddInputCoordinate({1.0f, 1.0f});
   TouchEvent expected_out;
   TouchEventPoint* point = expected_out.add_touch_points();
   point->set_x(2.0f);
   point->set_y(2.0f);
 
   AddInputCoordinate({1.2f, 4.2f});
   point = expected_out.add_touch_points();
   point->set_x(2.4f);
   point->set_y(8.4f);
 
   EXPECT_CALL(mock_stub_,
-              InjectTouchEvent(TouchPointCoordinateEqual(expected_out)));
+              InjectTouchEvent(EqualsTouchPointCoordinates(expected_out)));
   InjectTestTouchEvent();
 }
 
 // Verify up-scaling works with clamping.
 TEST_F(TouchInputScalerTest, UpScalingWithClamping) {
   SetInputDimensions(20, 20);
   SetOutputDimensions(40, 40);
 
   AddInputCoordinate({25.0f, 25.0f});
   TouchEvent expected_out;
   TouchEventPoint* point = expected_out.add_touch_points();
   point->set_x(39.0f);
   point->set_y(39.0f);
 
   EXPECT_CALL(mock_stub_,
-              InjectTouchEvent(TouchPointCoordinateEqual(expected_out)));
+              InjectTouchEvent(EqualsTouchPointCoordinates(expected_out)));
   InjectTestTouchEvent();
 }
 
 // Verify down scaling works. All coordinates should fall inside the output
 // dimensions after scaling.
 TEST_F(TouchInputScalerTest, DownScalingNoClamping) {
   SetInputDimensions(40, 40);
   SetOutputDimensions(20, 20);
 
   AddInputCoordinate({2.0f, 2.0f});
   TouchEvent expected_out;
   TouchEventPoint* point = expected_out.add_touch_points();
   point->set_x(1.0f);
   point->set_y(1.0f);
 
   AddInputCoordinate({6.0f, 3.0f});
   point = expected_out.add_touch_points();
   point->set_x(3.0);
   point->set_y(1.5f);
 
   EXPECT_CALL(mock_stub_,
-              InjectTouchEvent(TouchPointCoordinateEqual(expected_out)));
+              InjectTouchEvent(EqualsTouchPointCoordinates(expected_out)));
   InjectTestTouchEvent();
 }
 
 // Verify down scaling works with clamping.
 TEST_F(TouchInputScalerTest, DownScalingWithClamping) {
   SetInputDimensions(40, 40);
   SetOutputDimensions(20, 20);
 
   AddInputCoordinate({-20.0f, 10.0f});
   TouchEvent expected_out;
@@ skipping 10 matching lines @@
   point = expected_out.add_touch_points();
   point->set_x(3.0f);
   point->set_y(19.0f);
 
   AddInputCoordinate({80.0f, 6.0f});
   point = expected_out.add_touch_points();
   point->set_x(19.0f);
   point->set_y(3.0f);
 
   EXPECT_CALL(mock_stub_,
-              InjectTouchEvent(TouchPointCoordinateEqual(expected_out)));
+              InjectTouchEvent(EqualsTouchPointCoordinates(expected_out)));
   InjectTestTouchEvent();
 }
 
 // Verify that the radii are up-scaled.
 TEST_F(TouchInputScalerTest, UpScaleRadii) {
   SetInputDimensions(20, 20);
   SetOutputDimensions(40, 40);
 
   AddInputCoordinate({0.0f, 0.0f, 1.0f, 2.0f});
   TouchEvent expected_out;
   TouchEventPoint* point = expected_out.add_touch_points();
   point->set_radius_x(2.0f);
   point->set_radius_y(4.0f);
 
-  EXPECT_CALL(mock_stub_, InjectTouchEvent(TouchPointRadiiEqual(expected_out)));
+  EXPECT_CALL(mock_stub_,
+              InjectTouchEvent(EqualsTouchPointRadii(expected_out)));
   InjectTestTouchEvent();
 }
 
 // Verify that the radii are down-scaled.
 TEST_F(TouchInputScalerTest, DownScaleRadii) {
   SetInputDimensions(20, 20);
   SetOutputDimensions(10, 10);
 
   AddInputCoordinate({0.0f, 0.0f, 5.0f, 4.0f});
   TouchEvent expected_out;
   TouchEventPoint* point = expected_out.add_touch_points();
   point->set_radius_x(2.5f);
   point->set_radius_y(2.0f);
 
-  EXPECT_CALL(mock_stub_, InjectTouchEvent(TouchPointRadiiEqual(expected_out)));
+  EXPECT_CALL(mock_stub_,
+              InjectTouchEvent(EqualsTouchPointRadii(expected_out)));
   InjectTestTouchEvent();
 }
 
 // Verify that up-scaling with clamping works for x,y coordinates and radii all
 // work together.
 TEST_F(TouchInputScalerTest, UpScaleCoordinatesAndRadii) {
   SetInputDimensions(20, 20);
   SetOutputDimensions(40, 40);
 
   AddInputCoordinate({5.0f, 12.0f, 3.0f, 2.0f});
   TouchEvent expected_out;
   TouchEventPoint* point = expected_out.add_touch_points();
   point->set_x(10.0f);
   point->set_y(24.0f);
   point->set_radius_x(6.0f);
   point->set_radius_y(4.0f);
 
   // Make sure clamping and scaling all work.
   AddInputCoordinate({22.0f, -1.0f, 8.0f, 3.0f});
   point = expected_out.add_touch_points();
   point->set_x(39.0f);
   point->set_y(0.0f);
   point->set_radius_x(16.0f);
   point->set_radius_y(6.0f);
 
-  EXPECT_CALL(mock_stub_, InjectTouchEvent(::testing::AllOf(
-                              TouchPointCoordinateEqual(expected_out),
-                              TouchPointRadiiEqual(expected_out))));
+  EXPECT_CALL(mock_stub_,
+              InjectTouchEvent(AllOf(EqualsTouchPointCoordinates(expected_out),
+                                     EqualsTouchPointRadii(expected_out))));
   InjectTestTouchEvent();
 }
 
 // Verify that down-scaling with clamping works for x,y coordinates and radii
 // all work together.
 TEST_F(TouchInputScalerTest, DownScaleCoordinatesAndRadii) {
   SetInputDimensions(60, 60);
   SetOutputDimensions(20, 20);
 
   AddInputCoordinate({50.0f, 24.0f, 10.0f, 9.0f});
   TouchEvent expected_out;
   TouchEventPoint* point = expected_out.add_touch_points();
   point->set_x(16.666f);
   point->set_y(8.0f);
   point->set_radius_x(3.333f);
   point->set_radius_y(3.0f);
 
   // Make sure clamping and scaling all work.
   AddInputCoordinate({70.0f, 82.0f, 8.0f, 3.0f});
   point = expected_out.add_touch_points();
   point->set_x(19.0f);
   point->set_y(19.0f);
   point->set_radius_x(2.666f);
   point->set_radius_y(1.0f);
 
-  EXPECT_CALL(mock_stub_, InjectTouchEvent(::testing::AllOf(
-                              TouchPointCoordinateEqual(expected_out),
-                              TouchPointRadiiEqual(expected_out))));
+  EXPECT_CALL(mock_stub_,
+              InjectTouchEvent(AllOf(EqualsTouchPointCoordinates(expected_out),
+                                     EqualsTouchPointRadii(expected_out))));
   InjectTestTouchEvent();
 }
 
 }  // namespace remoting