Add Vector2d classes that represent offsets, instead of using Point.

ui/gfx/vector2d_unittest.cc

+// Copyright (c) 2012 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 "base/basictypes.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/vector2d.h"
+#include "ui/gfx/vector2d_f.h"
+
+#include <limits>
+
+namespace ui {

[tfarina, 2012/10/26 22:04:19]

Looks like only the unittests you added are wrapped in 'ui' namespace:
$ for f in $(find ui/gfx/ -name "*unittest.cc*"); do git grep -n "namespace ui
{" $f; done

ui/gfx/safe_integer_conversions_unittest.cc:11:namespace ui {
ui/gfx/point_unittest.cc:11:namespace ui {
ui/gfx/rect_unittest.cc:13:namespace ui {
ui/gfx/size_unittest.cc:12:namespace ui {

But instead they should be in 'gfx' namespace:

$ for f in $(find ui/gfx/ -name "*unittest.cc*"); do git grep -n "namespace gfx
{" $f; done                                                                     
                               
ui/gfx/font_list_unittest.cc:30:namespace gfx {
ui/gfx/shadow_value_unittest.cc:10:namespace gfx {
ui/gfx/canvas_unittest.cc:10:namespace gfx {
ui/gfx/font_fallback_win_unittest.cc:8:namespace gfx {
ui/gfx/render_text_unittest.cc:21:namespace gfx {
ui/gfx/image/image_skia_unittest.cc:24:namespace gfx {
ui/gfx/platform_font_win_unittest.cc:12:namespace gfx {
ui/gfx/codec/jpeg_codec_unittest.cc:59:namespace gfx {
ui/gfx/codec/png_codec_unittest.cc:23:namespace gfx {
ui/gfx/platform_font_pango_unittest.cc:13:namespace gfx {

To be consistent with the rest of the unittests in this directory.

You may fix this one, and let the others for a follow up CL.

[danakj, 2012/10/26 22:07:58]

Oh, thanks. I was assuming all tests were in ui since the ones I'd looked at
were.

+
+TEST(Vector2dTest, ConversionToFloat) {
+  gfx::Vector2d i(3, 4);
+  gfx::Vector2dF f = i;
+  EXPECT_EQ(i, f);
+}
+
+TEST(Vector2dTest, IsZero) {
+  gfx::Vector2d int_zero(0, 0);
+  gfx::Vector2d int_nonzero(2, -2);
+  gfx::Vector2dF float_zero(0, 0);
+  gfx::Vector2dF float_nonzero(0.1f, -0.1f);
+
+  EXPECT_TRUE(int_zero.IsZero());
+  EXPECT_FALSE(int_nonzero.IsZero());
+  EXPECT_TRUE(float_zero.IsZero());
+  EXPECT_FALSE(float_nonzero.IsZero());
+}
+
+TEST(Vector2dTest, Grow) {
+  gfx::Vector2d i(3, 5);
+  gfx::Vector2dF f(3.1f, 5.1f);
+
+  i.Grow(4, -1);
+  EXPECT_EQ(gfx::Vector2d(3 + 4, 5 - 1).ToString(), i.ToString());
+
+  f.Grow(4.3f, -1.3f);
+  EXPECT_EQ(gfx::Vector2dF(3.1f + 4.3f, 5.1f - 1.3f).ToString(), f.ToString());
+}
+
+TEST(Vector2dTest, Add) {
+  gfx::Vector2d i1(3, 5);
+  gfx::Vector2d i2(4, -1);
+
+  static const struct {
+    gfx::Vector2d expected;
+    gfx::Vector2d actual;
+  } int_tests[] = {
+    { gfx::Vector2d(3, 5), i1 + gfx::Vector2d() },
+    { gfx::Vector2d(3 + 4, 5 - 1), i1 + i2 },
+    { gfx::Vector2d(3 - 4, 5 + 1), i1 - i2 }
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(int_tests); ++i)
+    EXPECT_EQ(int_tests[i].expected.ToString(),
+              int_tests[i].actual.ToString());
+
+  gfx::Vector2dF f1(3.1f, 5.1f);
+  gfx::Vector2dF f2(4.3f, -1.3f);
+
+  static const struct {
+    gfx::Vector2dF expected;
+    gfx::Vector2dF actual;
+  } float_tests[] = {
+    { gfx::Vector2dF(3.1F, 5.1F), f1 + gfx::Vector2d() },
+    { gfx::Vector2dF(3.1F, 5.1F), f1 + gfx::Vector2dF() },
+    { gfx::Vector2dF(3.1f + 4.3f, 5.1f - 1.3f), f1 + f2 },
+    { gfx::Vector2dF(3.1f - 4.3f, 5.1f + 1.3f), f1 - f2 }
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(float_tests); ++i)
+    EXPECT_EQ(float_tests[i].expected.ToString(),
+              float_tests[i].actual.ToString());
+}
+
+TEST(Vector2dTest, Negative) {
+  static const struct {
+    gfx::Vector2d expected;
+    gfx::Vector2d actual;
+  } int_tests[] = {
+    { gfx::Vector2d(0, 0), -gfx::Vector2d(0, 0) },
+    { gfx::Vector2d(-3, -3), -gfx::Vector2d(3, 3) },
+    { gfx::Vector2d(3, 3), -gfx::Vector2d(-3, -3) },
+    { gfx::Vector2d(-3, 3), -gfx::Vector2d(3, -3) },
+    { gfx::Vector2d(3, -3), -gfx::Vector2d(-3, 3) }
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(int_tests); ++i)
+    EXPECT_EQ(int_tests[i].expected.ToString(),
+              int_tests[i].actual.ToString());
+
+  static const struct {
+    gfx::Vector2dF expected;
+    gfx::Vector2dF actual;
+  } float_tests[] = {
+    { gfx::Vector2dF(0, 0), -gfx::Vector2d(0, 0) },
+    { gfx::Vector2dF(-0.3f, -0.3f), -gfx::Vector2dF(0.3f, 0.3f) },
+    { gfx::Vector2dF(0.3f, 0.3f), -gfx::Vector2dF(-0.3f, -0.3f) },
+    { gfx::Vector2dF(-0.3f, 0.3f), -gfx::Vector2dF(0.3f, -0.3f) },
+    { gfx::Vector2dF(0.3f, -0.3f), -gfx::Vector2dF(-0.3f, 0.3f) }
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(float_tests); ++i)
+    EXPECT_EQ(float_tests[i].expected.ToString(),
+              float_tests[i].actual.ToString());
+}
+
+TEST(Vector2dTest, Scale) {
+  float double_values[][4] = {
+    { 4.5f, 1.2f, 3.3f, 5.6f },
+    { 4.5f, -1.2f, 3.3f, 5.6f },
+    { 4.5f, 1.2f, 3.3f, -5.6f },
+    { 4.5f, 1.2f, -3.3f, -5.6f },
+    { -4.5f, 1.2f, 3.3f, 5.6f },
+    { -4.5f, 1.2f, 0, 5.6f },
+    { -4.5f, 1.2f, 3.3f, 0 },
+    { 4.5f, 0, 3.3f, 5.6f },
+    { 0, 1.2f, 3.3f, 5.6f }
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(double_values); ++i) {
+    gfx::Vector2dF v(double_values[i][0], double_values[i][1]);
+    v.Scale(double_values[i][2], double_values[i][3]);
+    EXPECT_EQ(v.x(), double_values[i][0] * double_values[i][2]);
+    EXPECT_EQ(v.y(), double_values[i][1] * double_values[i][3]);
+  }
+
+  float single_values[][3] = {
+    { 4.5f, 1.2f, 3.3f },
+    { 4.5f, -1.2f, 3.3f },
+    { 4.5f, 1.2f, 3.3f },
+    { 4.5f, 1.2f, -3.3f },
+    { -4.5f, 1.2f, 3.3f },
+    { -4.5f, 1.2f, 0 },
+    { -4.5f, 1.2f, 3.3f },
+    { 4.5f, 0, 3.3f },
+    { 0, 1.2f, 3.3f }
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(single_values); ++i) {
+    gfx::Vector2dF v(single_values[i][0], single_values[i][1]);
+    v.Scale(single_values[i][2]);
+    EXPECT_EQ(v.x(), single_values[i][0] * single_values[i][2]);
+    EXPECT_EQ(v.y(), single_values[i][1] * single_values[i][2]);
+  }
+}
+
+TEST(Vector2dTest, Length) {
+  int int_values[][2] = {
+    { 0, 0 },
+    { 10, 20 },
+    { 20, 10 },
+    { -10, -20 },
+    { -20, 10 },
+    { 10, -20 },
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(int_values); ++i) {
+    int v0 = int_values[i][0];
+    int v1 = int_values[i][1];
+    double length_squared = v0 * v0 + v1 * v1;
+    double length = std::sqrt(length_squared);
+    gfx::Vector2d vector(v0, v1);
+    EXPECT_EQ(static_cast<float>(length_squared), vector.LengthSquared());
+    EXPECT_EQ(static_cast<float>(length), vector.Length());
+  }
+
+  float float_values[][2] = {
+    { 0, 0 },
+    { 10.5f, 20.5f },
+    { 20.5f, 10.5f },
+    { -10.5f, -20.5f },
+    { -20.5f, 10.5f },
+    { 10.5f, -20.5f },
+    // A large vector that fails if the Length function doesn't use
+    // double precision internally.
+    { 1236278317862780234892374893213178027.12122348904204230f,
+      335890352589839028212313231225425134332.38123f },
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(float_values); ++i) {
+    double v0 = float_values[i][0];
+    double v1 = float_values[i][1];
+    double length_squared = v0 * v0 + v1 * v1;
+    double length = std::sqrt(length_squared);
+    gfx::Vector2dF vector(v0, v1);
+    EXPECT_EQ(static_cast<float>(length_squared), vector.LengthSquared());
+    EXPECT_EQ(static_cast<float>(length), vector.Length());
+  }
+}
+
+}  // namespace ui