Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(390)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: ui/gfx/transform_unittest.cc

Issue 7044062: Use SkMatrix44 for the underlying implementation of ui::Transform (Closed) Base URL: http://git.chromium.org/git/chromium.git@trunk
Patch Set: Created 9 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« ui/gfx/transform.cc ('K') | « ui/gfx/transform.cc ('k') | ui/ui_unittests.gypi » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: ui/gfx/transform_unittest.cc
diff --git a/ui/gfx/transform_unittest.cc b/ui/gfx/transform_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..45a7a05c81a7e8cb66010ac054d510e63e82f91a
--- /dev/null
+++ b/ui/gfx/transform_unittest.cc
@@ -0,0 +1,264 @@
+// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
sky 2011/06/09 17:20:29 2011
+// 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 "third_party/eigen/Eigen/Geometry"
+#include "ui/gfx/transform.h"
+#include "ui/gfx/point.h"
+#include <iostream>
+#include <limits>
+
+typedef testing::Test XFormTest;
+
+#ifdef NDEBUG
+TEST(XFormTest, MatrixMultStressTest) {
+ ui::Transform xform;
+ for (int i = 0; i < 1000000; ++i) {
+ xform.ConcatRotate(3.0f);
+ xform.ConcatScale(2.0f, 2.0f);
+ xform.ConcatTranslate(1.0f, 2.0f);
+ xform.ConcatScale(0.5f, 0.5f);
+ }
+}
+#endif
+
+TEST(XFormTest, ConcatTranslate) {
+ static const struct TestCase {
sky 2011/06/09 17:20:29 Why are any of these 'static const'?
+ int x1;
+ int y1;
+ float tx;
+ float ty;
+ int x2;
+ int y2;
+ } test_cases[] = {
+ { 0, 0, 10.0f, 20.0f, 10, 20 },
+ { 0, 0, -10.0f, -20.0f, 0, 0 },
+ { 0, 0, -10.0f, -20.0f, -10, -20 },
+ { 0, 0,
+ std::numeric_limits<float>::quiet_NaN(),
+ std::numeric_limits<float>::quiet_NaN(),
+ 10, 20 },
+ };
+
+ ui::Transform xform;
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+ const TestCase& value = test_cases[i];
+ xform.ConcatTranslate(value.tx, value.ty);
+ gfx::Point p1(value.x1, value.y1);
+ gfx::Point p2(value.x2, value.y2);
+ xform.TransformPoint(&p1);
+ if (value.tx == value.tx &&
+ value.ty == value.ty) {
+ EXPECT_EQ(p1.x(), p2.x());
+ EXPECT_EQ(p1.y(), p2.y());
+ }
+ }
+}
+
+TEST(XFormTest, ConcatScale) {
+ static const struct TestCase {
+ int before;
+ float scale;
+ int after;
+ } test_cases[] = {
+ { 1, 10.0f, 10 },
+ { 1, .1f, 1 },
+ { 1, 100.0f, 100 },
+ { 1, -1.0f, -100 },
+ { 1, std::numeric_limits<float>::quiet_NaN(), 1 }
+ };
+
+ ui::Transform xform;
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+ const TestCase& value = test_cases[i];
+ xform.ConcatScale(value.scale, value.scale);
+ gfx::Point p1(value.before, value.before);
+ gfx::Point p2(value.after, value.after);
+ xform.TransformPoint(&p1);
+ if (value.scale == value.scale) {
+ EXPECT_EQ(p1.x(), p2.x());
+ EXPECT_EQ(p1.y(), p2.y());
+ }
+ }
+}
+
+TEST(XFormTest, ConcatRotate) {
+ static const struct TestCase {
+ int x1;
+ int y1;
+ float degrees;
+ int x2;
+ int y2;
+ } test_cases[] = {
+ { 1, 0, 90.0f, 0, 1 },
+ { 1, 0, -90.0f, 1, 0 },
+ { 1, 0, 90.0f, 0, 1 },
+ { 1, 0, 360.0f, 0, 1 },
+ { 1, 0, 0.0f, 0, 1 },
+ { 1, 0, std::numeric_limits<float>::quiet_NaN(), 1, 0 }
+ };
+
+ ui::Transform xform;
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+ const TestCase& value = test_cases[i];
+ xform.ConcatRotate(value.degrees);
+ gfx::Point p1(value.x1, value.y1);
+ gfx::Point p2(value.x2, value.y2);
+ xform.TransformPoint(&p1);
+ if (value.degrees == value.degrees) {
+ EXPECT_EQ(p1.x(), p2.x());
+ EXPECT_EQ(p1.y(), p2.y());
+ }
+ }
+}
+
+TEST(XFormTest, SetTranslate) {
+ static const struct TestCase {
+ int x1; int y1;
+ float tx; float ty;
+ int x2; int y2;
+ } test_cases[] = {
+ { 0, 0, 10.0f, 20.0f, 10, 20 },
+ { 10, 20, 10.0f, 20.0f, 20, 40 },
+ { 10, 20, 0.0f, 0.0f, 10, 20 },
+ { 0, 0,
+ std::numeric_limits<float>::quiet_NaN(),
+ std::numeric_limits<float>::quiet_NaN(),
+ 0, 0 }
+ };
+
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+ const TestCase& value = test_cases[i];
+ for (int j = -1; j < 2; ++j) {
+ for (int k = 0; k < 3; ++k) {
+ float epsilon = 0.0001f;
+ gfx::Point p0, p1, p2;
+ ui::Transform xform;
+ switch (k) {
+ case 0:
+ p1.SetPoint(value.x1, 0);
+ p2.SetPoint(value.x2, 0);
+ xform.SetTranslateX(value.tx + j * epsilon);
+ break;
+ case 1:
+ p1.SetPoint(0, value.y1);
+ p2.SetPoint(0, value.y2);
+ xform.SetTranslateY(value.ty + j * epsilon);
+ break;
+ case 2:
+ p1.SetPoint(value.x1, value.y1);
+ p2.SetPoint(value.x2, value.y2);
+ xform.SetTranslate(value.tx + j * epsilon,
+ value.ty + j * epsilon);
+ break;
+ }
+ p0 = p1;
+ xform.TransformPoint(&p1);
+ if (value.tx == value.tx &&
+ value.ty == value.ty) {
+ EXPECT_EQ(p1.x(), p2.x());
+ EXPECT_EQ(p1.y(), p2.y());
+ xform.TransformPointReverse(&p1);
+ EXPECT_EQ(p1.x(), p0.x());
+ EXPECT_EQ(p1.y(), p0.y());
+ }
+ }
+ }
+ }
+}
+
+TEST(XFormTest, SetScale) {
+ static const struct TestCase {
+ int before;
+ float s;
+ int after;
+ } test_cases[] = {
+ { 1, 10.0f, 10 },
+ { 1, 1.0f, 1 },
+ { 1, 0.0f, 0 },
+ { 0, 10.0f, 0 },
+ { 1, std::numeric_limits<float>::quiet_NaN(), 0 },
+ };
+
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+ const TestCase& value = test_cases[i];
+ for (int j = -1; j < 2; ++j) {
+ for (int k = 0; k < 3; ++k) {
+ float epsilon = 0.0001f;
+ gfx::Point p0, p1, p2;
+ ui::Transform xform;
+ switch (k) {
+ case 0:
+ p1.SetPoint(value.before, 0);
+ p2.SetPoint(value.after, 0);
+ xform.SetScaleX(value.s + j * epsilon);
+ break;
+ case 1:
+ p1.SetPoint(0, value.before);
+ p2.SetPoint(0, value.after);
+ xform.SetScaleY(value.s + j * epsilon);
+ break;
+ case 2:
+ p1.SetPoint(value.before,
+ value.before);
+ p2.SetPoint(value.after,
+ value.after);
+ xform.SetScale(value.s + j * epsilon,
+ value.s + j * epsilon);
+ break;
+ }
+ p0 = p1;
+ xform.TransformPoint(&p1);
+ if (value.s == value.s) {
+ EXPECT_EQ(p1.x(), p2.x());
+ EXPECT_EQ(p1.y(), p2.y());
+ if (value.s != 0.0f) {
+ xform.TransformPointReverse(&p1);
+ EXPECT_EQ(p1.x(), p0.x());
+ EXPECT_EQ(p1.y(), p0.y());
+ }
+ }
+ }
+ }
+ }
+}
+
+TEST(XFormTest, SetRotate) {
+ static const struct SetRotateCase {
+ int x;
+ int y;
+ float degree;
+ int xprime;
+ int yprime;
+ } set_rotate_cases[] = {
+ { 100, 0, 90.0f, 0, 100 },
+ { 0, 0, 90.0f, 0, 0 },
+ { 0, 100, 90.0f, -100, 0 },
+ { 100, 0, 0.0f, 100, 0 },
+ { 0, 0, 0.0f, 0, 0 },
+ { 0, 0, std::numeric_limits<float>::quiet_NaN(), 0, 0 },
+ { 100, 0, 360.0f, 100, 0 }
+ };
+
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(set_rotate_cases); ++i) {
+ const SetRotateCase& value = set_rotate_cases[i];
+ for (int j = -1; j < 2; ++j) {
+ float epsilon = 0.0001f;
+ gfx::Point pt(value.x, value.y);
+ ui::Transform xform;
+ // should be invariant to small floating point errors.
+ xform.SetRotate(value.degree + j * epsilon);
+ // just want to make sure that we don't crash in the case of NaN.
+ if (value.degree == value.degree) {
+ xform.TransformPoint(&pt);
+ EXPECT_EQ(value.xprime, pt.x());
+ EXPECT_EQ(value.yprime, pt.y());
+ xform.TransformPointReverse(&pt);
+ EXPECT_EQ(pt.x(), value.x);
+ EXPECT_EQ(pt.y(), value.y);
+ }
+ }
+ }
+}
« ui/gfx/transform.cc ('K') | « ui/gfx/transform.cc ('k') | ui/ui_unittests.gypi » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698