src/ui/gfx/test/gfx_util.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/gfx/test/gfx_util.h"
   6
   7 #include <iomanip>
   8 #include <sstream>
   9 #include <string>
  10
  11 #include "ui/gfx/geometry/box_f.h"
  12 #include "ui/gfx/geometry/point.h"
  13 #include "ui/gfx/geometry/point3_f.h"
  14 #include "ui/gfx/geometry/point_f.h"
  15 #include "ui/gfx/geometry/quad_f.h"
  16 #include "ui/gfx/geometry/rect.h"
  17 #include "ui/gfx/geometry/rect_f.h"
  18 #include "ui/gfx/geometry/size.h"
  19 #include "ui/gfx/geometry/size_f.h"
  20 #include "ui/gfx/geometry/vector2d.h"
  21 #include "ui/gfx/geometry/vector2d_f.h"
  22 #include "ui/gfx/geometry/vector3d_f.h"
  23 #include "ui/gfx/transform.h"
  24
  25 namespace gfx {
  26
  27 namespace {
  28
  29 std::string ColorAsString(SkColor color) {
  30   std::ostringstream stream;
  31   stream << std::hex << std::uppercase << "#" << std::setfill('0')
  32          << std::setw(2) << SkColorGetA(color)
  33          << std::setw(2) << SkColorGetR(color)
  34          << std::setw(2) << SkColorGetG(color)
  35          << std::setw(2) << SkColorGetB(color);
  36   return stream.str();
  37 }
  38
  39 bool FloatAlmostEqual(float a, float b) {
  40   // FloatLE is the gtest predicate for less than or almost equal to.
  41   return ::testing::FloatLE("a", "b", a, b) &&
  42          ::testing::FloatLE("b", "a", b, a);
  43 }
  44
  45 }  // namespace
  46
  47 ::testing::AssertionResult AssertBoxFloatEqual(const char* lhs_expr,
  48                                                const char* rhs_expr,
  49                                                const BoxF& lhs,
  50                                                const BoxF& rhs) {
  51   if (FloatAlmostEqual(lhs.x(), rhs.x()) &&
  52       FloatAlmostEqual(lhs.y(), rhs.y()) &&
  53       FloatAlmostEqual(lhs.z(), rhs.z()) &&
  54       FloatAlmostEqual(lhs.width(), rhs.width()) &&
  55       FloatAlmostEqual(lhs.height(), rhs.height()) &&
  56       FloatAlmostEqual(lhs.depth(), rhs.depth())) {
  57     return ::testing::AssertionSuccess();
  58   }
  59   return ::testing::AssertionFailure() << "Value of: " << rhs_expr
  60                                        << "\n  Actual: " << rhs.ToString()
  61                                        << "\nExpected: " << lhs_expr
  62                                        << "\nWhich is: " << lhs.ToString();
  63 }
  64
  65 ::testing::AssertionResult AssertRectFloatEqual(const char* lhs_expr,
  66                                                 const char* rhs_expr,
  67                                                 const RectF& lhs,
  68                                                 const RectF& rhs) {
  69   if (FloatAlmostEqual(lhs.x(), rhs.x()) &&
  70       FloatAlmostEqual(lhs.y(), rhs.y()) &&
  71       FloatAlmostEqual(lhs.width(), rhs.width()) &&
  72       FloatAlmostEqual(lhs.height(), rhs.height())) {
  73     return ::testing::AssertionSuccess();
  74   }
  75   return ::testing::AssertionFailure()
  76          << "Value of: " << rhs_expr << "\n  Actual: " << rhs.ToString()
  77          << "\nExpected: " << lhs_expr << "\nWhich is: " << lhs.ToString();
  78 }
  79
  80 ::testing::AssertionResult AssertSkColorsEqual(const char* lhs_expr,
  81                                                const char* rhs_expr,
  82                                                SkColor lhs,
  83                                                SkColor rhs) {
  84   if (lhs == rhs) {
  85     return ::testing::AssertionSuccess();
  86   }
  87   return ::testing::AssertionFailure() << "Value of: " << rhs_expr
  88                                        << "\n  Actual: " << ColorAsString(rhs)
  89                                        << "\nExpected: " << lhs_expr
  90                                        << "\nWhich is: " << ColorAsString(lhs);
  91 }
  92
  93 void PrintTo(const BoxF& box, ::std::ostream* os) {
  94   *os << box.ToString();
  95 }
  96
  97 void PrintTo(const Point& point, ::std::ostream* os) {
  98   *os << point.ToString();
  99 }
 100
 101 void PrintTo(const Point3F& point, ::std::ostream* os) {
 102   *os << point.ToString();
 103 }
 104
 105 void PrintTo(const PointF& point, ::std::ostream* os) {
 106   *os << point.ToString();
 107 }
 108
 109 void PrintTo(const QuadF& quad, ::std::ostream* os) {
 110   *os << quad.ToString();
 111 }
 112
 113 void PrintTo(const Rect& rect, ::std::ostream* os) {
 114   *os << rect.ToString();
 115 }
 116
 117 void PrintTo(const RectF& rect, ::std::ostream* os) {
 118   *os << rect.ToString();
 119 }
 120
 121 void PrintTo(const Size& size, ::std::ostream* os) {
 122   *os << size.ToString();
 123 }
 124
 125 void PrintTo(const SizeF& size, ::std::ostream* os) {
 126   *os << size.ToString();
 127 }
 128
 129 void PrintTo(const Transform& transform, ::std::ostream* os) {
 130   *os << transform.ToString();
 131 }
 132
 133 void PrintTo(const Vector2d& vector, ::std::ostream* os) {
 134   *os << vector.ToString();
 135 }
 136
 137 void PrintTo(const Vector2dF& vector, ::std::ostream* os) {
 138   *os << vector.ToString();
 139 }
 140
 141 void PrintTo(const Vector3dF& vector, ::std::ostream* os) {
 142   *os << vector.ToString();
 143 }
 144
 145 }  // namespace gfx