diff options
Diffstat (limited to 'gfx/tests/gtest')
26 files changed, 8383 insertions, 0 deletions
diff --git a/gfx/tests/gtest/MockWidget.cpp b/gfx/tests/gtest/MockWidget.cpp new file mode 100644 index 0000000000..696845641e --- /dev/null +++ b/gfx/tests/gtest/MockWidget.cpp @@ -0,0 +1,8 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +#include "MockWidget.h" + +NS_IMPL_ISUPPORTS_INHERITED0(MockWidget, nsBaseWidget) diff --git a/gfx/tests/gtest/MockWidget.h b/gfx/tests/gtest/MockWidget.h new file mode 100644 index 0000000000..a8cbaf7702 --- /dev/null +++ b/gfx/tests/gtest/MockWidget.h @@ -0,0 +1,96 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef GTEST_MOCKWIDGET_H +#define GTEST_MOCKWIDGET_H + +#include "mozilla/gfx/Point.h" +#include "mozilla/widget/InProcessCompositorWidget.h" +#include "nsBaseWidget.h" +#include "GLContext.h" +#include "GLContextProvider.h" + +using mozilla::gl::CreateContextFlags; +using mozilla::gl::GLContext; +using mozilla::gl::GLContextProvider; + +using mozilla::gfx::IntSize; + +class MockWidget : public nsBaseWidget { + public: + MockWidget() : mCompWidth(0), mCompHeight(0) {} + MockWidget(int aWidth, int aHeight) + : mCompWidth(aWidth), mCompHeight(aHeight) {} + NS_DECL_ISUPPORTS_INHERITED + + virtual LayoutDeviceIntRect GetClientBounds() override { + return LayoutDeviceIntRect(0, 0, mCompWidth, mCompHeight); + } + virtual LayoutDeviceIntRect GetBounds() override { return GetClientBounds(); } + + void* GetNativeData(uint32_t aDataType) override { + if (aDataType == NS_NATIVE_OPENGL_CONTEXT) { + nsCString discardFailureId; + RefPtr<GLContext> context = GLContextProvider::CreateHeadless( + {CreateContextFlags::REQUIRE_COMPAT_PROFILE}, &discardFailureId); + if (!context) { + return nullptr; + } + if (!context->CreateOffscreenDefaultFb({mCompWidth, mCompHeight})) { + return nullptr; + } + return context.forget().take(); + } + return nullptr; + } + + virtual nsresult Create(nsIWidget* aParent, nsNativeWidget aNativeParent, + const LayoutDeviceIntRect& aRect, + InitData* aInitData = nullptr) override { + return NS_OK; + } + virtual nsresult Create(nsIWidget* aParent, nsNativeWidget aNativeParent, + const DesktopIntRect& aRect, + InitData* aInitData = nullptr) override { + return NS_OK; + } + virtual void Show(bool aState) override {} + virtual bool IsVisible() const override { return true; } + virtual void Move(double aX, double aY) override {} + virtual void Resize(double aWidth, double aHeight, bool aRepaint) override {} + virtual void Resize(double aX, double aY, double aWidth, double aHeight, + bool aRepaint) override {} + + virtual void Enable(bool aState) override {} + virtual bool IsEnabled() const override { return true; } + + virtual nsSizeMode SizeMode() override { return mSizeMode; } + virtual void SetSizeMode(nsSizeMode aMode) override { mSizeMode = aMode; } + + virtual void SetFocus(Raise, mozilla::dom::CallerType aCallerType) override {} + virtual void Invalidate(const LayoutDeviceIntRect& aRect) override {} + virtual nsresult SetTitle(const nsAString& title) override { return NS_OK; } + virtual LayoutDeviceIntPoint WidgetToScreenOffset() override { + return LayoutDeviceIntPoint(0, 0); + } + virtual nsresult DispatchEvent(mozilla::WidgetGUIEvent* aEvent, + nsEventStatus& aStatus) override { + return NS_OK; + } + virtual void SetInputContext(const InputContext& aContext, + const InputContextAction& aAction) override {} + virtual InputContext GetInputContext() override { abort(); } + + private: + ~MockWidget() = default; + + nsSizeMode mSizeMode = nsSizeMode_Normal; + + int mCompWidth; + int mCompHeight; +}; + +#endif diff --git a/gfx/tests/gtest/PolygonTestUtils.cpp b/gfx/tests/gtest/PolygonTestUtils.cpp new file mode 100644 index 0000000000..04a2f47498 --- /dev/null +++ b/gfx/tests/gtest/PolygonTestUtils.cpp @@ -0,0 +1,163 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "PolygonTestUtils.h" + +#include <cmath> + +#include "Point.h" +#include "Triangle.h" + +typedef mozilla::gfx::Polygon MozPolygon; + +using mozilla::gfx::Point; +using mozilla::gfx::Point4D; +using mozilla::gfx::Triangle; + +namespace mozilla { +namespace gfx { + +const float kEpsilon = 0.001f; + +// Compares two points while allowing some numerical inaccuracy. +bool FuzzyEquals(const Point4D& lhs, const Point4D& rhs) { + const auto d = lhs - rhs; + + return std::abs(d.x) < kEpsilon && std::abs(d.y) < kEpsilon && + std::abs(d.z) < kEpsilon && std::abs(d.w) < kEpsilon; +} + +bool FuzzyEquals(const Point3D& lhs, const Point3D& rhs) { + const auto d = lhs - rhs; + + return std::abs(d.x) < kEpsilon && std::abs(d.y) < kEpsilon && + std::abs(d.z) < kEpsilon; +} + +bool FuzzyEquals(const Point& lhs, const Point& rhs) { + const auto d = lhs - rhs; + + return std::abs(d.x) < kEpsilon && std::abs(d.y) < kEpsilon; +} + +bool operator==(const Triangle& lhs, const Triangle& rhs) { + return FuzzyEquals(lhs.p1, rhs.p1) && FuzzyEquals(lhs.p2, rhs.p2) && + FuzzyEquals(lhs.p3, rhs.p3); +} + +// Compares the points of two polygons and ensures +// that the points are in the same winding order. +bool operator==(const MozPolygon& lhs, const MozPolygon& rhs) { + const auto& left = lhs.GetPoints(); + const auto& right = rhs.GetPoints(); + + // Polygons do not have the same amount of points. + if (left.Length() != right.Length()) { + return false; + } + + const size_t pointCount = left.Length(); + + // Find the first vertex of the first polygon from the second polygon. + // This assumes that the polygons do not contain duplicate vertices. + int start = -1; + for (size_t i = 0; i < pointCount; ++i) { + if (FuzzyEquals(left[0], right[i])) { + start = i; + break; + } + } + + // Found at least one different vertex. + if (start == -1) { + return false; + } + + // Verify that the polygons have the same points. + for (size_t i = 0; i < pointCount; ++i) { + size_t j = (start + i) % pointCount; + + if (!FuzzyEquals(left[i], right[j])) { + return false; + } + } + + return true; +} + +} // namespace gfx +} // namespace mozilla + +TEST(PolygonTestUtils, TestSanity) +{ + EXPECT_TRUE(FuzzyEquals(Point4D(0.0f, 0.0f, 0.0f, 1.0f), + Point4D(0.0f, 0.0f, 0.0f, 1.0f))); + + EXPECT_TRUE(FuzzyEquals(Point4D(0.0f, 0.0f, 0.0f, 1.0f), + Point4D(0.00001f, 0.00001f, 0.00001f, 1.0f))); + + EXPECT_TRUE(FuzzyEquals(Point4D(0.00001f, 0.00001f, 0.00001f, 1.0f), + Point4D(0.0f, 0.0f, 0.0f, 1.0f))); + + EXPECT_FALSE(FuzzyEquals(Point4D(0.0f, 0.0f, 0.0f, 1.0f), + Point4D(0.01f, 0.01f, 0.01f, 1.0f))); + + EXPECT_FALSE(FuzzyEquals(Point4D(0.01f, 0.01f, 0.01f, 1.0f), + Point4D(0.0f, 0.0f, 0.0f, 1.0f))); + + MozPolygon p1{ + Point4D(0.0f, 0.0f, 1.0f, 1.0f), Point4D(1.0f, 0.0f, 1.0f, 1.0f), + Point4D(1.0f, 1.0f, 1.0f, 1.0f), Point4D(0.0f, 1.0f, 1.0f, 1.0f)}; + + // Same points as above shifted forward by one position. + MozPolygon shifted{ + Point4D(0.0f, 1.0f, 1.0f, 1.0f), Point4D(0.0f, 0.0f, 1.0f, 1.0f), + Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f)}; + + MozPolygon p2{Point4D(0.00001f, 0.00001f, 1.00001f, 1.0f), + Point4D(1.00001f, 0.00001f, 1.00001f, 1.0f), + Point4D(1.00001f, 1.00001f, 1.00001f, 1.0f), + Point4D(0.00001f, 1.00001f, 1.00001f, 1.0f)}; + + MozPolygon p3{ + Point4D(0.01f, 0.01f, 1.01f, 1.0f), Point4D(1.01f, 0.01f, 1.01f, 1.0f), + Point4D(1.01f, 1.01f, 1.01f, 1.0f), Point4D(0.01f, 1.01f, 1.01f, 1.0f)}; + + // Trivial equals + EXPECT_TRUE(p1 == p1); + EXPECT_TRUE(p2 == p2); + EXPECT_TRUE(p3 == p3); + EXPECT_TRUE(shifted == shifted); + + // Polygons with the same point order + EXPECT_TRUE(p1 == p2); + EXPECT_TRUE(p1 == shifted); + + // Polygons containing different points + EXPECT_FALSE(p1 == p3); + EXPECT_FALSE(p2 == p3); + EXPECT_FALSE(shifted == p3); + + const nsTArray<Triangle> t1{ + Triangle(Point(0.0f, 0.0f), Point(0.0f, 1.0f), Point(1.0f, 1.0f))}; + + const nsTArray<Triangle> t2{ + Triangle(Point(0.0f, 0.0f), Point(1.0f, 1.0f), Point(1.0f, 0.0f))}; + + const nsTArray<Triangle> t3{Triangle(Point(0.00001f, 0.00001f), + Point(0.00001f, 1.00001f), + Point(1.00001f, 1.00001f))}; + + EXPECT_TRUE(t1[0] == t1[0]); + EXPECT_TRUE(t2[0] == t2[0]); + EXPECT_TRUE(t3[0] == t1[0]); + + EXPECT_FALSE(t1[0] == t2[0]); + EXPECT_FALSE(t2[0] == t3[0]); + + AssertArrayEQ(t1, t1); + AssertArrayEQ(t2, t2); +} diff --git a/gfx/tests/gtest/PolygonTestUtils.h b/gfx/tests/gtest/PolygonTestUtils.h new file mode 100644 index 0000000000..e860b6a8d1 --- /dev/null +++ b/gfx/tests/gtest/PolygonTestUtils.h @@ -0,0 +1,40 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef GFX_TEST_POLYGONUTILS_H +#define GFX_TEST_POLYGONUTILS_H + +#include "gtest/gtest.h" + +#include "nsTArray.h" +#include "Point.h" +#include "Polygon.h" +#include "Triangle.h" + +namespace mozilla { +namespace gfx { + +bool FuzzyEquals(const Point4D& lhs, const Point4D& rhs); +bool FuzzyEquals(const Point3D& lhs, const Point3D& rhs); +bool FuzzyEquals(const Point& lhs, const Point& rhs); + +bool operator==(const Triangle& lhs, const Triangle& rhs); +bool operator==(const Polygon& lhs, const Polygon& rhs); + +// Compares two arrays with the equality operator. +template <typename T> +void AssertArrayEQ(const nsTArray<T>& rhs, const nsTArray<T>& lhs) { + ASSERT_EQ(lhs.Length(), rhs.Length()); + + for (size_t i = 0; i < lhs.Length(); ++i) { + EXPECT_TRUE(lhs[i] == rhs[i]); + } +} + +} // namespace gfx +} // namespace mozilla + +#endif /* GFX_TEST_POLYGONUTILS_H */ diff --git a/gfx/tests/gtest/TestArena.cpp b/gfx/tests/gtest/TestArena.cpp new file mode 100644 index 0000000000..7f9aad6592 --- /dev/null +++ b/gfx/tests/gtest/TestArena.cpp @@ -0,0 +1,185 @@ +/* vim:set ts=2 sw=2 sts=2 et: */ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +#include "gtest/gtest.h" +#include "gmock/gmock.h" + +#include "mozilla/gfx/IterableArena.h" +#include <string> + +using namespace mozilla; +using namespace mozilla::gfx; + +#ifdef A +# undef A +#endif + +#ifdef B +# undef B +#endif + +// to avoid having symbols that collide easily like A and B in the global +// namespace +namespace test_arena { + +class A; +class B; + +class Base { + public: + virtual ~Base() = default; + virtual A* AsA() { return nullptr; } + virtual B* AsB() { return nullptr; } +}; + +static int sDtorItemA = 0; +static int sDtorItemB = 0; + +class A : public Base { + public: + virtual A* AsA() override { return this; } + + explicit A(uint64_t val) : mVal(val) {} + ~A() { ++sDtorItemA; } + + uint64_t mVal; +}; + +class B : public Base { + public: + virtual B* AsB() override { return this; } + + explicit B(const std::string& str) : mVal(str) {} + ~B() { ++sDtorItemB; } + + std::string mVal; +}; + +struct BigStruct { + uint64_t mVal; + uint8_t data[120]; + + explicit BigStruct(uint64_t val) : mVal(val) {} +}; + +static void TestArenaAlloc(IterableArena::ArenaType aType) { + sDtorItemA = 0; + sDtorItemB = 0; + IterableArena arena(aType, 256); + + // An empty arena has no items to iterate over. + { + int iterations = 0; + arena.ForEach([&](void* item) { iterations++; }); + ASSERT_EQ(iterations, 0); + } + + auto a1 = arena.Alloc<A>(42); + auto b1 = arena.Alloc<B>("Obladi oblada"); + auto a2 = arena.Alloc<A>(1337); + auto b2 = arena.Alloc<B>("Yellow submarine"); + auto b3 = arena.Alloc<B>("She's got a ticket to ride"); + + // Alloc returns a non-negative offset if the allocation succeeded. + ASSERT_TRUE(a1 >= 0); + ASSERT_TRUE(a2 >= 0); + ASSERT_TRUE(b1 >= 0); + ASSERT_TRUE(b2 >= 0); + ASSERT_TRUE(b3 >= 0); + + ASSERT_TRUE(arena.GetStorage(a1) != nullptr); + ASSERT_TRUE(arena.GetStorage(a2) != nullptr); + ASSERT_TRUE(arena.GetStorage(b1) != nullptr); + ASSERT_TRUE(arena.GetStorage(b2) != nullptr); + ASSERT_TRUE(arena.GetStorage(b3) != nullptr); + + ASSERT_TRUE(((Base*)arena.GetStorage(a1))->AsA() != nullptr); + ASSERT_TRUE(((Base*)arena.GetStorage(a2))->AsA() != nullptr); + + ASSERT_TRUE(((Base*)arena.GetStorage(b1))->AsB() != nullptr); + ASSERT_TRUE(((Base*)arena.GetStorage(b2))->AsB() != nullptr); + ASSERT_TRUE(((Base*)arena.GetStorage(b3))->AsB() != nullptr); + + ASSERT_EQ(((Base*)arena.GetStorage(a1))->AsA()->mVal, (uint64_t)42); + ASSERT_EQ(((Base*)arena.GetStorage(a2))->AsA()->mVal, (uint64_t)1337); + + ASSERT_EQ(((Base*)arena.GetStorage(b1))->AsB()->mVal, + std::string("Obladi oblada")); + ASSERT_EQ(((Base*)arena.GetStorage(b2))->AsB()->mVal, + std::string("Yellow submarine")); + ASSERT_EQ(((Base*)arena.GetStorage(b3))->AsB()->mVal, + std::string("She's got a ticket to ride")); + + { + int iterations = 0; + arena.ForEach([&](void* item) { iterations++; }); + ASSERT_EQ(iterations, 5); + } + + // Typically, running the destructors of the elements in the arena will is + // done manually like this: + arena.ForEach([](void* item) { ((Base*)item)->~Base(); }); + arena.Clear(); + ASSERT_EQ(sDtorItemA, 2); + ASSERT_EQ(sDtorItemB, 3); + + // An empty arena has no items to iterate over (we just cleared it). + { + int iterations = 0; + arena.ForEach([&](void* item) { iterations++; }); + ASSERT_EQ(iterations, 0); + } +} + +static void TestArenaLimit(IterableArena::ArenaType aType, + bool aShouldReachLimit) { + IterableArena arena(aType, 128); + + // A non-growable arena should return a negative offset when running out + // of space, without crashing. + // We should not run out of space with a growable arena (unless the os is + // running out of memory but this isn't expected for this test). + bool reachedLimit = false; + for (int i = 0; i < 100; ++i) { + auto offset = arena.Alloc<A>(42); + if (offset < 0) { + reachedLimit = true; + break; + } + } + ASSERT_EQ(reachedLimit, aShouldReachLimit); +} + +} // namespace test_arena + +using namespace test_arena; + +TEST(Moz2D, FixedArena) +{ + TestArenaAlloc(IterableArena::FIXED_SIZE); + TestArenaLimit(IterableArena::FIXED_SIZE, true); +} + +TEST(Moz2D, GrowableArena) +{ + TestArenaAlloc(IterableArena::GROWABLE); + TestArenaLimit(IterableArena::GROWABLE, false); + + IterableArena arena(IterableArena::GROWABLE, 16); + // sizeof(BigStruct) is more than twice the initial capacity, make sure that + // this doesn't blow everything up, since the arena doubles its storage size + // each time it grows (until it finds a size that fits). + auto a = arena.Alloc<BigStruct>(1); + auto b = arena.Alloc<BigStruct>(2); + auto c = arena.Alloc<BigStruct>(3); + + // Offsets should also still point to the appropriate values after + // reallocation. + ASSERT_EQ(((BigStruct*)arena.GetStorage(a))->mVal, (uint64_t)1); + ASSERT_EQ(((BigStruct*)arena.GetStorage(b))->mVal, (uint64_t)2); + ASSERT_EQ(((BigStruct*)arena.GetStorage(c))->mVal, (uint64_t)3); + + arena.Clear(); +} diff --git a/gfx/tests/gtest/TestArrayView.cpp b/gfx/tests/gtest/TestArrayView.cpp new file mode 100644 index 0000000000..209f286845 --- /dev/null +++ b/gfx/tests/gtest/TestArrayView.cpp @@ -0,0 +1,20 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +#include <limits> + +#include "gtest/gtest.h" + +#include "mozilla/ArrayView.h" + +using namespace mozilla::gfx; + +TEST(Gfx, ArrayView) +{ + nsTArray<int> p = {5, 6}; + ArrayView<int> pv(p); + ASSERT_EQ(pv[1], 6); + ASSERT_EQ(*pv.Data(), 5); +} diff --git a/gfx/tests/gtest/TestBSPTree.cpp b/gfx/tests/gtest/TestBSPTree.cpp new file mode 100644 index 0000000000..8601169a03 --- /dev/null +++ b/gfx/tests/gtest/TestBSPTree.cpp @@ -0,0 +1,694 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" + +#include "BSPTree.h" +#include "Polygon.h" +#include "PolygonTestUtils.h" + +#include <deque> +#include <list> + +using namespace mozilla::gfx; +using namespace mozilla::layers; +typedef mozilla::gfx::Polygon MozPolygon; + +namespace { + +static void RunTest(std::deque<MozPolygon> aPolygons, + std::deque<MozPolygon> aExpected) { + std::list<TestPolygon> layers; + for (MozPolygon& polygon : aPolygons) { + layers.push_back(TestPolygon(nullptr, std::move(polygon))); + } + + const BSPTree tree(layers); + const nsTArray<TestPolygon> order = tree.GetDrawOrder(); + + EXPECT_EQ(aExpected.size(), order.Length()); + + for (size_t i = 0; i < order.Length(); ++i) { + EXPECT_TRUE(aExpected[i] == *order[i].geometry); + } +} + +} // namespace + +TEST(BSPTree, SameNode) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{ + Point4D(0.0f, 0.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 0.0f, 1.0f), + Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(0.0f, 1.0f, 0.0f, 1.0f)}, + MozPolygon{ + Point4D(0.0f, 0.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 0.0f, 1.0f), + Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(0.0f, 1.0f, 0.0f, 1.0f)}}; + + ::RunTest(polygons, polygons); +} + +TEST(BSPTree, OneChild) +{ + const MozPolygon p1{ + Point4D(0.0f, 0.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 0.0f, 1.0f), + Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(0.0f, 1.0f, 0.0f, 1.0f)}; + + const MozPolygon p2{ + Point4D(0.0f, 0.0f, 1.0f, 1.0f), Point4D(1.0f, 0.0f, 1.0f, 1.0f), + Point4D(1.0f, 1.0f, 1.0f, 1.0f), Point4D(0.0f, 1.0f, 1.0f, 1.0f)}; + + ::RunTest({p1, p2}, {p1, p2}); + ::RunTest({p2, p1}, {p1, p2}); +} + +TEST(BSPTree, SharedEdge1) +{ + MozPolygon p1{ + Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 0.0f, 1.0f, 1.0f), + Point4D(0.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f)}; + + MozPolygon p2{ + Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f), + Point4D(2.0f, 2.0f, 1.0f, 1.0f), Point4D(2.0f, 0.0f, 1.0f, 1.0f)}; + + ::RunTest({p1, p2}, {p1, p2}); +} + +TEST(BSPTree, SharedEdge2) +{ + MozPolygon p1{ + Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 0.0f, 1.0f, 1.0f), + Point4D(0.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f)}; + + MozPolygon p2{ + Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f), + Point4D(2.0f, 2.0f, 0.0f, 1.0f), Point4D(2.0f, 0.0f, 0.0f, 1.0f)}; + + ::RunTest({p1, p2}, {p2, p1}); +} + +TEST(BSPTree, SplitSharedEdge) +{ + MozPolygon p1{ + Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 0.0f, 1.0f, 1.0f), + Point4D(0.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f)}; + + MozPolygon p2{ + Point4D(1.0f, 0.0f, 2.0f, 1.0f), Point4D(1.0f, 1.0f, 2.0f, 1.0f), + Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 0.0f, 1.0f)}; + + const std::deque<MozPolygon> expected{ + MozPolygon{ + Point4D(1.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 0.0f, 1.0f), + Point4D(1.0f, 0.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 1.0f, 1.0f)}, + MozPolygon{ + Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 0.0f, 1.0f, 1.0f), + Point4D(0.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f)}, + MozPolygon{ + Point4D(1.0f, 0.0f, 2.0f, 1.0f), Point4D(1.0f, 1.0f, 2.0f, 1.0f), + Point4D(1.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 0.0f, 1.0f, 1.0f)}}; + + ::RunTest({p1, p2}, expected); +} + +TEST(BSPTree, SplitSimple1) +{ + MozPolygon p1{ + Point4D(0.0f, 0.0f, 1.0f, 1.0f), Point4D(1.0f, 0.0f, 1.0f, 1.0f), + Point4D(1.0f, 1.0f, 1.0f, 1.0f), Point4D(0.0f, 1.0f, 1.0f, 1.0f)}; + + MozPolygon p2{ + Point4D(0.0f, 0.0f, 2.0f, 1.0f), Point4D(1.0f, 0.0f, 2.0f, 1.0f), + Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(0.0f, 1.0f, 0.0f, 1.0f)}; + + const std::deque<MozPolygon> expected{ + MozPolygon{ + Point4D(0.0f, 1.0f, 0.0f, 1.0f), Point4D(0.0f, 0.5f, 1.0f, 1.0f), + Point4D(1.0f, 0.5f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 0.0f, 1.0f)}, + p1, + MozPolygon{ + Point4D(0.0f, 0.0f, 2.0f, 1.0f), Point4D(1.0f, 0.0f, 2.0f, 1.0f), + Point4D(1.0f, 0.5f, 1.0f, 1.0f), Point4D(0.0f, 0.5f, 1.0f, 1.0f)}}; + + ::RunTest({p1, p2}, expected); +} + +TEST(BSPTree, SplitSimple2) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-5.00000f, -5.00000f, 0.00000f, 1.0f), + Point4D(-5.00000f, 5.00000f, 0.00000f, 1.0f), + Point4D(5.00000f, 5.00000f, 0.00000f, 1.0f), + Point4D(5.00000f, -5.00000f, 0.00000f, 1.0f)}, + MozPolygon{Point4D(0.00000f, -5.00000f, -5.00000f, 1.0f), + Point4D(0.00000f, 5.00000f, -5.00000f, 1.0f), + Point4D(0.00000f, 5.00000f, 5.00000f, 1.0f), + Point4D(0.00000f, -5.00000f, 5.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(0.00000f, -5.00000f, 0.00000f, 1.0f), + Point4D(0.00000f, -5.00000f, -5.00000f, 1.0f), + Point4D(0.00000f, 5.00000f, -5.00000f, 1.0f), + Point4D(0.00000f, 5.00000f, 0.00000f, 1.0f)}, + MozPolygon{Point4D(-5.00000f, -5.00000f, 0.00000f, 1.0f), + Point4D(-5.00000f, 5.00000f, 0.00000f, 1.0f), + Point4D(5.00000f, 5.00000f, 0.00000f, 1.0f), + Point4D(5.00000f, -5.00000f, 0.00000f, 1.0f)}, + MozPolygon{Point4D(0.00000f, 5.00000f, 0.00000f, 1.0f), + Point4D(0.00000f, 5.00000f, 5.00000f, 1.0f), + Point4D(0.00000f, -5.00000f, 5.00000f, 1.0f), + Point4D(0.00000f, -5.00000f, 0.00000f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, NoSplit1) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(0.00000f, 10.00000f, 0.00000f, 1.0f), + Point4D(0.00000f, 0.00000f, 0.00000f, 1.0f), + Point4D(10.00000f, 0.00000f, 0.00000f, 1.0f), + Point4D(10.00000f, 10.00000f, 0.00000f, 1.0f)}, + MozPolygon{Point4D(0.00000f, 10.00000f, -5.00000f, 1.0f), + Point4D(0.00000f, 0.00000f, -5.00000f, 1.0f), + Point4D(10.00000f, 0.00000f, -5.00000f, 1.0f), + Point4D(10.00000f, 10.00000f, -5.00000f, 1.0f)}, + MozPolygon{Point4D(0.00000f, 10.00000f, 5.00000f, 1.0f), + Point4D(0.00000f, 0.00000f, 5.00000f, 1.0f), + Point4D(10.00000f, 0.00000f, 5.00000f, 1.0f), + Point4D(10.00000f, 10.00000f, 5.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(0.00000f, 10.00000f, -5.00000f, 1.0f), + Point4D(0.00000f, 0.00000f, -5.00000f, 1.0f), + Point4D(10.00000f, 0.00000f, -5.00000f, 1.0f), + Point4D(10.00000f, 10.00000f, -5.00000f, 1.0f)}, + MozPolygon{Point4D(0.00000f, 10.00000f, 0.00000f, 1.0f), + Point4D(0.00000f, 0.00000f, 0.00000f, 1.0f), + Point4D(10.00000f, 0.00000f, 0.00000f, 1.0f), + Point4D(10.00000f, 10.00000f, 0.00000f, 1.0f)}, + MozPolygon{Point4D(0.00000f, 10.00000f, 5.00000f, 1.0f), + Point4D(0.00000f, 0.00000f, 5.00000f, 1.0f), + Point4D(10.00000f, 0.00000f, 5.00000f, 1.0f), + Point4D(10.00000f, 10.00000f, 5.00000f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, NoSplit2) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-5.00000f, -5.00000f, 0.00000f, 1.0f), + Point4D(-5.00000f, 5.00000f, 0.00000f, 1.0f), + Point4D(5.00000f, 5.00000f, 0.00000f, 1.0f), + Point4D(5.00000f, -5.00000f, 0.00000f, 1.0f)}, + MozPolygon{Point4D(0.00000f, 5.00000f, -15.00000f, 1.0f), + Point4D(0.00000f, -5.00000f, -15.00000f, 1.0f), + Point4D(0.00000f, -5.00000f, -10.00000f, 1.0f), + Point4D(0.00000f, 5.00000f, -10.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(0.00000f, 5.00000f, -15.00000f, 1.0f), + Point4D(0.00000f, -5.00000f, -15.00000f, 1.0f), + Point4D(0.00000f, -5.00000f, -10.00000f, 1.0f), + Point4D(0.00000f, 5.00000f, -10.00000f, 1.0f)}, + MozPolygon{Point4D(-5.00000f, -5.00000f, 0.00000f, 1.0f), + Point4D(-5.00000f, 5.00000f, 0.00000f, 1.0f), + Point4D(5.00000f, 5.00000f, 0.00000f, 1.0f), + Point4D(5.00000f, -5.00000f, 0.00000f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate0degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, 2.00000f, 2.00000f, 1.0f), + Point4D(-0.00000f, -2.00000f, 2.00000f, 1.0f), + Point4D(0.00010f, -2.00000f, -2.00000f, 1.0f), + Point4D(0.00010f, 2.00000f, -2.00000f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.00000f, 2.00000f, 1.0f), + Point4D(2.00000f, -0.00000f, -2.00000f, 1.0f), + Point4D(-2.00000f, 0.00000f, -2.00000f, 1.0f), + Point4D(-2.00000f, 0.00010f, 2.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(2.00000f, 0.00000f, 2.00000f, 1.0f), + Point4D(2.00000f, -0.00000f, -2.00000f, 1.0f), + Point4D(-2.00000f, 0.00000f, -2.00000f, 1.0f), + Point4D(-2.00000f, 0.00010f, 2.00000f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, 2.00000f, 2.00000f, 1.0f), + Point4D(-0.00000f, -2.00000f, 2.00000f, 1.0f), + Point4D(0.00010f, -2.00000f, -2.00000f, 1.0f), + Point4D(0.00010f, 2.00000f, -2.00000f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate20degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f), + Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f), + Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f), + Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)}, + MozPolygon{Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f), + Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f), + Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f), + Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate40degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, -0.73200f, 2.73210f, 1.0f), + Point4D(-0.00000f, -2.73200f, -0.73200f, 1.0f), + Point4D(0.00010f, 0.73210f, -2.73200f, 1.0f), + Point4D(0.00010f, 2.73210f, 0.73210f, 1.0f)}, + MozPolygon{Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, -0.73200f, 2.73210f, 1.0f), + Point4D(-0.00000f, -2.73200f, -0.73200f, 1.0f), + Point4D(0.00010f, 0.73210f, -2.73200f, 1.0f), + Point4D(0.00010f, 2.73210f, 0.73210f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate60degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, -2.73200f, 0.73210f, 1.0f), + Point4D(-0.00000f, -0.73200f, -2.73200f, 1.0f), + Point4D(0.00010f, 2.73210f, -0.73200f, 1.0f), + Point4D(0.00010f, 0.73210f, 2.73210f, 1.0f)}, + MozPolygon{Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(-2.00000f, -1.73200f, -1.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(-2.00000f, 1.26793f, 0.73210f, 1.0f), + Point4D(-2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(2.00000f, 1.26793f, 0.73210f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, -2.73200f, 0.73210f, 1.0f), + Point4D(-0.00000f, -0.73200f, -2.73200f, 1.0f), + Point4D(0.00010f, 2.73210f, -0.73200f, 1.0f), + Point4D(0.00010f, 0.73210f, 2.73210f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 1.26793f, 0.73210f, 1.0f), + Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(-2.00000f, 1.26793f, 0.73210f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate80degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, -1.19530f, -2.56340f, 1.0f), + Point4D(-0.00000f, 2.56350f, -1.19530f, 1.0f), + Point4D(0.00010f, 1.19540f, 2.56350f, 1.0f), + Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(-0.00000f, -1.19530f, -2.56340f, 1.0f), + Point4D(-0.00000f, 2.56350f, -1.19530f, 1.0f), + Point4D(0.00010f, 1.19540f, 2.56350f, 1.0f), + Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate100degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, 2.73210f, -0.73200f, 1.0f), + Point4D(-0.00000f, 0.73210f, 2.73210f, 1.0f), + Point4D(0.00010f, -2.73200f, 0.73210f, 1.0f), + Point4D(0.00010f, -0.73200f, -2.73200f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(-2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(2.00000f, -1.26783f, -0.73200f, 1.0f), + Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(-2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(-2.00000f, -1.26783f, -0.73200f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, 2.73210f, -0.73200f, 1.0f), + Point4D(-0.00000f, 0.73210f, 2.73210f, 1.0f), + Point4D(0.00010f, -2.73200f, 0.73210f, 1.0f), + Point4D(0.00010f, -0.73200f, -2.73200f, 1.0f)}, + MozPolygon{Point4D(-2.00000f, -1.26783f, -0.73200f, 1.0f), + Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(2.00000f, -1.26783f, -0.73200f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate120degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, -0.73200f, 2.73210f, 1.0f), + Point4D(-0.00000f, -2.73200f, -0.73200f, 1.0f), + Point4D(0.00010f, 0.73210f, -2.73200f, 1.0f), + Point4D(0.00010f, 2.73210f, 0.73210f, 1.0f)}, + MozPolygon{Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, -0.73200f, 2.73210f, 1.0f), + Point4D(-0.00000f, -2.73200f, -0.73200f, 1.0f), + Point4D(0.00010f, 0.73210f, -2.73200f, 1.0f), + Point4D(0.00010f, 2.73210f, 0.73210f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate140degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, -1.19530f, -2.56340f, 1.0f), + Point4D(-0.00000f, 2.56350f, -1.19530f, 1.0f), + Point4D(0.00010f, 1.19540f, 2.56350f, 1.0f), + Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(-0.00000f, -1.19530f, -2.56340f, 1.0f), + Point4D(-0.00000f, 2.56350f, -1.19530f, 1.0f), + Point4D(0.00010f, 1.19540f, 2.56350f, 1.0f), + Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate160degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, 2.00000f, 2.00000f, 1.0f), + Point4D(-0.00000f, -2.00000f, 2.00000f, 1.0f), + Point4D(0.00010f, -2.00000f, -2.00000f, 1.0f), + Point4D(0.00010f, 2.00000f, -2.00000f, 1.0f)}, + MozPolygon{Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f), + Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f), + Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f), + Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f), + Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, 2.00000f, 2.00000f, 1.0f), + Point4D(-0.00000f, -2.00000f, 2.00000f, 1.0f), + Point4D(0.00010f, -2.00000f, -2.00000f, 1.0f), + Point4D(0.00010f, 2.00000f, -2.00000f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate180degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, -2.00000f, -2.00000f, 1.0f), + Point4D(-0.00000f, 2.00000f, -2.00000f, 1.0f), + Point4D(0.00010f, 2.00000f, 2.00000f, 1.0f), + Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f), + Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(-0.00000f, -2.00000f, -2.00000f, 1.0f), + Point4D(-0.00000f, 2.00000f, -2.00000f, 1.0f), + Point4D(0.00010f, 2.00000f, 2.00000f, 1.0f), + Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f), + Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate200degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f), + Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f), + Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f), + Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)}, + MozPolygon{Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f), + Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f), + Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f), + Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate220degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, 0.73210f, -2.73200f, 1.0f), + Point4D(-0.00000f, 2.73210f, 0.73210f, 1.0f), + Point4D(0.00010f, -0.73200f, 2.73210f, 1.0f), + Point4D(0.00010f, -2.73200f, -0.73200f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(-0.00000f, 0.73210f, -2.73200f, 1.0f), + Point4D(-0.00000f, 2.73210f, 0.73210f, 1.0f), + Point4D(0.00010f, -0.73200f, 2.73210f, 1.0f), + Point4D(0.00010f, -2.73200f, -0.73200f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate240degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, -2.73200f, 0.73210f, 1.0f), + Point4D(-0.00000f, -0.73200f, -2.73200f, 1.0f), + Point4D(0.00010f, 2.73210f, -0.73200f, 1.0f), + Point4D(0.00010f, 0.73210f, 2.73210f, 1.0f)}, + MozPolygon{Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(-2.00000f, -1.73200f, -1.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(-2.00000f, 1.26793f, 0.73210f, 1.0f), + Point4D(-2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(2.00000f, 1.26793f, 0.73210f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, -2.73200f, 0.73210f, 1.0f), + Point4D(-0.00000f, -0.73200f, -2.73200f, 1.0f), + Point4D(0.00010f, 2.73210f, -0.73200f, 1.0f), + Point4D(0.00010f, 0.73210f, 2.73210f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 1.26793f, 0.73210f, 1.0f), + Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(-2.00000f, 1.26793f, 0.73210f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate260degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f), + Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f), + Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f), + Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)}, + MozPolygon{Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f), + Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f), + Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f), + Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate280degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, 2.73210f, -0.73200f, 1.0f), + Point4D(-0.00000f, 0.73210f, 2.73210f, 1.0f), + Point4D(0.00010f, -2.73200f, 0.73210f, 1.0f), + Point4D(0.00010f, -0.73200f, -2.73200f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(-2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(2.00000f, -1.26783f, -0.73200f, 1.0f), + Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(-2.00000f, -1.73200f, -1.00000f, 1.0f), + Point4D(-2.00000f, -1.26783f, -0.73200f, 1.0f)}, + MozPolygon{Point4D(-0.00000f, 2.73210f, -0.73200f, 1.0f), + Point4D(-0.00000f, 0.73210f, 2.73210f, 1.0f), + Point4D(0.00010f, -2.73200f, 0.73210f, 1.0f), + Point4D(0.00010f, -0.73200f, -2.73200f, 1.0f)}, + MozPolygon{Point4D(-2.00000f, -1.26783f, -0.73200f, 1.0f), + Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f), + Point4D(2.00000f, -1.26783f, -0.73200f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate300degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, 0.73210f, -2.73200f, 1.0f), + Point4D(-0.00000f, 2.73210f, 0.73210f, 1.0f), + Point4D(0.00010f, -0.73200f, 2.73210f, 1.0f), + Point4D(0.00010f, -2.73200f, -0.73200f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(-0.00000f, 0.73210f, -2.73200f, 1.0f), + Point4D(-0.00000f, 2.73210f, 0.73210f, 1.0f), + Point4D(0.00010f, -0.73200f, 2.73210f, 1.0f), + Point4D(0.00010f, -2.73200f, -0.73200f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f), + Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f), + Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate320degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, -1.19530f, -2.56340f, 1.0f), + Point4D(-0.00000f, 2.56350f, -1.19530f, 1.0f), + Point4D(0.00010f, 1.19540f, 2.56350f, 1.0f), + Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(-0.00000f, -1.19530f, -2.56340f, 1.0f), + Point4D(-0.00000f, 2.56350f, -1.19530f, 1.0f), + Point4D(0.00010f, 1.19540f, 2.56350f, 1.0f), + Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f), + Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f), + Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate340degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, -2.00000f, -2.00000f, 1.0f), + Point4D(-0.00000f, 2.00000f, -2.00000f, 1.0f), + Point4D(0.00010f, 2.00000f, 2.00000f, 1.0f), + Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f), + Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(-0.00000f, -2.00000f, -2.00000f, 1.0f), + Point4D(-0.00000f, 2.00000f, -2.00000f, 1.0f), + Point4D(0.00010f, 2.00000f, 2.00000f, 1.0f), + Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f), + Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f)}}; + ::RunTest(polygons, expected); +} + +TEST(BSPTree, TwoPlaneIntersectRotate360degrees) +{ + const std::deque<MozPolygon> polygons{ + MozPolygon{Point4D(-0.00000f, -2.00000f, -2.00000f, 1.0f), + Point4D(-0.00000f, 2.00000f, -2.00000f, 1.0f), + Point4D(0.00010f, 2.00000f, 2.00000f, 1.0f), + Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f), + Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f)}}; + + const std::deque<MozPolygon> expected{ + MozPolygon{Point4D(-0.00000f, -2.00000f, -2.00000f, 1.0f), + Point4D(-0.00000f, 2.00000f, -2.00000f, 1.0f), + Point4D(0.00010f, 2.00000f, 2.00000f, 1.0f), + Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)}, + MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f), + Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f), + Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f)}}; + ::RunTest(polygons, expected); +} diff --git a/gfx/tests/gtest/TestBufferRotation.cpp b/gfx/tests/gtest/TestBufferRotation.cpp new file mode 100644 index 0000000000..871295e68c --- /dev/null +++ b/gfx/tests/gtest/TestBufferRotation.cpp @@ -0,0 +1,162 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" + +#include "BufferUnrotate.h" + +using mozilla::gfx::BufferUnrotate; + +static unsigned char* GenerateBuffer(int bytesPerPixel, int width, int height, + int stride, int xBoundary, int yBoundary) { + unsigned char* buffer = new unsigned char[stride * height]; + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + int pos = ((yBoundary + y) % height) * stride + + ((xBoundary + x) % width) * bytesPerPixel; + for (int i = 0; i < bytesPerPixel; i++) { + buffer[pos + i] = (x + y + i * 2) % 256; + } + } + } + return buffer; +} + +static bool CheckBuffer(unsigned char* buffer, int bytesPerPixel, int width, + int height, int stride) { + int xBoundary = 0; + int yBoundary = 0; + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + int pos = ((yBoundary + y) % height) * stride + + ((xBoundary + x) % width) * bytesPerPixel; + for (int i = 0; i < bytesPerPixel; i++) { + if (buffer[pos + i] != (x + y + i * 2) % 256) { + printf("Buffer differs at %i, %i, is %i\n", x, y, + (int)buffer[pos + i]); + return false; + } + } + } + } + return true; +} + +TEST(Gfx, BufferUnrotateHorizontal) +{ + const int NUM_OF_TESTS = 8; + int bytesPerPixelList[2] = {2, 4}; + int width[NUM_OF_TESTS] = {100, 100, 99, 99, 100, 100, 99, 99}; + int height[NUM_OF_TESTS] = {100, 99, 100, 99, 100, 99, 100, 99}; + int xBoundary[NUM_OF_TESTS] = {30, 30, 30, 30, 31, 31, 31, 31}; + int yBoundary[NUM_OF_TESTS] = {0, 0, 0, 0}; + + for (int bytesPerId = 0; bytesPerId < 2; bytesPerId++) { + int bytesPerPixel = bytesPerPixelList[bytesPerId]; + int stride = 256 * bytesPerPixel; + for (int testId = 0; testId < NUM_OF_TESTS; testId++) { + unsigned char* buffer = + GenerateBuffer(bytesPerPixel, width[testId], height[testId], stride, + xBoundary[testId], yBoundary[testId]); + BufferUnrotate(buffer, width[testId] * bytesPerPixel, height[testId], + stride, xBoundary[testId] * bytesPerPixel, + yBoundary[testId]); + + EXPECT_TRUE(CheckBuffer(buffer, bytesPerPixel, width[testId], + height[testId], stride)); + delete[] buffer; + } + } +} + +TEST(Gfx, BufferUnrotateVertical) +{ + const int NUM_OF_TESTS = 8; + int bytesPerPixelList[2] = {2, 4}; + int width[NUM_OF_TESTS] = {100, 100, 99, 99, 100, 100, 99, 99}; + int height[NUM_OF_TESTS] = {100, 99, 100, 99, 100, 99, 100, 99}; + int xBoundary[NUM_OF_TESTS] = {0, 0, 0, 0}; + int yBoundary[NUM_OF_TESTS] = {30, 30, 30, 30, 31, 31, 31, 31}; + + for (int bytesPerId = 0; bytesPerId < 2; bytesPerId++) { + int bytesPerPixel = bytesPerPixelList[bytesPerId]; + int stride = 256 * bytesPerPixel; + for (int testId = 0; testId < NUM_OF_TESTS; testId++) { + unsigned char* buffer = + GenerateBuffer(bytesPerPixel, width[testId], height[testId], stride, + xBoundary[testId], yBoundary[testId]); + BufferUnrotate(buffer, width[testId] * bytesPerPixel, height[testId], + stride, xBoundary[testId] * bytesPerPixel, + yBoundary[testId]); + + EXPECT_TRUE(CheckBuffer(buffer, bytesPerPixel, width[testId], + height[testId], stride)); + delete[] buffer; + } + } +} + +TEST(Gfx, BufferUnrotateBoth) +{ + const int NUM_OF_TESTS = 16; + int bytesPerPixelList[2] = {2, 4}; + int width[NUM_OF_TESTS] = {100, 100, 99, 99, 100, 100, 99, 99, + 100, 100, 99, 99, 100, 100, 99, 99}; + int height[NUM_OF_TESTS] = {100, 99, 100, 99, 100, 99, 100, 99, + 100, 99, 100, 99, 100, 99, 100, 99}; + int xBoundary[NUM_OF_TESTS] = {30, 30, 30, 30, 31, 31, 31, 31, + 30, 30, 30, 30, 31, 31, 31, 31}; + int yBoundary[NUM_OF_TESTS] = {30, 30, 30, 30, 30, 30, 30, 30, + 31, 31, 31, 31, 31, 31, 31, 31}; + + for (int bytesPerId = 0; bytesPerId < 2; bytesPerId++) { + int bytesPerPixel = bytesPerPixelList[bytesPerId]; + int stride = 256 * bytesPerPixel; + for (int testId = 0; testId < NUM_OF_TESTS; testId++) { + unsigned char* buffer = + GenerateBuffer(bytesPerPixel, width[testId], height[testId], stride, + xBoundary[testId], yBoundary[testId]); + BufferUnrotate(buffer, width[testId] * bytesPerPixel, height[testId], + stride, xBoundary[testId] * bytesPerPixel, + yBoundary[testId]); + + EXPECT_TRUE(CheckBuffer(buffer, bytesPerPixel, width[testId], + height[testId], stride)); + delete[] buffer; + } + } +} + +TEST(Gfx, BufferUnrotateUneven) +{ + const int NUM_OF_TESTS = 16; + int bytesPerPixelList[2] = {2, 4}; + int width[NUM_OF_TESTS] = {10, 100, 99, 39, 100, 40, 99, 39, + 100, 50, 39, 99, 74, 60, 99, 39}; + int height[NUM_OF_TESTS] = {100, 39, 10, 99, 10, 99, 40, 99, + 73, 39, 100, 39, 67, 99, 84, 99}; + int xBoundary[NUM_OF_TESTS] = {0, 0, 30, 30, 99, 31, 0, 31, + 30, 30, 30, 30, 31, 31, 31, 38}; + int yBoundary[NUM_OF_TESTS] = {30, 30, 0, 30, 0, 30, 0, 30, + 31, 31, 31, 31, 31, 31, 31, 98}; + + for (int bytesPerId = 0; bytesPerId < 2; bytesPerId++) { + int bytesPerPixel = bytesPerPixelList[bytesPerId]; + int stride = 256 * bytesPerPixel; + for (int testId = 0; testId < NUM_OF_TESTS; testId++) { + unsigned char* buffer = + GenerateBuffer(bytesPerPixel, width[testId], height[testId], stride, + xBoundary[testId], yBoundary[testId]); + BufferUnrotate(buffer, width[testId] * bytesPerPixel, height[testId], + stride, xBoundary[testId] * bytesPerPixel, + yBoundary[testId]); + + EXPECT_TRUE(CheckBuffer(buffer, bytesPerPixel, width[testId], + height[testId], stride)); + delete[] buffer; + } + } +} diff --git a/gfx/tests/gtest/TestColorNames.cpp b/gfx/tests/gtest/TestColorNames.cpp new file mode 100644 index 0000000000..dba82161a7 --- /dev/null +++ b/gfx/tests/gtest/TestColorNames.cpp @@ -0,0 +1,91 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" + +#include <string.h> +#include "nsColor.h" +#include "nsColorNames.h" +#include "mozilla/Sprintf.h" +#include "nsString.h" +#include "mozilla/ArrayUtils.h" + +// define an array of all color names +#define GFX_COLOR(_name, _value) #_name, +static const char* const kColorNames[] = { +#include "nsColorNameList.h" +}; +#undef GFX_COLOR + +// define an array of all color name values +#define GFX_COLOR(_name, _value) _value, +static const nscolor kColors[] = { +#include "nsColorNameList.h" +}; +#undef GFX_COLOR + +using namespace mozilla; + +static const char* kJunkNames[] = {nullptr, "", "123", + "backgroundz", "zzzzzz", "#@$&@#*@*$@$#"}; + +static void RunColorTests() { + nscolor rgb; + // First make sure we can find all of the tags that are supposed to + // be in the table. Futz with the case to make sure any case will + // work + + for (uint32_t index = 0; index < ArrayLength(kColorNames); index++) { + // Lookup color by name and make sure it has the right id + nsCString tagName(kColorNames[index]); + + // Check that color lookup by name gets the right rgb value + ASSERT_TRUE(NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tagName), &rgb)) + << "can't find '" << tagName.get() << "'"; + ASSERT_TRUE((rgb == kColors[index])) + << "failed at index " << index << " out of " << ArrayLength(kColorNames); + + // fiddle with the case to make sure we can still find it + tagName.SetCharAt(tagName.CharAt(0) - 32, 0); + ASSERT_TRUE(NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tagName), &rgb)) + << "can't find '" << tagName.get() << "'"; + ASSERT_TRUE((rgb == kColors[index])) + << "failed at index " << index << " out of " << ArrayLength(kColorNames); + + // Check that parsing an RGB value in hex gets the right values + uint8_t r = NS_GET_R(rgb); + uint8_t g = NS_GET_G(rgb); + uint8_t b = NS_GET_B(rgb); + uint8_t a = NS_GET_A(rgb); + char cbuf[50]; + if (a != UINT8_MAX) { + SprintfLiteral(cbuf, "%02x%02x%02x%02x", r, g, b, a); + } else { + SprintfLiteral(cbuf, "%02x%02x%02x", r, g, b); + } + nscolor hexrgb; + ASSERT_TRUE(NS_HexToRGBA(NS_ConvertASCIItoUTF16(cbuf), + nsHexColorType::AllowAlpha, &hexrgb)) + << "hex conversion to color of '" << cbuf << "'"; + ASSERT_TRUE(hexrgb == rgb); + } +} + +static void RunJunkColorTests() { + nscolor rgb; + // Now make sure we don't find some garbage + for (uint32_t i = 0; i < ArrayLength(kJunkNames); i++) { + nsCString tag(kJunkNames[i]); + ASSERT_FALSE(NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tag), &rgb)) + << "Failed at junk color " << kJunkNames[i]; + } +} + +TEST(Gfx, ColorNames) +{ RunColorTests(); } + +TEST(Gfx, JunkColorNames) +{ RunJunkColorTests(); } diff --git a/gfx/tests/gtest/TestConfigManager.cpp b/gfx/tests/gtest/TestConfigManager.cpp new file mode 100644 index 0000000000..a4d9bbd696 --- /dev/null +++ b/gfx/tests/gtest/TestConfigManager.cpp @@ -0,0 +1,922 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +#include "gtest/gtest.h" + +#include "gfxFeature.h" +#include "mozilla/gfx/gfxConfigManager.h" +#include "nsIGfxInfo.h" + +using namespace mozilla; +using namespace mozilla::gfx; + +namespace mozilla { +namespace gfx { + +class MockGfxInfo final : public nsIGfxInfo { + public: + NS_DECL_THREADSAFE_ISUPPORTS + + int32_t mStatusWr; + int32_t mStatusWrCompositor; + int32_t mStatusWrShaderCache; + int32_t mStatusWrOptimizedShaders; + int32_t mStatusWrPartialPresent; + int32_t mStatusWrScissoredCacheClears; + int32_t mMaxRefreshRate; + bool mHasMixedRefreshRate; + Maybe<bool> mHasBattery; + const char* mVendorId; + const char* mDeviceId; + + // Default allows WebRender + compositor, and is desktop NVIDIA. + MockGfxInfo() + : mStatusWr(nsIGfxInfo::FEATURE_STATUS_OK), + mStatusWrCompositor(nsIGfxInfo::FEATURE_STATUS_OK), + mStatusWrShaderCache(nsIGfxInfo::FEATURE_STATUS_OK), + mStatusWrOptimizedShaders(nsIGfxInfo::FEATURE_STATUS_OK), + mStatusWrPartialPresent(nsIGfxInfo::FEATURE_STATUS_OK), + mStatusWrScissoredCacheClears(nsIGfxInfo::FEATURE_STATUS_OK), + mMaxRefreshRate(-1), + mHasMixedRefreshRate(false), + mHasBattery(Some(false)), + mVendorId("0x10de"), + mDeviceId("") {} + + NS_IMETHOD GetFeatureStatus(int32_t aFeature, nsACString& aFailureId, + int32_t* _retval) override { + switch (aFeature) { + case nsIGfxInfo::FEATURE_WEBRENDER: + *_retval = mStatusWr; + break; + case nsIGfxInfo::FEATURE_WEBRENDER_COMPOSITOR: + *_retval = mStatusWrCompositor; + break; + case nsIGfxInfo::FEATURE_WEBRENDER_SHADER_CACHE: + *_retval = mStatusWrShaderCache; + break; + case nsIGfxInfo::FEATURE_WEBRENDER_OPTIMIZED_SHADERS: + *_retval = mStatusWrOptimizedShaders; + break; + case nsIGfxInfo::FEATURE_WEBRENDER_PARTIAL_PRESENT: + *_retval = mStatusWrPartialPresent; + break; + case nsIGfxInfo::FEATURE_WEBRENDER_SCISSORED_CACHE_CLEARS: + *_retval = mStatusWrScissoredCacheClears; + break; + default: + return NS_ERROR_NOT_IMPLEMENTED; + } + return NS_OK; + } + + NS_IMETHOD GetHasBattery(bool* aHasBattery) override { + if (mHasBattery.isNothing()) { + return NS_ERROR_NOT_IMPLEMENTED; + } + *aHasBattery = *mHasBattery; + return NS_OK; + } + + NS_IMETHOD GetAdapterVendorID(nsAString& aAdapterVendorID) override { + if (!mVendorId) { + return NS_ERROR_NOT_IMPLEMENTED; + } + aAdapterVendorID.AssignASCII(mVendorId); + return NS_OK; + } + + NS_IMETHOD GetAdapterDeviceID(nsAString& aAdapterDeviceID) override { + if (!mDeviceId) { + return NS_ERROR_NOT_IMPLEMENTED; + } + aAdapterDeviceID.AssignASCII(mDeviceId); + return NS_OK; + } + + NS_IMETHOD_(int32_t) GetMaxRefreshRate(bool* aMixed) override { + if (aMixed) { + *aMixed = mHasMixedRefreshRate; + } + return mMaxRefreshRate; + } + + NS_IMETHODIMP GetEmbeddedInFirefoxReality( + bool* aEmbeddedInFirefoxReality) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + + NS_IMETHOD GetAzureCanvasBackend(nsAString& aBackend) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + + NS_IMETHOD GetAzureContentBackend(nsAString& aBackend) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + + // The following methods we don't need for testing gfxConfigManager. + NS_IMETHOD GetFeatureSuggestedDriverVersion(int32_t aFeature, + nsAString& _retval) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + + NS_IMETHOD GetMonitors(JSContext* cx, + JS::MutableHandle<JS::Value> _retval) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetFailures(nsTArray<int32_t>& indices, + nsTArray<nsCString>& failures) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD_(void) LogFailure(const nsACString& failure) override {} + NS_IMETHOD GetInfo(JSContext*, JS::MutableHandle<JS::Value>) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetFeatures(JSContext*, JS::MutableHandle<JS::Value>) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetFeatureLog(JSContext*, JS::MutableHandle<JS::Value>) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetActiveCrashGuards(JSContext*, + JS::MutableHandle<JS::Value>) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetContentBackend(nsAString& aContentBackend) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetUsingGPUProcess(bool* aOutValue) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetIsHeadless(bool* aIsHeadless) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetTargetFrameRate(uint32_t* aTargetFrameRate) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetCodecSupportInfo(nsACString& aCodecSupportInfo) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetD2DEnabled(bool* aD2DEnabled) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetDWriteEnabled(bool* aDWriteEnabled) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetDWriteVersion(nsAString& aDwriteVersion) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetCleartypeParameters(nsAString& aCleartypeParams) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetWindowProtocol(nsAString& aWindowProtocol) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetTestType(nsAString& aTestType) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDescription(nsAString& aAdapterDescription) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDriver(nsAString& aAdapterDriver) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterSubsysID(nsAString& aAdapterSubsysID) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterRAM(uint32_t* aAdapterRAM) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDriverVersion( + nsAString& aAdapterDriverVersion) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDriverDate(nsAString& aAdapterDriverDate) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDescription2(nsAString& aAdapterDescription) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDriver2(nsAString& aAdapterDriver) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterVendorID2(nsAString& aAdapterVendorID) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDeviceID2(nsAString& aAdapterDeviceID) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterSubsysID2(nsAString& aAdapterSubsysID) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterRAM2(uint32_t* aAdapterRAM) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDriverVersion2( + nsAString& aAdapterDriverVersion) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetAdapterDriverDate2(nsAString& aAdapterDriverDate) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetIsGPU2Active(bool* aIsGPU2Active) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD GetDrmRenderDevice(nsACString& aDrmRenderDevice) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD ControlGPUProcessForXPCShell(bool aEnable, + bool* _retval) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD KillGPUProcessForTests() override { + return NS_ERROR_NOT_IMPLEMENTED; + } + NS_IMETHOD CrashGPUProcessForTests() override { + return NS_ERROR_NOT_IMPLEMENTED; + } + + NS_IMETHOD_(void) GetData() override {} + + private: + virtual ~MockGfxInfo() = default; +}; + +NS_IMPL_ISUPPORTS(MockGfxInfo, nsIGfxInfo) + +class GfxConfigManager : public ::testing::Test, public gfxConfigManager { + public: + GfxConfigManager() { + mFeatureWr = &mFeatures.mWr; + mFeatureWrCompositor = &mFeatures.mWrCompositor; + mFeatureWrAngle = &mFeatures.mWrAngle; + mFeatureWrDComp = &mFeatures.mWrDComp; + mFeatureWrPartial = &mFeatures.mWrPartial; + mFeatureWrShaderCache = &mFeatures.mWrShaderCache; + mFeatureWrOptimizedShaders = &mFeatures.mWrOptimizedShaders; + mFeatureWrScissoredCacheClears = &mFeatures.mWrScissoredCacheClears; + mFeatureHwCompositing = &mFeatures.mHwCompositing; + mFeatureGPUProcess = &mFeatures.mGPUProcess; + } + + void SetUp() override { + mMockGfxInfo = new MockGfxInfo(); + mGfxInfo = mMockGfxInfo; + + mFeatureD3D11HwAngle = &mFeatures.mD3D11HwAngle; + mFeatureD3D11Compositing = &mFeatures.mD3D11Compositing; + + // By default, turn everything on. This effectively assumes we are on + // qualified nightly Windows 10 with DirectComposition support. + mFeatureHwCompositing->EnableByDefault(); + mFeatureD3D11HwAngle->EnableByDefault(); + mFeatureD3D11Compositing->EnableByDefault(); + mFeatureGPUProcess->EnableByDefault(); + + mWrCompositorEnabled.emplace(true); + mWrPartialPresent = true; + mWrShaderCache.emplace(true); + mWrOptimizedShaders = true; + mWrForceAngle = true; + mWrDCompWinEnabled = true; + mWrCompositorDCompRequired = true; + mWrScissoredCacheClearsEnabled = true; + ++mHwStretchingSupport.mBoth; + mIsWin10OrLater = true; + mIsWin11OrLater = true; + mIsNightly = true; + mIsEarlyBetaOrEarlier = true; + } + + void TearDown() override { + mFeatures.mWr.Reset(); + mFeatures.mWrCompositor.Reset(); + mFeatures.mWrAngle.Reset(); + mFeatures.mWrDComp.Reset(); + mFeatures.mWrPartial.Reset(); + mFeatures.mWrShaderCache.Reset(); + mFeatures.mWrOptimizedShaders.Reset(); + mFeatures.mWrScissoredCacheClears.Reset(); + mFeatures.mHwCompositing.Reset(); + mFeatures.mD3D11HwAngle.Reset(); + mFeatures.mD3D11Compositing.Reset(); + mFeatures.mGPUProcess.Reset(); + } + + struct { + FeatureState mWr; + FeatureState mWrCompositor; + FeatureState mWrAngle; + FeatureState mWrDComp; + FeatureState mWrPartial; + FeatureState mWrShaderCache; + FeatureState mWrOptimizedShaders; + FeatureState mWrScissoredCacheClears; + FeatureState mHwCompositing; + FeatureState mD3D11HwAngle; + FeatureState mD3D11Compositing; + FeatureState mGPUProcess; + } mFeatures; + + RefPtr<MockGfxInfo> mMockGfxInfo; +}; + +} // namespace gfx +} // namespace mozilla + +TEST_F(GfxConfigManager, WebRenderDefault) { + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderDefaultRelease) { + mIsNightly = mIsEarlyBetaOrEarlier = false; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderNoPartialPresent) { + mWrPartialPresent = false; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderPartialBlocked) { + mWrPartialPresent = true; + mMockGfxInfo->mStatusWrPartialPresent = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + ConfigureWebRender(); + + EXPECT_FALSE(mFeatures.mWrPartial.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderForcePartialBlocked) { + mWrForcePartialPresent = true; + mMockGfxInfo->mStatusWrPartialPresent = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderScaledResolutionWithHwStretching) { + mScaledResolution = true; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderScaledResolutionNoHwStretching) { + ++mHwStretchingSupport.mNone; + mScaledResolution = true; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderEnabledWithDisableHwCompositingNoWr) { + mDisableHwCompositingNoWr = true; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderDisabledWithDisableHwCompositingNoWr) { + mDisableHwCompositingNoWr = true; + mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + ConfigureWebRender(); + + EXPECT_FALSE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_FALSE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_FALSE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderDisabledWithAllowSoftwareGPUProcess) { + mDisableHwCompositingNoWr = true; + mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + mGPUProcessAllowSoftware = true; + ConfigureWebRender(); + + EXPECT_FALSE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_FALSE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderSafeMode) { + mSafeMode = true; + ConfigureWebRender(); + + EXPECT_FALSE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderEarlierThanWindows10) { + mIsWin10OrLater = false; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderDCompDisabled) { + mWrDCompWinEnabled = false; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderDCompNotRequired) { + mWrDCompWinEnabled = false; + mWrCompositorDCompRequired = false; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderForceAngleDisabled) { + mWrForceAngle = false; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderD3D11HwAngleDisabled) { + mFeatures.mD3D11HwAngle.UserDisable("", ""_ns); + ConfigureWebRender(); + + EXPECT_FALSE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_FALSE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderD3D11HwAngleAndForceAngleDisabled) { + mWrForceAngle = false; + mFeatures.mD3D11HwAngle.UserDisable("", ""_ns); + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_FALSE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderGPUProcessDisabled) { + mFeatures.mGPUProcess.UserDisable("", ""_ns); + ConfigureWebRender(); + + EXPECT_FALSE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_FALSE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderIntelBatteryNoHwStretchingNotNightly) { + mIsNightly = mIsEarlyBetaOrEarlier = false; + ++mHwStretchingSupport.mNone; + mScaledResolution = true; + mMockGfxInfo->mHasBattery.ref() = true; + mMockGfxInfo->mVendorId = "0x8086"; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderNvidiaHighMixedRefreshRateWin10) { + mIsWin10OrLater = true; + mIsWin11OrLater = false; + mMockGfxInfo->mMaxRefreshRate = 120; + mMockGfxInfo->mHasMixedRefreshRate = true; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderNvidiaHighMixedRefreshRateWin11) { + mIsWin10OrLater = true; + mIsWin11OrLater = true; + mMockGfxInfo->mMaxRefreshRate = 120; + mMockGfxInfo->mHasMixedRefreshRate = true; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderNvidiaHighRefreshRateNotNightly) { + mMockGfxInfo->mMaxRefreshRate = 120; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderNvidiaLowMixedRefreshRateNotNightly) { + mMockGfxInfo->mMaxRefreshRate = 60; + mMockGfxInfo->mHasMixedRefreshRate = true; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderSofwareAndNotQualified) { + mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + ConfigureWebRender(); + + EXPECT_FALSE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderForceEnabledEnvvar) { + mWrEnvForceEnabled = true; + mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderSoftwareAllowedForceEnabledPref) { + mWrForceEnabled = true; + mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderForceSoftwareForceEnabledEnvvar) { + mWrEnvForceEnabled = true; + mWrSoftwareForceEnabled = true; + mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + ConfigureWebRender(); + + EXPECT_FALSE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderSoftwareReleaseWindowsGPUProcessDisabled) { + mIsNightly = mIsEarlyBetaOrEarlier = false; + mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + mFeatures.mGPUProcess.UserDisable("", ""_ns); + ConfigureWebRender(); + + EXPECT_FALSE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_FALSE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderSoftwareReleaseGPUProcessDisabled) { + mIsNightly = mIsEarlyBetaOrEarlier = false; + mIsWin10OrLater = false; + mFeatureD3D11Compositing = nullptr; + mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + mFeatures.mGPUProcess.UserDisable("", ""_ns); + ConfigureWebRender(); + + EXPECT_FALSE(mFeatures.mWr.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_FALSE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderShaderCacheDisabled) { + mWrShaderCache = Some(false); + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderShaderCacheBlocked) { + mMockGfxInfo->mStatusWrShaderCache = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderScissoredCacheClearsDisabled) { + mWrScissoredCacheClearsEnabled = false; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderScissoredCacheClearsBlocked) { + mMockGfxInfo->mStatusWrScissoredCacheClears = + nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} + +TEST_F(GfxConfigManager, WebRenderScissoredCacheClearsForceEnabled) { + mWrScissoredCacheClearsForceEnabled = false; + mMockGfxInfo->mStatusWrScissoredCacheClears = + nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + ConfigureWebRender(); + + EXPECT_TRUE(mFeatures.mWr.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled()); + EXPECT_FALSE(mFeatures.mWrScissoredCacheClears.IsEnabled()); + EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled()); + EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled()); + EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled()); + EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled()); +} diff --git a/gfx/tests/gtest/TestCoord.cpp b/gfx/tests/gtest/TestCoord.cpp new file mode 100644 index 0000000000..bf44e1bd92 --- /dev/null +++ b/gfx/tests/gtest/TestCoord.cpp @@ -0,0 +1,89 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" + +#include "nsCoord.h" + +namespace mozilla { + +template <typename CoordTyped> +void TestConstructors() { + CoordTyped coord1; + EXPECT_EQ(coord1.value, 0); + + CoordTyped coord2 = 6000; + EXPECT_EQ(coord2.value, 6000); + + EXPECT_EQ(CoordTyped::FromRound(5.3).value, 5); + EXPECT_EQ(CoordTyped::FromRound(5.5).value, 6); + EXPECT_EQ(CoordTyped::FromRound(-2.5).value, -2); + + EXPECT_EQ(CoordTyped::FromTruncate(5.9).value, 5); + EXPECT_EQ(CoordTyped::FromTruncate(-2.7).value, -2); + + EXPECT_EQ(CoordTyped::FromCeil(5.3).value, 6); + EXPECT_EQ(CoordTyped::FromCeil(-2.7).value, -2); + + EXPECT_EQ(CoordTyped::FromFloor(5.9).value, 5); + EXPECT_EQ(CoordTyped::FromFloor(-2.7).value, -3); +} + +template <typename CoordTyped> +void TestComparisonOperators() { + CoordTyped coord1 = 6000; + CoordTyped coord2 = 10000; + + EXPECT_LT(coord1, CoordTyped::kMax); + EXPECT_GT(coord1, CoordTyped::kMin); + EXPECT_NE(coord1, coord2); +} + +template <typename CoordTyped> +void TestArithmeticOperators() { + CoordTyped coord1 = 6000; + CoordTyped coord2 = 10000; + + EXPECT_EQ(coord1 + coord2, CoordTyped(16000)); + EXPECT_EQ(coord2 - coord1, CoordTyped(4000)); + + decltype(CoordTyped::value) scaleInt = 2; + EXPECT_EQ(coord1 * scaleInt, CoordTyped(12000)); + EXPECT_EQ(coord1 / scaleInt, CoordTyped(3000)); + + EXPECT_EQ(coord1 * 2.0, 12000.0); + EXPECT_EQ(coord1 / 2.0, 3000.0); +} + +template <typename CoordTyped> +void TestClamp() { + CoordTyped coord1 = CoordTyped::kMax + 1000; + EXPECT_EQ(coord1.ToMinMaxClamped(), CoordTyped::kMax); + + CoordTyped coord2 = CoordTyped::kMin - 1000; + EXPECT_EQ(coord2.ToMinMaxClamped(), CoordTyped::kMin); + + CoordTyped coord3 = 12000; + EXPECT_EQ(coord3.ToMinMaxClamped(), CoordTyped(12000)); +} + +TEST(Gfx, TestAuCoord) +{ + TestConstructors<AuCoord>(); + TestComparisonOperators<AuCoord>(); + TestArithmeticOperators<AuCoord>(); + TestClamp<AuCoord>(); +} + +TEST(Gfx, TestAuCoord64) +{ + TestConstructors<AuCoord64>(); + TestComparisonOperators<AuCoord64>(); + TestArithmeticOperators<AuCoord64>(); + TestClamp<AuCoord64>(); +} + +} // namespace mozilla diff --git a/gfx/tests/gtest/TestGfxWidgets.cpp b/gfx/tests/gtest/TestGfxWidgets.cpp new file mode 100644 index 0000000000..9cadfa7382 --- /dev/null +++ b/gfx/tests/gtest/TestGfxWidgets.cpp @@ -0,0 +1,111 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" +#include "GfxDriverInfo.h" +#include "nsVersionComparator.h" + +using namespace mozilla::widget; + +TEST(GfxWidgets, Split) +{ + char aStr[8], bStr[8], cStr[8], dStr[8]; + + ASSERT_TRUE(SplitDriverVersion("33.4.3.22", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 33 && atoi(bStr) == 4 && atoi(cStr) == 3 && + atoi(dStr) == 22); + + ASSERT_TRUE(SplitDriverVersion("28.74.0.0", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 28 && atoi(bStr) == 74 && atoi(cStr) == 0 && + atoi(dStr) == 0); + + ASSERT_TRUE(SplitDriverVersion("132.0.0.0", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 132 && atoi(bStr) == 0 && atoi(cStr) == 0 && + atoi(dStr) == 0); + + ASSERT_TRUE(SplitDriverVersion("2.3.0.0", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 2 && atoi(bStr) == 3 && atoi(cStr) == 0 && + atoi(dStr) == 0); + + ASSERT_TRUE(SplitDriverVersion("25.4.0.8", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 25 && atoi(bStr) == 4 && atoi(cStr) == 0 && + atoi(dStr) == 8); + + ASSERT_TRUE(SplitDriverVersion("424.143.84437.3", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 424 && atoi(bStr) == 143 && atoi(cStr) == 8443 && + atoi(dStr) == 3); + + ASSERT_FALSE(SplitDriverVersion("25.4.0.8.", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 25 && atoi(bStr) == 4 && atoi(cStr) == 0 && + atoi(dStr) == 8); + + ASSERT_TRUE(SplitDriverVersion("424.143.8.3143243", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 424 && atoi(bStr) == 143 && atoi(cStr) == 8 && + atoi(dStr) == 3143); + + ASSERT_FALSE(SplitDriverVersion("25.4.0.8..", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 25 && atoi(bStr) == 4 && atoi(cStr) == 0 && + atoi(dStr) == 8); + + ASSERT_FALSE( + SplitDriverVersion("424.143.8.3143243.", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 424 && atoi(bStr) == 143 && atoi(cStr) == 8 && + atoi(dStr) == 3143); + + ASSERT_FALSE(SplitDriverVersion("25.4.0.8.13", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 25 && atoi(bStr) == 4 && atoi(cStr) == 0 && + atoi(dStr) == 8); + + ASSERT_FALSE(SplitDriverVersion("4.1.8.13.24.35", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 4 && atoi(bStr) == 1 && atoi(cStr) == 8 && + atoi(dStr) == 13); + + ASSERT_TRUE(SplitDriverVersion("28...74", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 28 && atoi(bStr) == 0 && atoi(cStr) == 0 && + atoi(dStr) == 74); + + ASSERT_FALSE(SplitDriverVersion("4.1.8.13.24.35", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 4 && atoi(bStr) == 1 && atoi(cStr) == 8 && + atoi(dStr) == 13); + + ASSERT_TRUE(SplitDriverVersion("35..42.0", aStr, bStr, cStr, dStr)); + ASSERT_TRUE(atoi(aStr) == 35 && atoi(bStr) == 0 && atoi(cStr) == 42 && + atoi(dStr) == 0); +} + +TEST(GfxWidgets, Versioning) +{ + ASSERT_TRUE(mozilla::Version("0") < mozilla::Version("41.0a1")); + ASSERT_TRUE(mozilla::Version("39.0.5b7") < mozilla::Version("41.0a1")); + ASSERT_TRUE(mozilla::Version("18.0.5b7") < mozilla::Version("18.2")); + ASSERT_TRUE(mozilla::Version("30.0.5b7") < mozilla::Version("41.0b9")); + ASSERT_TRUE(mozilla::Version("100") > mozilla::Version("43.0a1")); + ASSERT_FALSE(mozilla::Version("42.0") < mozilla::Version("42.0")); + ASSERT_TRUE(mozilla::Version("42.0b2") < mozilla::Version("42.0")); + ASSERT_TRUE(mozilla::Version("42.0b2") < mozilla::Version("42")); + ASSERT_TRUE(mozilla::Version("42.0b2") < mozilla::Version("43.0a1")); + ASSERT_TRUE(mozilla::Version("42") < mozilla::Version("43.0a1")); + ASSERT_TRUE(mozilla::Version("42.0") < mozilla::Version("43.0a1")); + ASSERT_TRUE(mozilla::Version("42.0.5") < mozilla::Version("43.0a1")); + ASSERT_TRUE(mozilla::Version("42.1") < mozilla::Version("43.0a1")); + ASSERT_TRUE(mozilla::Version("42.0a1") < mozilla::Version("42")); + ASSERT_TRUE(mozilla::Version("42.0a1") < mozilla::Version("42.0.5")); + ASSERT_TRUE(mozilla::Version("42.0b7") < mozilla::Version("42.0.5")); + ASSERT_TRUE(mozilla::Version("") == mozilla::Version("0")); + ASSERT_TRUE(mozilla::Version("1b1b") == mozilla::Version("1b1b")); + ASSERT_TRUE(mozilla::Version("1b1b") < mozilla::Version("1b1c")); + ASSERT_TRUE(mozilla::Version("1b1b") < mozilla::Version("1b1d")); + ASSERT_TRUE(mozilla::Version("1b1c") > mozilla::Version("1b1b")); + ASSERT_TRUE(mozilla::Version("1b1d") > mozilla::Version("1b1b")); + ASSERT_TRUE(mozilla::Version("110") < mozilla::Version("110.0.1")); + ASSERT_TRUE(mozilla::Version("110.*") >= mozilla::Version("110.0.1")); + + // Note these two; one would expect for 42.0b1 and 42b1 to compare the + // same, but they do not. If this ever changes, we want to know, so + // leave the test here to fail. + ASSERT_TRUE(mozilla::Version("42.0a1") < mozilla::Version("42.0b2")); + ASSERT_FALSE(mozilla::Version("42.0a1") < mozilla::Version("42b2")); +} diff --git a/gfx/tests/gtest/TestMatrix.cpp b/gfx/tests/gtest/TestMatrix.cpp new file mode 100644 index 0000000000..e55e8e793b --- /dev/null +++ b/gfx/tests/gtest/TestMatrix.cpp @@ -0,0 +1,145 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" +#include "mozilla/gfx/Matrix.h" + +using namespace mozilla; +using namespace mozilla::gfx; + +TEST(Matrix, TransformAndClipRect) +{ + Rect c(100, 100, 100, 100); + Matrix4x4 m; + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 50, 20, 20), c).IsEmpty()); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(250, 50, 20, 20), c).IsEmpty()); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(250, 250, 20, 20), c).IsEmpty()); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 250, 20, 20), c).IsEmpty()); + + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 50, 100, 20), c).IsEmpty()); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(150, 50, 100, 20), c).IsEmpty()); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 250, 100, 20), c).IsEmpty()); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(150, 250, 100, 20), c).IsEmpty()); + + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 50, 20, 100), c).IsEmpty()); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 150, 20, 100), c).IsEmpty()); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(250, 50, 20, 100), c).IsEmpty()); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(250, 150, 20, 100), c).IsEmpty()); + + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 50, 100, 100), c) + .IsEqualInterior(Rect(100, 100, 50, 50))); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(150, 50, 100, 100), c) + .IsEqualInterior(Rect(150, 100, 50, 50))); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(150, 150, 100, 100), c) + .IsEqualInterior(Rect(150, 150, 50, 50))); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 150, 100, 100), c) + .IsEqualInterior(Rect(100, 150, 50, 50))); + + EXPECT_TRUE(m.TransformAndClipBounds(Rect(110, 110, 80, 80), c) + .IsEqualInterior(Rect(110, 110, 80, 80))); + + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 50, 200, 200), c) + .IsEqualInterior(Rect(100, 100, 100, 100))); + + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 50, 200, 100), c) + .IsEqualInterior(Rect(100, 100, 100, 50))); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 150, 200, 100), c) + .IsEqualInterior(Rect(100, 150, 100, 50))); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(50, 50, 100, 200), c) + .IsEqualInterior(Rect(100, 100, 50, 100))); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(150, 50, 100, 200), c) + .IsEqualInterior(Rect(150, 100, 50, 100))); + + Matrix4x4 m2 = Matrix4x4::From2D(Matrix(22.68, 0, 0, 12, 16, 164)); + EXPECT_TRUE( + m2.TransformAndClipBounds(Rect(0, 0, 100, 100), Rect(1024, 1024, 0, 0)) + .IsEmpty()); + + // Empty rectangles should still have meaningful corners. + EXPECT_TRUE(m.TransformAndClipBounds(Rect(150, 50, 0, 200), c) + .IsEqualEdges(Rect(150, 100, 0, 100))); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(150, 150, 0, 0), c) + .IsEqualEdges(Rect(150, 150, 0, 0))); + EXPECT_TRUE(m.TransformAndClipBounds(Rect(150, 100, 300, 0), c) + .IsEqualEdges(Rect(150, 100, 50, 0))); +} + +TEST(Matrix, RotateTransform) +{ + gfx::Matrix4x4 transformMatrix; + gfx::Point3D trans, scale; + gfx::Quaternion orient; + + auto floor = [&](float aValue, int aDecimal) { + const int digit = pow(10, aDecimal); + const float result = (int)(aValue * digit); + return result / digit; + }; + + // Test rotate 45 degree on x-axis. + gfx::Quaternion expectedOrient(0.382f, 0.0f, 0.0f, 0.923f); + transformMatrix.RotateX(0.785f); + // the orient would be (x:0.3825, y:0, z:0, w: 0.9239) + transformMatrix.Decompose(trans, orient, scale); + EXPECT_EQ(floor(orient.x, 3), expectedOrient.x); + EXPECT_EQ(floor(orient.y, 3), expectedOrient.y); + EXPECT_EQ(floor(orient.z, 3), expectedOrient.z); + EXPECT_EQ(floor(orient.w, 3), expectedOrient.w); + + // Test set rotate matrix from a quaternion and + // compare it with the result from decompose. + transformMatrix = gfx::Matrix4x4(); + transformMatrix.SetRotationFromQuaternion(orient); + transformMatrix.Decompose(trans, orient, scale); + EXPECT_EQ(floor(orient.x, 3), expectedOrient.x); + EXPECT_EQ(floor(orient.y, 3), expectedOrient.y); + EXPECT_EQ(floor(orient.z, 3), expectedOrient.z); + EXPECT_EQ(floor(orient.w, 3), expectedOrient.w); + + // Test rotate -45 degree on axis: (0.577f, 0.577f, 0.577f). + transformMatrix = gfx::Matrix4x4(); + transformMatrix.SetRotateAxisAngle(0.577f, 0.577f, 0.577f, -0.785f); + // the orient would be (x:-0.2208, y:-0.2208, z:-0.2208, w: 0.9239) + transformMatrix.Decompose(trans, orient, scale); + + expectedOrient.Set(-0.220f, -0.220f, -0.220f, 0.923f); + EXPECT_EQ(floor(orient.x, 3), expectedOrient.x); + EXPECT_EQ(floor(orient.y, 3), expectedOrient.y); + EXPECT_EQ(floor(orient.z, 3), expectedOrient.z); + EXPECT_EQ(floor(orient.w, 3), expectedOrient.w); + + // Test set rotate matrix from a quaternion and + // compare it with the result from decompose. + transformMatrix = gfx::Matrix4x4(); + transformMatrix.SetRotationFromQuaternion(orient); + transformMatrix.Decompose(trans, orient, scale); + EXPECT_EQ(floor(orient.x, 3), expectedOrient.x); + EXPECT_EQ(floor(orient.y, 3), expectedOrient.y); + EXPECT_EQ(floor(orient.z, 3), expectedOrient.z); + EXPECT_EQ(floor(orient.w, 3), expectedOrient.w); +} + +TEST(Matrix4x4Flagged, Mult) +{ + Matrix4x4Flagged simple = + Matrix4x4::Translation(Point(42, 42)) * Matrix4x4::Scaling(3, 3, 1); + // For the general matrix, put a value in every field to make sure + // nothing gets dropped. + Matrix4x4 general(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2); + + // Use Matrix4x4::operator*(Matrix4x4). + // For the purposes of this test, assume that's correct. + Matrix4x4Flagged realResult = Matrix4x4Flagged(simple.GetMatrix() * general); + + // Check that Matrix4x4Flagged::operator*(Matrix4x4Flagged) produces the same + // result. + Matrix4x4Flagged flaggedResult = simple * Matrix4x4Flagged(general); + EXPECT_EQ(realResult, flaggedResult); + + // Check that Matrix4x4Flagged::operator*(Matrix4x4) produces the same result. + Matrix4x4Flagged mixedResult = simple * general; + EXPECT_EQ(realResult, mixedResult); +} diff --git a/gfx/tests/gtest/TestMoz2D.cpp b/gfx/tests/gtest/TestMoz2D.cpp new file mode 100644 index 0000000000..50854cdc98 --- /dev/null +++ b/gfx/tests/gtest/TestMoz2D.cpp @@ -0,0 +1,41 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" +#include "TestBase.h" +#include "TestPoint.h" +#include "TestScaling.h" +#include "TestBugs.h" + +TEST(Moz2D, Bugs) +{ + TestBugs* test = new TestBugs(); + int failures = 0; + test->RunTests(&failures); + delete test; + + ASSERT_EQ(failures, 0); +} + +TEST(Moz2D, Point) +{ + TestBase* test = new TestPoint(); + int failures = 0; + test->RunTests(&failures); + delete test; + + ASSERT_EQ(failures, 0); +} + +TEST(Moz2D, Scaling) +{ + TestBase* test = new TestScaling(); + int failures = 0; + test->RunTests(&failures); + delete test; + + ASSERT_EQ(failures, 0); +} diff --git a/gfx/tests/gtest/TestPolygon.cpp b/gfx/tests/gtest/TestPolygon.cpp new file mode 100644 index 0000000000..168f7b46d9 --- /dev/null +++ b/gfx/tests/gtest/TestPolygon.cpp @@ -0,0 +1,104 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" + +#include "PolygonTestUtils.h" + +#include "nsTArray.h" +#include "Point.h" +#include "Polygon.h" +#include "Triangle.h" + +using namespace mozilla::gfx; +typedef mozilla::gfx::Polygon MozPolygon; + +TEST(MozPolygon, TriangulateRectangle) +{ + const MozPolygon p{ + Point4D(0.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 1.0f, 1.0f, 1.0f), + Point4D(1.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 0.0f, 1.0f, 1.0f)}; + + const nsTArray<Triangle> triangles = p.ToTriangles(); + const nsTArray<Triangle> expected = { + Triangle(Point(0.0f, 0.0f), Point(0.0f, 1.0f), Point(1.0f, 1.0f)), + Triangle(Point(0.0f, 0.0f), Point(1.0f, 1.0f), Point(1.0f, 0.0f))}; + + AssertArrayEQ(triangles, expected); +} + +TEST(MozPolygon, TriangulatePentagon) +{ + const MozPolygon p{ + Point4D(0.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 1.0f, 1.0f, 1.0f), + Point4D(0.5f, 1.5f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f), + Point4D(1.0f, 0.0f, 1.0f, 1.0f)}; + + const nsTArray<Triangle> triangles = p.ToTriangles(); + const nsTArray<Triangle> expected = { + Triangle(Point(0.0f, 0.0f), Point(0.0f, 1.0f), Point(0.5f, 1.5f)), + Triangle(Point(0.0f, 0.0f), Point(0.5f, 1.5f), Point(1.0f, 1.0f)), + Triangle(Point(0.0f, 0.0f), Point(1.0f, 1.0f), Point(1.0f, 0.0f))}; + + AssertArrayEQ(triangles, expected); +} + +static void TestClipRect(const MozPolygon& aPolygon, + const MozPolygon& aExpected, const Rect& aRect) { + const MozPolygon res = aPolygon.ClipPolygon(MozPolygon::FromRect(aRect)); + EXPECT_TRUE(res == aExpected); +} + +TEST(MozPolygon, ClipRectangle) +{ + MozPolygon polygon{ + Point4D(0.0f, 0.0f, 0.0f, 1.0f), Point4D(0.0f, 1.0f, 0.0f, 1.0f), + Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 0.0f, 1.0f)}; + TestClipRect(polygon, polygon, Rect(0.0f, 0.0f, 1.0f, 1.0f)); + + MozPolygon expected = MozPolygon{ + Point4D(0.0f, 0.0f, 0.0f, 1.0f), Point4D(0.0f, 0.8f, 0.0f, 1.0f), + Point4D(0.8f, 0.8f, 0.0f, 1.0f), Point4D(0.8f, 0.0f, 0.0f, 1.0f)}; + TestClipRect(polygon, expected, Rect(0.0f, 0.0f, 0.8f, 0.8f)); + + expected = MozPolygon{ + Point4D(0.2f, 0.2f, 0.0f, 1.0f), Point4D(0.2f, 1.0f, 0.0f, 1.0f), + Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(1.0f, 0.2f, 0.0f, 1.0f)}; + TestClipRect(polygon, expected, Rect(0.2f, 0.2f, 0.8f, 0.8f)); + + expected = MozPolygon{ + Point4D(0.2f, 0.2f, 0.0f, 1.0f), Point4D(0.2f, 0.8f, 0.0f, 1.0f), + Point4D(0.8f, 0.8f, 0.0f, 1.0f), Point4D(0.8f, 0.2f, 0.0f, 1.0f)}; + TestClipRect(polygon, expected, Rect(0.2f, 0.2f, 0.6f, 0.6f)); +} + +TEST(MozPolygon, ClipTriangle) +{ + MozPolygon clipped, expected; + const MozPolygon polygon{Point4D(0.0f, 0.0f, 0.0f, 1.0f), + Point4D(0.0f, 1.0f, 0.0f, 1.0f), + Point4D(1.0f, 1.0f, 0.0f, 1.0f)}; + + expected = MozPolygon{Point4D(0.0f, 0.0f, 0.0f, 1.0f), + Point4D(0.0f, 1.0f, 0.0f, 1.0f), + Point4D(1.0f, 1.0f, 0.0f, 1.0f)}; + TestClipRect(polygon, expected, Rect(0.0f, 0.0f, 1.0f, 1.0f)); + + expected = MozPolygon{Point4D(0.0f, 0.0f, 0.0f, 1.0f), + Point4D(0.0f, 0.8f, 0.0f, 1.0f), + Point4D(0.8f, 0.8f, 0.0f, 1.0f)}; + TestClipRect(polygon, expected, Rect(0.0f, 0.0f, 0.8f, 0.8f)); + + expected = MozPolygon{Point4D(0.2f, 0.2f, 0.0f, 1.0f), + Point4D(0.2f, 1.0f, 0.0f, 1.0f), + Point4D(1.0f, 1.0f, 0.0f, 1.0f)}; + TestClipRect(polygon, expected, Rect(0.2f, 0.2f, 0.8f, 0.8f)); + + expected = MozPolygon{Point4D(0.2f, 0.2f, 0.0f, 1.0f), + Point4D(0.2f, 0.8f, 0.0f, 1.0f), + Point4D(0.8f, 0.8f, 0.0f, 1.0f)}; + TestClipRect(polygon, expected, Rect(0.2f, 0.2f, 0.6f, 0.6f)); +} diff --git a/gfx/tests/gtest/TestQcms.cpp b/gfx/tests/gtest/TestQcms.cpp new file mode 100644 index 0000000000..de42ecff38 --- /dev/null +++ b/gfx/tests/gtest/TestQcms.cpp @@ -0,0 +1,410 @@ +/* vim:set ts=2 sw=2 sts=2 et: */ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +#include "gtest/gtest.h" +#include "gtest/MozGTestBench.h" +#include "gmock/gmock.h" + +#include "mozilla/ArrayUtils.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/SSE.h" +#include "mozilla/arm.h" +#include "qcms.h" +#include "qcmsint.h" + +#include <cmath> + +/* SSEv1 is only included in non-Windows or non-x86-64-bit builds. */ +#if defined(MOZILLA_MAY_SUPPORT_SSE) && \ + (!(defined(_MSC_VER) && defined(_M_AMD64))) +# define QCMS_MAY_SUPPORT_SSE +#endif + +using namespace mozilla; + +static bool CmpRgbChannel(const uint8_t* aRef, const uint8_t* aTest, + size_t aIndex) { + return std::abs(static_cast<int8_t>(aRef[aIndex] - aTest[aIndex])) <= 1; +} + +template <bool kSwapRB, bool kHasAlpha> +static bool CmpRgbBufferImpl(const uint8_t* aRefBuffer, + const uint8_t* aTestBuffer, size_t aPixels) { + const size_t pixelSize = kHasAlpha ? 4 : 3; + if (memcmp(aRefBuffer, aTestBuffer, aPixels * pixelSize) == 0) { + return true; + } + + const size_t kRIndex = kSwapRB ? 2 : 0; + const size_t kGIndex = 1; + const size_t kBIndex = kSwapRB ? 0 : 2; + const size_t kAIndex = 3; + + size_t remaining = aPixels; + const uint8_t* ref = aRefBuffer; + const uint8_t* test = aTestBuffer; + while (remaining > 0) { + if (!CmpRgbChannel(ref, test, kRIndex) || + !CmpRgbChannel(ref, test, kGIndex) || + !CmpRgbChannel(ref, test, kBIndex) || + (kHasAlpha && ref[kAIndex] != test[kAIndex])) { + EXPECT_EQ(test[kRIndex], ref[kRIndex]); + EXPECT_EQ(test[kGIndex], ref[kGIndex]); + EXPECT_EQ(test[kBIndex], ref[kBIndex]); + if (kHasAlpha) { + EXPECT_EQ(test[kAIndex], ref[kAIndex]); + } + return false; + } + + --remaining; + ref += pixelSize; + test += pixelSize; + } + + return true; +} + +template <bool kSwapRB, bool kHasAlpha> +static size_t GetRgbInputBufferImpl(UniquePtr<uint8_t[]>& aOutBuffer) { + const uint8_t colorSamples[] = {0, 5, 16, 43, 101, 127, 182, 255}; + const size_t colorSampleMax = sizeof(colorSamples) / sizeof(uint8_t); + const size_t pixelSize = kHasAlpha ? 4 : 3; + const size_t pixelCount = colorSampleMax * colorSampleMax * 256 * 3; + + aOutBuffer = MakeUnique<uint8_t[]>(pixelCount * pixelSize); + if (!aOutBuffer) { + return 0; + } + + const size_t kRIndex = kSwapRB ? 2 : 0; + const size_t kGIndex = 1; + const size_t kBIndex = kSwapRB ? 0 : 2; + const size_t kAIndex = 3; + + // Sample every red pixel value with a subset of green and blue. + uint8_t* color = aOutBuffer.get(); + for (uint16_t r = 0; r < 256; ++r) { + for (uint8_t g : colorSamples) { + for (uint8_t b : colorSamples) { + color[kRIndex] = r; + color[kGIndex] = g; + color[kBIndex] = b; + if (kHasAlpha) { + color[kAIndex] = 0x80; + } + color += pixelSize; + } + } + } + + // Sample every green pixel value with a subset of red and blue. + for (uint8_t r : colorSamples) { + for (uint16_t g = 0; g < 256; ++g) { + for (uint8_t b : colorSamples) { + color[kRIndex] = r; + color[kGIndex] = g; + color[kBIndex] = b; + if (kHasAlpha) { + color[kAIndex] = 0x80; + } + color += pixelSize; + } + } + } + + // Sample every blue pixel value with a subset of red and green. + for (uint8_t r : colorSamples) { + for (uint8_t g : colorSamples) { + for (uint16_t b = 0; b < 256; ++b) { + color[kRIndex] = r; + color[kGIndex] = g; + color[kBIndex] = b; + if (kHasAlpha) { + color[kAIndex] = 0x80; + } + color += pixelSize; + } + } + } + + return pixelCount; +} + +static size_t GetRgbInputBuffer(UniquePtr<uint8_t[]>& aOutBuffer) { + return GetRgbInputBufferImpl<false, false>(aOutBuffer); +} + +static size_t GetRgbaInputBuffer(UniquePtr<uint8_t[]>& aOutBuffer) { + return GetRgbInputBufferImpl<false, true>(aOutBuffer); +} + +static size_t GetBgraInputBuffer(UniquePtr<uint8_t[]>& aOutBuffer) { + return GetRgbInputBufferImpl<true, true>(aOutBuffer); +} + +static bool CmpRgbBuffer(const uint8_t* aRefBuffer, const uint8_t* aTestBuffer, + size_t aPixels) { + return CmpRgbBufferImpl<false, false>(aRefBuffer, aTestBuffer, aPixels); +} + +static bool CmpRgbaBuffer(const uint8_t* aRefBuffer, const uint8_t* aTestBuffer, + size_t aPixels) { + return CmpRgbBufferImpl<false, true>(aRefBuffer, aTestBuffer, aPixels); +} + +static bool CmpBgraBuffer(const uint8_t* aRefBuffer, const uint8_t* aTestBuffer, + size_t aPixels) { + return CmpRgbBufferImpl<true, true>(aRefBuffer, aTestBuffer, aPixels); +} + +static void ClearRgbBuffer(uint8_t* aBuffer, size_t aPixels) { + if (aBuffer) { + memset(aBuffer, 0, aPixels * 3); + } +} + +static void ClearRgbaBuffer(uint8_t* aBuffer, size_t aPixels) { + if (aBuffer) { + memset(aBuffer, 0, aPixels * 4); + } +} + +static UniquePtr<uint8_t[]> GetRgbOutputBuffer(size_t aPixels) { + UniquePtr<uint8_t[]> buffer = MakeUnique<uint8_t[]>(aPixels * 3); + ClearRgbBuffer(buffer.get(), aPixels); + return buffer; +} + +static UniquePtr<uint8_t[]> GetRgbaOutputBuffer(size_t aPixels) { + UniquePtr<uint8_t[]> buffer = MakeUnique<uint8_t[]>(aPixels * 4); + ClearRgbaBuffer(buffer.get(), aPixels); + return buffer; +} + +class GfxQcms_ProfilePairBase : public ::testing::Test { + protected: + GfxQcms_ProfilePairBase() + : mInProfile(nullptr), + mOutProfile(nullptr), + mTransform(nullptr), + mPixels(0), + mStorageType(QCMS_DATA_RGB_8), + mPrecache(false) {} + + void SetUp() override { + // XXX: This means that we can't have qcms v2 unit test + // without changing the qcms API. + qcms_enable_iccv4(); + } + + void TearDown() override { + if (mInProfile) { + qcms_profile_release(mInProfile); + } + if (mOutProfile) { + qcms_profile_release(mOutProfile); + } + if (mTransform) { + qcms_transform_release(mTransform); + } + } + + bool SetTransform(qcms_transform* aTransform) { + if (mTransform) { + qcms_transform_release(mTransform); + } + mTransform = aTransform; + return !!mTransform; + } + + bool SetTransform(qcms_data_type aType) { + return SetTransform(qcms_transform_create(mInProfile, aType, mOutProfile, + aType, QCMS_INTENT_DEFAULT)); + } + + bool SetBuffers(qcms_data_type aType) { + switch (aType) { + case QCMS_DATA_RGB_8: + mPixels = GetRgbInputBuffer(mInput); + mRef = GetRgbOutputBuffer(mPixels); + mOutput = GetRgbOutputBuffer(mPixels); + break; + case QCMS_DATA_RGBA_8: + mPixels = GetRgbaInputBuffer(mInput); + mRef = GetRgbaOutputBuffer(mPixels); + mOutput = GetRgbaOutputBuffer(mPixels); + break; + case QCMS_DATA_BGRA_8: + mPixels = GetBgraInputBuffer(mInput); + mRef = GetRgbaOutputBuffer(mPixels); + mOutput = GetRgbaOutputBuffer(mPixels); + break; + default: + MOZ_ASSERT_UNREACHABLE("Unknown type!"); + break; + } + + mStorageType = aType; + return mInput && mOutput && mRef && mPixels > 0u; + } + + void ClearOutputBuffer() { + switch (mStorageType) { + case QCMS_DATA_RGB_8: + ClearRgbBuffer(mOutput.get(), mPixels); + break; + case QCMS_DATA_RGBA_8: + case QCMS_DATA_BGRA_8: + ClearRgbaBuffer(mOutput.get(), mPixels); + break; + default: + MOZ_ASSERT_UNREACHABLE("Unknown type!"); + break; + } + } + + void ProduceRef(transform_fn_t aFn) { + aFn(mTransform, mInput.get(), mRef.get(), mPixels); + } + + void CopyInputToRef() { + size_t pixelSize = 0; + switch (mStorageType) { + case QCMS_DATA_RGB_8: + pixelSize = 3; + break; + case QCMS_DATA_RGBA_8: + case QCMS_DATA_BGRA_8: + pixelSize = 4; + break; + default: + MOZ_ASSERT_UNREACHABLE("Unknown type!"); + break; + } + + memcpy(mRef.get(), mInput.get(), mPixels * pixelSize); + } + + void ProduceOutput(transform_fn_t aFn) { + ClearOutputBuffer(); + aFn(mTransform, mInput.get(), mOutput.get(), mPixels); + } + + bool VerifyOutput(const UniquePtr<uint8_t[]>& aBuf) { + switch (mStorageType) { + case QCMS_DATA_RGB_8: + return CmpRgbBuffer(aBuf.get(), mOutput.get(), mPixels); + case QCMS_DATA_RGBA_8: + return CmpRgbaBuffer(aBuf.get(), mOutput.get(), mPixels); + case QCMS_DATA_BGRA_8: + return CmpBgraBuffer(aBuf.get(), mOutput.get(), mPixels); + default: + MOZ_ASSERT_UNREACHABLE("Unknown type!"); + break; + } + + return false; + } + + bool ProduceVerifyOutput(transform_fn_t aFn) { + ProduceOutput(aFn); + return VerifyOutput(mRef); + } + + void PrecacheOutput() { + qcms_profile_precache_output_transform(mOutProfile); + mPrecache = true; + } + + qcms_profile* mInProfile; + qcms_profile* mOutProfile; + qcms_transform* mTransform; + + UniquePtr<uint8_t[]> mInput; + UniquePtr<uint8_t[]> mOutput; + UniquePtr<uint8_t[]> mRef; + size_t mPixels; + qcms_data_type mStorageType; + bool mPrecache; +}; + +class GfxQcms_sRGB_To_sRGB : public GfxQcms_ProfilePairBase { + protected: + void SetUp() override { + GfxQcms_ProfilePairBase::SetUp(); + mInProfile = qcms_profile_sRGB(); + mOutProfile = qcms_profile_sRGB(); + } +}; + +class GfxQcms_sRGB_To_SamsungSyncmaster : public GfxQcms_ProfilePairBase { + protected: + void SetUp() override { + GfxQcms_ProfilePairBase::SetUp(); + mInProfile = qcms_profile_sRGB(); + mOutProfile = qcms_profile_from_path("lcms_samsung_syncmaster.icc"); + } +}; + +class GfxQcms_sRGB_To_ThinkpadW540 : public GfxQcms_ProfilePairBase { + protected: + void SetUp() override { + GfxQcms_ProfilePairBase::SetUp(); + mInProfile = qcms_profile_sRGB(); + mOutProfile = qcms_profile_from_path("lcms_thinkpad_w540.icc"); + } +}; + +TEST_F(GfxQcms_sRGB_To_sRGB, TransformIdentity) { + PrecacheOutput(); + SetBuffers(QCMS_DATA_RGB_8); + SetTransform(QCMS_DATA_RGB_8); + qcms_transform_data(mTransform, mInput.get(), mOutput.get(), mPixels); + EXPECT_TRUE(VerifyOutput(mInput)); +} + +class GfxQcmsPerf_Base : public GfxQcms_sRGB_To_ThinkpadW540 { + protected: + explicit GfxQcmsPerf_Base(qcms_data_type aType) { mStorageType = aType; } + + void TransformPerf() { ProduceRef(qcms_transform_data_rgb_out_lut_precache); } + + void TransformPlatformPerf() { + qcms_transform_data(mTransform, mInput.get(), mRef.get(), mPixels); + } + + void SetUp() override { + GfxQcms_sRGB_To_ThinkpadW540::SetUp(); + PrecacheOutput(); + SetBuffers(mStorageType); + SetTransform(mStorageType); + } +}; + +class GfxQcmsPerf_Rgb : public GfxQcmsPerf_Base { + protected: + GfxQcmsPerf_Rgb() : GfxQcmsPerf_Base(QCMS_DATA_RGB_8) {} +}; + +class GfxQcmsPerf_Rgba : public GfxQcmsPerf_Base { + protected: + GfxQcmsPerf_Rgba() : GfxQcmsPerf_Base(QCMS_DATA_RGBA_8) {} +}; + +class GfxQcmsPerf_Bgra : public GfxQcmsPerf_Base { + protected: + GfxQcmsPerf_Bgra() : GfxQcmsPerf_Base(QCMS_DATA_BGRA_8) {} +}; + +MOZ_GTEST_BENCH_F(GfxQcmsPerf_Rgb, TransformC, [this] { TransformPerf(); }); +MOZ_GTEST_BENCH_F(GfxQcmsPerf_Rgb, TransformPlatform, + [this] { TransformPlatformPerf(); }); +MOZ_GTEST_BENCH_F(GfxQcmsPerf_Rgba, TransformC, [this] { TransformPerf(); }); +MOZ_GTEST_BENCH_F(GfxQcmsPerf_Rgba, TransformPlatform, + [this] { TransformPlatformPerf(); }); +MOZ_GTEST_BENCH_F(GfxQcmsPerf_Bgra, TransformC, [this] { TransformPerf(); }); +MOZ_GTEST_BENCH_F(GfxQcmsPerf_Bgra, TransformPlatform, + [this] { TransformPlatformPerf(); }); diff --git a/gfx/tests/gtest/TestRect.cpp b/gfx/tests/gtest/TestRect.cpp new file mode 100644 index 0000000000..886f5cb031 --- /dev/null +++ b/gfx/tests/gtest/TestRect.cpp @@ -0,0 +1,667 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +#include <limits> + +#include "gtest/gtest.h" + +#include "gfxTypes.h" +#include "nsRect.h" +#include "nsRectAbsolute.h" +#include "gfxRect.h" +#include "mozilla/gfx/Rect.h" +#include "mozilla/gfx/RectAbsolute.h" +#include "mozilla/WritingModes.h" +#ifdef XP_WIN +# include <windows.h> +#endif + +using mozilla::gfx::IntRect; +using mozilla::gfx::IntRectAbsolute; + +template <class RectType> +static bool TestConstructors() { + // Create a rectangle + RectType rect1(10, 20, 30, 40); + + // Make sure the rectangle was properly initialized + EXPECT_TRUE(rect1.IsEqualRect(10, 20, 30, 40) && rect1.IsEqualXY(10, 20) && + rect1.IsEqualSize(30, 40)) + << "[1] Make sure the rectangle was properly initialized with " + "constructor"; + + // Create a second rect using the copy constructor + RectType rect2(rect1); + + // Make sure the rectangle was properly initialized + EXPECT_TRUE(rect2.IsEqualEdges(rect1) && + rect2.IsEqualXY(rect1.X(), rect1.Y()) && + rect2.IsEqualSize(rect1.Width(), rect1.Height())) + << "[2] Make sure the rectangle was properly initialized with copy " + "constructor"; + + EXPECT_TRUE(!rect1.IsEmpty() && !rect1.IsZeroArea() && rect1.IsFinite() && + !rect2.IsEmpty() && !rect2.IsZeroArea() && rect2.IsFinite()) + << "[3] These rectangles are not empty and are finite"; + + rect1.SetRect(1, 2, 30, 40); + EXPECT_TRUE(rect1.X() == 1 && rect1.Y() == 2 && rect1.Width() == 30 && + rect1.Height() == 40 && rect1.XMost() == 31 && + rect1.YMost() == 42); + + rect1.SetRectX(11, 50); + EXPECT_TRUE(rect1.X() == 11 && rect1.Y() == 2 && rect1.Width() == 50 && + rect1.Height() == 40 && rect1.XMost() == 61 && + rect1.YMost() == 42); + + rect1.SetRectY(22, 60); + EXPECT_TRUE(rect1.X() == 11 && rect1.Y() == 22 && rect1.Width() == 50 && + rect1.Height() == 60 && rect1.XMost() == 61 && + rect1.YMost() == 82); + + rect1.SetBox(1, 2, 31, 42); + EXPECT_TRUE(rect1.X() == 1 && rect1.Y() == 2 && rect1.Width() == 30 && + rect1.Height() == 40 && rect1.XMost() == 31 && + rect1.YMost() == 42); + + rect1.SetBoxX(11, 61); + EXPECT_TRUE(rect1.X() == 11 && rect1.Y() == 2 && rect1.Width() == 50 && + rect1.Height() == 40 && rect1.XMost() == 61 && + rect1.YMost() == 42); + + rect1.SetBoxY(22, 82); + EXPECT_TRUE(rect1.X() == 11 && rect1.Y() == 22 && rect1.Width() == 50 && + rect1.Height() == 60 && rect1.XMost() == 61 && + rect1.YMost() == 82); + + rect1.SetRect(1, 2, 30, 40); + EXPECT_TRUE(rect1.X() == 1 && rect1.Y() == 2 && rect1.Width() == 30 && + rect1.Height() == 40 && rect1.XMost() == 31 && + rect1.YMost() == 42); + + rect1.MoveByX(10); + EXPECT_TRUE(rect1.X() == 11 && rect1.Y() == 2 && rect1.Width() == 30 && + rect1.Height() == 40 && rect1.XMost() == 41 && + rect1.YMost() == 42); + + rect1.MoveByY(20); + EXPECT_TRUE(rect1.X() == 11 && rect1.Y() == 22 && rect1.Width() == 30 && + rect1.Height() == 40 && rect1.XMost() == 41 && + rect1.YMost() == 62); + + return true; +} + +template <class RectType> +static bool TestEqualityOperator() { + RectType rect1(10, 20, 30, 40); + RectType rect2(rect1); + + // Test the equality operator + EXPECT_TRUE(rect1 == rect2) << "[1] Test the equality operator"; + + EXPECT_FALSE(!rect1.IsEqualInterior(rect2)) + << "[2] Test the inequality operator"; + + // Make sure that two empty rects are equal + rect1.SetEmpty(); + rect2.SetEmpty(); + EXPECT_TRUE(rect1 == rect2) << "[3] Make sure that two empty rects are equal"; + + return true; +} + +template <class RectType> +static bool TestContainment() { + RectType rect1(10, 10, 50, 50); + + // Test the point containment methods + // + + // Basic test of a point in the middle of the rect + EXPECT_TRUE(rect1.Contains(rect1.Center()) && + rect1.ContainsX(rect1.Center().x) && + rect1.ContainsY(rect1.Center().y)) + << "[1] Basic test of a point in the middle of the rect"; + + // Test against a point at the left/top edges + EXPECT_TRUE(rect1.Contains(rect1.X(), rect1.Y()) && + rect1.ContainsX(rect1.X()) && rect1.ContainsY(rect1.Y())) + << "[2] Test against a point at the left/top edges"; + + // Test against a point at the right/bottom extents + EXPECT_FALSE(rect1.Contains(rect1.XMost(), rect1.YMost()) || + rect1.ContainsX(rect1.XMost()) || rect1.ContainsY(rect1.YMost())) + << "[3] Test against a point at the right/bottom extents"; + + // Test the rect containment methods + // + RectType rect2(rect1); + + // Test against a rect that's the same as rect1 + EXPECT_FALSE(!rect1.Contains(rect2)) + << "[4] Test against a rect that's the same as rect1"; + + // Test against a rect whose left edge (only) is outside of rect1 + rect2.MoveByX(-1); + EXPECT_FALSE(rect1.Contains(rect2)) + << "[5] Test against a rect whose left edge (only) is outside of rect1"; + rect2.MoveByX(1); + + // Test against a rect whose top edge (only) is outside of rect1 + rect2.MoveByY(-1); + EXPECT_FALSE(rect1.Contains(rect2)) + << "[6] Test against a rect whose top edge (only) is outside of rect1"; + rect2.MoveByY(1); + + // Test against a rect whose right edge (only) is outside of rect1 + rect2.MoveByX(1); + EXPECT_FALSE(rect1.Contains(rect2)) + << "[7] Test against a rect whose right edge (only) is outside of rect1"; + rect2.MoveByX(-1); + + // Test against a rect whose bottom edge (only) is outside of rect1 + rect2.MoveByY(1); + EXPECT_FALSE(rect1.Contains(rect2)) + << "[8] Test against a rect whose bottom edge (only) is outside of rect1"; + rect2.MoveByY(-1); + + return true; +} + +// Test the method that returns a boolean result but doesn't return a +// a rectangle +template <class RectType> +static bool TestIntersects() { + RectType rect1(10, 10, 50, 50); + RectType rect2(rect1); + + // Test against a rect that's the same as rect1 + EXPECT_FALSE(!rect1.Intersects(rect2)) + << "[1] Test against a rect that's the same as rect1"; + + // Test against a rect that's enclosed by rect1 + rect2.Inflate(-1, -1); + EXPECT_FALSE(!rect1.Contains(rect2) || !rect1.Intersects(rect2)) + << "[2] Test against a rect that's enclosed by rect1"; + rect2.Inflate(1, 1); + + // Make sure inflate and deflate worked correctly + EXPECT_TRUE(rect1.IsEqualInterior(rect2)) + << "[3] Make sure inflate and deflate worked correctly"; + + // Test against a rect that overlaps the left edge of rect1 + rect2.MoveByX(-1); + EXPECT_FALSE(!rect1.Intersects(rect2)) + << "[4] Test against a rect that overlaps the left edge of rect1"; + rect2.MoveByX(1); + + // Test against a rect that's outside of rect1 on the left + rect2.MoveByX(-rect2.Width()); + EXPECT_FALSE(rect1.Intersects(rect2)) + << "[5] Test against a rect that's outside of rect1 on the left"; + rect2.MoveByX(rect2.Width()); + + // Test against a rect that overlaps the top edge of rect1 + rect2.MoveByY(-1); + EXPECT_FALSE(!rect1.Intersects(rect2)) + << "[6] Test against a rect that overlaps the top edge of rect1"; + rect2.MoveByY(1); + + // Test against a rect that's outside of rect1 on the top + rect2.MoveByY(-rect2.Height()); + EXPECT_FALSE(rect1.Intersects(rect2)) + << "[7] Test against a rect that's outside of rect1 on the top"; + rect2.MoveByY(rect2.Height()); + + // Test against a rect that overlaps the right edge of rect1 + rect2.MoveByX(1); + EXPECT_FALSE(!rect1.Intersects(rect2)) + << "[8] Test against a rect that overlaps the right edge of rect1"; + rect2.MoveByX(-1); + + // Test against a rect that's outside of rect1 on the right + rect2.MoveByX(rect2.Width()); + EXPECT_FALSE(rect1.Intersects(rect2)) + << "[9] Test against a rect that's outside of rect1 on the right"; + rect2.MoveByX(-rect2.Width()); + + // Test against a rect that overlaps the bottom edge of rect1 + rect2.MoveByY(1); + EXPECT_FALSE(!rect1.Intersects(rect2)) + << "[10] Test against a rect that overlaps the bottom edge of rect1"; + rect2.MoveByY(-1); + + // Test against a rect that's outside of rect1 on the bottom + rect2.MoveByY(rect2.Height()); + EXPECT_FALSE(rect1.Intersects(rect2)) + << "[11] Test against a rect that's outside of rect1 on the bottom"; + rect2.MoveByY(-rect2.Height()); + + return true; +} + +// Test the method that returns a boolean result and an intersection rect +template <class RectType> +static bool TestIntersection() { + RectType rect1(10, 10, 50, 50); + RectType rect2(rect1); + RectType dest; + + // Test against a rect that's the same as rect1 + EXPECT_FALSE(!dest.IntersectRect(rect1, rect2) || + !(dest.IsEqualInterior(rect1))) + << "[1] Test against a rect that's the same as rect1"; + + // Test against a rect that's enclosed by rect1 + rect2.Inflate(-1, -1); + EXPECT_FALSE(!dest.IntersectRect(rect1, rect2) || + !(dest.IsEqualInterior(rect2))) + << "[2] Test against a rect that's enclosed by rect1"; + rect2.Inflate(1, 1); + + // Test against a rect that overlaps the left edge of rect1 + rect2.MoveByX(-1); + EXPECT_FALSE(!dest.IntersectRect(rect1, rect2) || + !(dest.IsEqualInterior(RectType( + rect1.X(), rect1.Y(), rect1.Width() - 1, rect1.Height())))) + << "[3] Test against a rect that overlaps the left edge of rect1"; + rect2.MoveByX(1); + + // Test against a rect that's outside of rect1 on the left + rect2.MoveByX(-rect2.Width()); + EXPECT_FALSE(dest.IntersectRect(rect1, rect2)) + << "[4] Test against a rect that's outside of rect1 on the left"; + // Make sure an empty rect is returned + EXPECT_TRUE(dest.IsEmpty() && dest.IsZeroArea()) + << "[4] Make sure an empty rect is returned"; + EXPECT_TRUE(dest.IsFinite()) << "[4b] Should be finite"; + rect2.MoveByX(rect2.Width()); + + // Test against a rect that overlaps the top edge of rect1 + rect2.MoveByY(-1); + EXPECT_FALSE(!dest.IntersectRect(rect1, rect2) || + !(dest.IsEqualInterior(RectType( + rect1.X(), rect1.Y(), rect1.Width(), rect1.Height() - 1)))) + << "[5] Test against a rect that overlaps the top edge of rect1"; + EXPECT_TRUE(dest.IsFinite()) << "[5b] Should be finite"; + rect2.MoveByY(1); + + // Test against a rect that's outside of rect1 on the top + rect2.MoveByY(-rect2.Height()); + EXPECT_FALSE(dest.IntersectRect(rect1, rect2)) + << "[6] Test against a rect that's outside of rect1 on the top"; + // Make sure an empty rect is returned + EXPECT_TRUE(dest.IsEmpty() && dest.IsZeroArea()) + << "[6] Make sure an empty rect is returned"; + EXPECT_TRUE(dest.IsFinite()) << "[6b] Should be finite"; + rect2.MoveByY(rect2.Height()); + + // Test against a rect that overlaps the right edge of rect1 + rect2.MoveByX(1); + EXPECT_FALSE( + !dest.IntersectRect(rect1, rect2) || + !(dest.IsEqualInterior(RectType(rect1.X() + 1, rect1.Y(), + rect1.Width() - 1, rect1.Height())))) + << "[7] Test against a rect that overlaps the right edge of rect1"; + rect2.MoveByX(-1); + + // Test against a rect that's outside of rect1 on the right + rect2.MoveByX(rect2.Width()); + EXPECT_FALSE(dest.IntersectRect(rect1, rect2)) + << "[8] Test against a rect that's outside of rect1 on the right"; + // Make sure an empty rect is returned + EXPECT_TRUE(dest.IsEmpty() && dest.IsZeroArea()) + << "[8] Make sure an empty rect is returned"; + EXPECT_TRUE(dest.IsFinite()) << "[8b] Should be finite"; + rect2.MoveByX(-rect2.Width()); + + // Test against a rect that overlaps the bottom edge of rect1 + rect2.MoveByY(1); + EXPECT_FALSE( + !dest.IntersectRect(rect1, rect2) || + !(dest.IsEqualInterior(RectType(rect1.X(), rect1.Y() + 1, rect1.Width(), + rect1.Height() - 1)))) + << "[9] Test against a rect that overlaps the bottom edge of rect1"; + EXPECT_TRUE(dest.IsFinite()) << "[9b] Should be finite"; + rect2.MoveByY(-1); + + // Test against a rect that's outside of rect1 on the bottom + rect2.MoveByY(rect2.Height()); + EXPECT_FALSE(dest.IntersectRect(rect1, rect2)) + << "[10] Test against a rect that's outside of rect1 on the bottom"; + // Make sure an empty rect is returned + EXPECT_TRUE(dest.IsEmpty() && dest.IsZeroArea()) + << "[10] Make sure an empty rect is returned"; + EXPECT_TRUE(dest.IsFinite()) << "[10b] Should be finite"; + rect2.MoveByY(-rect2.Height()); + + // Test against a rect with zero width or height + rect1.SetRect(100, 100, 100, 100); + rect2.SetRect(150, 100, 0, 100); + EXPECT_TRUE(!dest.IntersectRect(rect1, rect2) && dest.IsEmpty() && + dest.IsZeroArea()) + << "[11] Intersection of rects with zero width or height should be empty"; + EXPECT_TRUE(dest.IsFinite()) << "[11b] Should be finite"; + + // Tests against a rect with negative width or height + // + + // Test against a rect with negative width + rect1.SetRect(100, 100, 100, 100); + rect2.SetRect(100, 100, -100, 100); + EXPECT_TRUE(!dest.IntersectRect(rect1, rect2) && dest.IsEmpty() && + dest.IsZeroArea()) + << "[12] Intersection of rects with negative width or height should be " + "empty"; + EXPECT_TRUE(dest.IsFinite()) << "[12b] Should be finite"; + + // Those two rects exactly overlap in some way... + // but we still want to return an empty rect + rect1.SetRect(100, 100, 100, 100); + rect2.SetRect(200, 200, -100, -100); + EXPECT_TRUE(!dest.IntersectRect(rect1, rect2) && dest.IsEmpty() && + dest.IsZeroArea()) + << "[13] Intersection of rects with negative width or height should be " + "empty"; + EXPECT_TRUE(dest.IsFinite()) << "[13b] Should be finite"; + + // Test against two identical rects with negative height + rect1.SetRect(100, 100, 100, -100); + rect2.SetRect(100, 100, 100, -100); + EXPECT_TRUE(!dest.IntersectRect(rect1, rect2) && dest.IsEmpty() && + dest.IsZeroArea()) + << "[14] Intersection of rects with negative width or height should be " + "empty"; + EXPECT_TRUE(dest.IsFinite()) << "[14b] Should be finite"; + + return true; +} + +template <class RectType> +static bool TestUnion() { + RectType rect1; + RectType rect2(10, 10, 50, 50); + RectType dest; + + // Check the case where the receiver is an empty rect + rect1.SetEmpty(); + dest.UnionRect(rect1, rect2); + EXPECT_TRUE(!dest.IsEmpty() && !dest.IsZeroArea() && + dest.IsEqualInterior(rect2)) + << "[1] Check the case where the receiver is an empty rect"; + EXPECT_TRUE(dest.IsFinite()) << "[1b] Should be finite"; + + // Check the case where the source rect is an empty rect + rect1 = rect2; + rect2.SetEmpty(); + dest.UnionRect(rect1, rect2); + EXPECT_TRUE(!dest.IsEmpty() && !dest.IsZeroArea() && + dest.IsEqualInterior(rect1)) + << "[2] Check the case where the source rect is an empty rect"; + EXPECT_TRUE(dest.IsFinite()) << "[2b] Should be finite"; + + // Test the case where both rects are empty + rect1.SetEmpty(); + rect2.SetEmpty(); + dest.UnionRect(rect1, rect2); + EXPECT_TRUE(dest.IsEmpty() && dest.IsZeroArea()) + << "[3] Test the case where both rects are empty"; + EXPECT_TRUE(dest.IsFinite()) << "[3b] Should be finite"; + + // Test union case where the two rects don't overlap at all + rect1.SetRect(10, 10, 50, 50); + rect2.SetRect(100, 100, 50, 50); + dest.UnionRect(rect1, rect2); + EXPECT_TRUE(!dest.IsEmpty() && !dest.IsZeroArea() && + (dest.IsEqualInterior(RectType(rect1.X(), rect1.Y(), + rect2.XMost() - rect1.X(), + rect2.YMost() - rect1.Y())))) + << "[4] Test union case where the two rects don't overlap at all"; + EXPECT_TRUE(dest.IsFinite()) << "[4b] Should be finite"; + + // Test union case where the two rects overlap + rect1.SetRect(30, 30, 50, 50); + rect2.SetRect(10, 10, 50, 50); + dest.UnionRect(rect1, rect2); + EXPECT_TRUE(!dest.IsEmpty() && !dest.IsZeroArea() && + (dest.IsEqualInterior(RectType(rect2.X(), rect2.Y(), + rect1.XMost() - rect2.X(), + rect1.YMost() - rect2.Y())))) + << "[5] Test union case where the two rects overlap"; + EXPECT_TRUE(dest.IsFinite()) << "[5b] Should be finite"; + + return true; +} + +template <class RectType> +static void TestUnionEmptyRects() { + RectType rect1(10, 10, 0, 50); + RectType rect2(5, 5, 40, 0); + EXPECT_TRUE(rect1.IsEmpty() && rect2.IsEmpty()); + + RectType dest = rect1.Union(rect2); + EXPECT_TRUE(dest.IsEmpty() && dest.IsEqualEdges(rect2)) + << "Test the case where both rects are empty, and the result is the " + "same value passing into Union()"; +} + +static bool TestFiniteGfx() { + float posInf = std::numeric_limits<float>::infinity(); + float negInf = -std::numeric_limits<float>::infinity(); + float justNaN = std::numeric_limits<float>::quiet_NaN(); + + gfxFloat values[4] = {5.0, 10.0, 15.0, 20.0}; + + // Try the "non-finite" values for x, y, width, height, one at a time + for (int i = 0; i < 4; i += 1) { + values[i] = posInf; + gfxRect rectPosInf(values[0], values[1], values[2], values[3]); + EXPECT_FALSE(rectPosInf.IsFinite()) + << "For +inf (" << values[0] << "," << values[1] << "," << values[2] + << "," << values[3] << ")"; + + values[i] = negInf; + gfxRect rectNegInf(values[0], values[1], values[2], values[3]); + EXPECT_FALSE(rectNegInf.IsFinite()) + << "For -inf (" << values[0] << "," << values[1] << "," << values[2] + << "," << values[3] << ")"; + + values[i] = justNaN; + gfxRect rectNaN(values[0], values[1], values[2], values[3]); + EXPECT_FALSE(rectNaN.IsFinite()) + << "For NaN (" << values[0] << "," << values[1] << "," << values[2] + << "," << values[3] << ")"; + + // Reset to a finite value... + values[i] = 5.0 * i; + } + + return true; +} + +// We want to test nsRect values that are still in range but where +// the implementation is at risk of overflowing +template <class RectType> +static bool TestBug1135677() { + RectType rect1(1073741344, 1073741344, 1073756696, 1073819936); + RectType rect2(1073741820, 1073741820, 14400, 77640); + RectType dest; + + dest = rect1.Intersect(rect2); + + EXPECT_TRUE(dest.IsEqualRect(1073741820, 1073741820, 14400, 77640)) + << "[1] Operation should not overflow internally."; + + return true; +} + +template <class RectType> +static bool TestSetWH() { + RectType rect(1, 2, 3, 4); + EXPECT_TRUE(rect.IsEqualRect(1, 2, 3, 4)); + rect.SetWidth(13); + EXPECT_TRUE(rect.IsEqualRect(1, 2, 13, 4)); + rect.SetHeight(14); + EXPECT_TRUE(rect.IsEqualRect(1, 2, 13, 14)); + rect.SizeTo(23, 24); + EXPECT_TRUE(rect.IsEqualRect(1, 2, 23, 24)); + return true; +} + +template <class RectType> +static bool TestSwap() { + RectType rect(1, 2, 3, 4); + EXPECT_TRUE(rect.IsEqualRect(1, 2, 3, 4)); + rect.Swap(); + EXPECT_TRUE(rect.IsEqualRect(2, 1, 4, 3)); + return true; +} + +static void TestIntersectionLogicalHelper(nscoord x1, nscoord y1, nscoord w1, + nscoord h1, nscoord x2, nscoord y2, + nscoord w2, nscoord h2, nscoord xR, + nscoord yR, nscoord wR, nscoord hR, + bool isNonEmpty) { + nsRect rect1(x1, y1, w1, h1); + nsRect rect2(x2, y2, w2, h2); + nsRect rectDebug; + EXPECT_TRUE(isNonEmpty == rectDebug.IntersectRect(rect1, rect2)); + EXPECT_TRUE(rectDebug.IsEqualEdges(nsRect(xR, yR, wR, hR))); + + mozilla::LogicalRect r1(mozilla::WritingMode(), rect1.X(), rect1.Y(), + rect1.Width(), rect1.Height()); + mozilla::LogicalRect r2(mozilla::WritingMode(), rect2.X(), rect2.Y(), + rect2.Width(), rect2.Height()); + EXPECT_TRUE(isNonEmpty == r1.IntersectRect(r1, r2)); + EXPECT_TRUE(rectDebug.IsEqualEdges(nsRect( + r1.IStart(mozilla::WritingMode()), r1.BStart(mozilla::WritingMode()), + r1.ISize(mozilla::WritingMode()), r1.BSize(mozilla::WritingMode())))); + + mozilla::LogicalRect r3(mozilla::WritingMode(), rect1.X(), rect1.Y(), + rect1.Width(), rect1.Height()); + mozilla::LogicalRect r4(mozilla::WritingMode(), rect2.X(), rect2.Y(), + rect2.Width(), rect2.Height()); + EXPECT_TRUE(isNonEmpty == r4.IntersectRect(r3, r4)); + EXPECT_TRUE(rectDebug.IsEqualEdges(nsRect( + r4.IStart(mozilla::WritingMode()), r4.BStart(mozilla::WritingMode()), + r4.ISize(mozilla::WritingMode()), r4.BSize(mozilla::WritingMode())))); + + mozilla::LogicalRect r5(mozilla::WritingMode(), rect1.X(), rect1.Y(), + rect1.Width(), rect1.Height()); + mozilla::LogicalRect r6(mozilla::WritingMode(), rect2.X(), rect2.Y(), + rect2.Width(), rect2.Height()); + mozilla::LogicalRect r7(mozilla::WritingMode(), 0, 0, 1, 1); + EXPECT_TRUE(isNonEmpty == r7.IntersectRect(r5, r6)); + EXPECT_TRUE(rectDebug.IsEqualEdges(nsRect( + r7.IStart(mozilla::WritingMode()), r7.BStart(mozilla::WritingMode()), + r7.ISize(mozilla::WritingMode()), r7.BSize(mozilla::WritingMode())))); +} + +static void TestIntersectionLogical(nscoord x1, nscoord y1, nscoord w1, + nscoord h1, nscoord x2, nscoord y2, + nscoord w2, nscoord h2, nscoord xR, + nscoord yR, nscoord wR, nscoord hR, + bool isNonEmpty) { + TestIntersectionLogicalHelper(x1, y1, w1, h1, x2, y2, w2, h2, xR, yR, wR, hR, + isNonEmpty); + TestIntersectionLogicalHelper(x2, y2, w2, h2, x1, y1, w1, h1, xR, yR, wR, hR, + isNonEmpty); +} + +TEST(Gfx, Logical) +{ + TestIntersectionLogical(578, 0, 2650, 1152, 1036, 0, 2312, 1, 1036, 0, 2192, + 1, true); + TestIntersectionLogical(0, 0, 1000, 1000, 500, 500, 1000, 1000, 500, 500, 500, + 500, true); + TestIntersectionLogical(100, 200, 300, 400, 50, 250, 100, 100, 100, 250, 50, + 100, true); + TestIntersectionLogical(0, 100, 200, 300, 300, 100, 100, 300, 300, 100, 0, 0, + false); +} + +TEST(Gfx, nsRect) +{ + TestConstructors<nsRect>(); + TestEqualityOperator<nsRect>(); + TestContainment<nsRect>(); + TestIntersects<nsRect>(); + TestIntersection<nsRect>(); + TestUnion<nsRect>(); + TestUnionEmptyRects<nsRect>(); + TestBug1135677<nsRect>(); + TestSetWH<nsRect>(); + TestSwap<nsRect>(); +} + +TEST(Gfx, nsIntRect) +{ + TestConstructors<nsIntRect>(); + TestEqualityOperator<nsIntRect>(); + TestContainment<nsIntRect>(); + TestIntersects<nsIntRect>(); + TestIntersection<nsIntRect>(); + TestUnion<nsIntRect>(); + TestUnionEmptyRects<nsIntRect>(); + TestBug1135677<nsIntRect>(); + TestSetWH<nsIntRect>(); + TestSwap<nsIntRect>(); +} + +TEST(Gfx, gfxRect) +{ + TestConstructors<gfxRect>(); + // Skip TestEqualityOperator<gfxRect>(); as gfxRect::operator== is private + TestContainment<gfxRect>(); + TestIntersects<gfxRect>(); + TestIntersection<gfxRect>(); + TestUnion<gfxRect>(); + TestUnionEmptyRects<gfxRect>(); + TestBug1135677<gfxRect>(); + TestFiniteGfx(); + TestSetWH<gfxRect>(); + TestSwap<gfxRect>(); +} + +TEST(Gfx, nsRectAbsolute) +{ TestUnionEmptyRects<nsRectAbsolute>(); } + +TEST(Gfx, IntRectAbsolute) +{ TestUnionEmptyRects<IntRectAbsolute>(); } + +static void TestMoveInsideAndClamp(IntRect aSrc, IntRect aTarget, + IntRect aExpected) { + // Test the implementation in BaseRect (x/y/width/height representation) + IntRect result = aSrc.MoveInsideAndClamp(aTarget); + EXPECT_TRUE(result.IsEqualEdges(aExpected)) + << "Source " << aSrc << " Target " << aTarget << " Expected " << aExpected + << " Actual " << result; + + // Also test the implementation in RectAbsolute (left/top/right/bottom + // representation) + IntRectAbsolute absSrc = IntRectAbsolute::FromRect(aSrc); + IntRectAbsolute absTarget = IntRectAbsolute::FromRect(aTarget); + IntRectAbsolute absExpected = IntRectAbsolute::FromRect(aExpected); + + IntRectAbsolute absResult = absSrc.MoveInsideAndClamp(absTarget); + EXPECT_TRUE(absResult.IsEqualEdges(absExpected)) + << "AbsSource " << absSrc << " AbsTarget " << absTarget << " AbsExpected " + << absExpected << " AbsActual " << absResult; +} + +TEST(Gfx, MoveInsideAndClamp) +{ + TestMoveInsideAndClamp(IntRect(0, 0, 10, 10), IntRect(1, -1, 10, 10), + IntRect(1, -1, 10, 10)); + TestMoveInsideAndClamp(IntRect(0, 0, 10, 10), IntRect(-1, -1, 12, 5), + IntRect(0, -1, 10, 5)); + TestMoveInsideAndClamp(IntRect(0, 0, 10, 10), IntRect(10, 11, 10, 0), + IntRect(10, 11, 10, 0)); + TestMoveInsideAndClamp(IntRect(0, 0, 10, 10), IntRect(-10, -1, 10, 0), + IntRect(-10, -1, 10, 0)); + TestMoveInsideAndClamp(IntRect(0, 0, 0, 0), IntRect(10, -10, 10, 10), + IntRect(10, 0, 0, 0)); +} diff --git a/gfx/tests/gtest/TestRegion.cpp b/gfx/tests/gtest/TestRegion.cpp new file mode 100644 index 0000000000..87a699ad78 --- /dev/null +++ b/gfx/tests/gtest/TestRegion.cpp @@ -0,0 +1,1350 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include <algorithm> + +#include "gtest/gtest.h" +#include "nsRegion.h" +#include "RegionBuilder.h" +#include "mozilla/UniquePtr.h" + +using namespace mozilla::gfx; + +// #define REGION_RANDOM_STRESS_TESTS + +class TestLargestRegion { + public: + static void TestSingleRect(nsRect r) { + nsRegion region(r); + EXPECT_TRUE(region.GetLargestRectangle().IsEqualInterior(r)); + } + // Construct a rectangle, remove part of it, then check the remainder + static void TestNonRectangular() { + nsRegion r(nsRect(0, 0, 30, 30)); + + const int nTests = 19; + struct { + nsRect rect; + int64_t expectedArea; + } tests[nTests] = {// Remove a 20x10 chunk from the square + {nsRect(0, 0, 20, 10), 600}, + {nsRect(10, 0, 20, 10), 600}, + {nsRect(10, 20, 20, 10), 600}, + {nsRect(0, 20, 20, 10), 600}, + // Remove a 10x20 chunk from the square + {nsRect(0, 0, 10, 20), 600}, + {nsRect(20, 0, 10, 20), 600}, + {nsRect(20, 10, 10, 20), 600}, + {nsRect(0, 10, 10, 20), 600}, + // Remove the center 10x10 + {nsRect(10, 10, 10, 10), 300}, + // Remove the middle column + {nsRect(10, 0, 10, 30), 300}, + // Remove the middle row + {nsRect(0, 10, 30, 10), 300}, + // Remove the corners 10x10 + {nsRect(0, 0, 10, 10), 600}, + {nsRect(20, 20, 10, 10), 600}, + {nsRect(20, 0, 10, 10), 600}, + {nsRect(0, 20, 10, 10), 600}, + // Remove the corners 20x20 + {nsRect(0, 0, 20, 20), 300}, + {nsRect(10, 10, 20, 20), 300}, + {nsRect(10, 0, 20, 20), 300}, + {nsRect(0, 10, 20, 20), 300}}; + + for (int32_t i = 0; i < nTests; i++) { + nsRegion r2; + r2.Sub(r, tests[i].rect); + + EXPECT_TRUE(r2.IsComplex()) << "nsRegion code got unexpectedly smarter!"; + + nsRect largest = r2.GetLargestRectangle(); + EXPECT_TRUE(largest.Width() * largest.Height() == tests[i].expectedArea) + << "Did not successfully find largest rectangle in non-rectangular " + "region on iteration " + << i; + } + } + static void TwoRectTest() { + nsRegion r(nsRect(0, 0, 100, 100)); + const int nTests = 4; + struct { + nsRect rect1, rect2; + int64_t expectedArea; + } tests[nTests] = { + {nsRect(0, 0, 75, 40), nsRect(0, 60, 75, 40), 2500}, + {nsRect(25, 0, 75, 40), nsRect(25, 60, 75, 40), 2500}, + {nsRect(25, 0, 75, 40), nsRect(0, 60, 75, 40), 2000}, + {nsRect(0, 0, 75, 40), nsRect(25, 60, 75, 40), 2000}, + }; + for (int32_t i = 0; i < nTests; i++) { + nsRegion r2; + + r2.Sub(r, tests[i].rect1); + r2.Sub(r2, tests[i].rect2); + + EXPECT_TRUE(r2.IsComplex()) << "nsRegion code got unexpectedly smarter!"; + + nsRect largest = r2.GetLargestRectangle(); + EXPECT_TRUE(largest.Width() * largest.Height() == tests[i].expectedArea) + << "Did not successfully find largest rectangle in two-rect-subtract " + "region on iteration " + << i; + } + } + static void TestContainsSpecifiedRect() { + nsRegion r(nsRect(0, 0, 100, 100)); + r.Or(r, nsRect(0, 300, 50, 50)); + EXPECT_TRUE(r.GetLargestRectangle(nsRect(0, 300, 10, 10)) + .IsEqualInterior(nsRect(0, 300, 50, 50))) + << "Chose wrong rectangle"; + } + static void TestContainsSpecifiedOverflowingRect() { + nsRegion r(nsRect(0, 0, 100, 100)); + r.Or(r, nsRect(0, 300, 50, 50)); + EXPECT_TRUE(r.GetLargestRectangle(nsRect(0, 290, 10, 20)) + .IsEqualInterior(nsRect(0, 300, 50, 50))) + << "Chose wrong rectangle"; + } +}; + +TEST(Gfx, RegionSingleRect) +{ + TestLargestRegion::TestSingleRect(nsRect(0, 52, 720, 480)); + TestLargestRegion::TestSingleRect(nsRect(-20, 40, 50, 20)); + TestLargestRegion::TestSingleRect(nsRect(-20, 40, 10, 8)); + TestLargestRegion::TestSingleRect(nsRect(-20, -40, 10, 8)); + TestLargestRegion::TestSingleRect(nsRect(-10, -10, 20, 20)); +} + +TEST(Gfx, RegionNonRectangular) +{ TestLargestRegion::TestNonRectangular(); } + +TEST(Gfx, RegionTwoRectTest) +{ TestLargestRegion::TwoRectTest(); } + +TEST(Gfx, RegionContainsSpecifiedRect) +{ TestLargestRegion::TestContainsSpecifiedRect(); } + +TEST(Gfx, RegionTestContainsSpecifiedOverflowingRect) +{ TestLargestRegion::TestContainsSpecifiedOverflowingRect(); } + +TEST(Gfx, RegionScaleToInside) +{ + { // no rectangles + nsRegion r; + + nsIntRegion scaled = r.ScaleToInsidePixels(1, 1, 60); + nsIntRegion result; + + EXPECT_TRUE(result.IsEqual(scaled)) << "scaled result incorrect"; + } + + { // one rectangle + nsRegion r(nsRect(0, 44760, 19096, 264)); + + nsIntRegion scaled = r.ScaleToInsidePixels(1, 1, 60); + nsIntRegion result(mozilla::gfx::IntRect(0, 746, 318, 4)); + + EXPECT_TRUE(result.IsEqual(scaled)) << "scaled result incorrect"; + } + + { // the first rectangle gets adjusted + nsRegion r(nsRect(0, 44760, 19096, 264)); + r.Or(r, nsRect(0, 45024, 19360, 1056)); + + nsIntRegion scaled = r.ScaleToInsidePixels(1, 1, 60); + nsIntRegion result(mozilla::gfx::IntRect(0, 746, 318, 5)); + result.Or(result, mozilla::gfx::IntRect(0, 751, 322, 17)); + + EXPECT_TRUE(result.IsEqual(scaled)) << "scaled result incorrect"; + } + + { // the second rectangle gets adjusted + nsRegion r(nsRect(0, 44760, 19360, 264)); + r.Or(r, nsRect(0, 45024, 19096, 1056)); + + nsIntRegion scaled = r.ScaleToInsidePixels(1, 1, 60); + nsIntRegion result(mozilla::gfx::IntRect(0, 746, 322, 4)); + result.Or(result, mozilla::gfx::IntRect(0, 750, 318, 18)); + + EXPECT_TRUE(result.IsEqual(scaled)) << "scaled result incorrect"; + } +} + +TEST(Gfx, RegionIsEqual) +{ + { + nsRegion r(nsRect(0, 0, 50, 50)); + EXPECT_FALSE(nsRegion().IsEqual(r)); + } + { + nsRegion r1(nsRect(0, 0, 50, 50)); + nsRegion r2(nsRect(0, 0, 50, 50)); + EXPECT_TRUE(r1.IsEqual(r2)); + } + { + nsRegion r1(nsRect(0, 0, 50, 50)); + nsRegion r2(nsRect(0, 0, 60, 50)); + EXPECT_FALSE(r1.IsEqual(r2)); + } + { + nsRegion r1(nsRect(0, 0, 50, 50)); + r1.OrWith(nsRect(0, 60, 50, 50)); + nsRegion r2(nsRect(0, 0, 50, 50)); + r2.OrWith(nsRect(0, 60, 50, 50)); + EXPECT_TRUE(r1.IsEqual(r2)); + } + { + nsRegion r1(nsRect(0, 0, 50, 50)); + r1.OrWith(nsRect(0, 60, 50, 50)); + nsRegion r2(nsRect(0, 0, 50, 50)); + r2.OrWith(nsRect(0, 70, 50, 50)); + EXPECT_FALSE(r1.IsEqual(r2)); + } + { + nsRegion r1(nsRect(0, 0, 50, 50)); + r1.OrWith(nsRect(0, 60, 50, 50)); + r1.OrWith(nsRect(100, 60, 50, 50)); + nsRegion r2(nsRect(0, 0, 50, 50)); + r2.OrWith(nsRect(0, 60, 50, 50)); + EXPECT_FALSE(r1.IsEqual(r2)); + } +} + +TEST(Gfx, RegionOrWith) +{ + PR_Sleep(PR_SecondsToInterval(10)); + { + nsRegion r(nsRect(11840, 11840, 4640, -10880)); + r.OrWith(nsRect(160, 160, 7720, 880)); + } + { + nsRegion r(nsRect(79, 31, 75, 12)); + r.OrWith(nsRect(22, 43, 132, 5)); + r.OrWith(nsRect(22, 48, 125, 3)); + r.OrWith(nsRect(22, 51, 96, 20)); + r.OrWith(nsRect(34, 71, 1, 14)); + r.OrWith(nsRect(26, 85, 53, 1)); + r.OrWith(nsRect(26, 86, 53, 4)); + r.OrWith(nsRect(96, 86, 30, 4)); + r.OrWith(nsRect(34, 90, 1, 2)); + r.OrWith(nsRect(96, 90, 30, 2)); + r.OrWith(nsRect(34, 92, 1, 3)); + r.OrWith(nsRect(49, 92, 34, 3)); + r.OrWith(nsRect(96, 92, 30, 3)); + r.OrWith(nsRect(34, 95, 1, 17)); + r.OrWith(nsRect(49, 95, 77, 17)); + r.OrWith(nsRect(34, 112, 1, 12)); + r.OrWith(nsRect(75, 112, 51, 12)); + r.OrWith(nsRect(34, 124, 1, 10)); + r.OrWith(nsRect(75, 124, 44, 10)); + r.OrWith(nsRect(34, 134, 1, 19)); + r.OrWith(nsRect(22, 17, 96, 27)); + } + { + nsRegion r(nsRect(0, 8, 257, 32)); + r.OrWith(nsRect(3702, 8, 138, 32)); + r.OrWith(nsRect(0, 40, 225, 1)); + r.OrWith(nsRect(3702, 40, 138, 1)); + r.OrWith(nsRect(0, 41, 101, 40)); + r.OrWith(nsRect(69, 41, 32, 40)); + } + { + nsRegion r(nsRect(79, 56, 8, 32)); + r.OrWith(nsRect(5, 94, 23, 81)); + r.OrWith(nsRect(56, 29, 91, 81)); + } + { + nsRegion r(nsRect(0, 82, 3840, 2046)); + r.OrWith(nsRect(0, 0, 3840, 82)); + } + { + nsRegion r(nsRect(2, 5, 600, 28)); + r.OrWith(nsRect(2, 82, 600, 19)); + r.OrWith(nsRect(2, 33, 600, 49)); + } + { + nsRegion r(nsRect(3823, 0, 17, 17)); + r.OrWith(nsRect(3823, 2029, 17, 17)); + r.OrWith(nsRect(3823, 0, 17, 2046)); + } + { + nsRegion r(nsRect(1036, 4, 32, 21)); + r.OrWith(nsRect(1070, 4, 66, 21)); + r.OrWith(nsRect(40, 5, 0, 33)); + } + { + nsRegion r(nsRect(0, 0, 1024, 1152)); + r.OrWith(nsRect(-335802, -1073741824, 1318851, 1860043520)); + } + { + nsRegion r(nsRect(0, 0, 800, 1000)); + r.OrWith(nsRect(0, 0, 536870912, 1073741824)); + } + { + nsRegion r(nsRect(53, 2, 52, 3)); + r.OrWith(nsRect(45, 5, 60, 16)); + r.OrWith(nsRect(16, 21, 8, 1)); + r.OrWith(nsRect(45, 21, 12, 1)); + r.OrWith(nsRect(16, 22, 8, 5)); + r.OrWith(nsRect(33, 22, 52, 5)); + r.OrWith(nsRect(16, 27, 8, 7)); + r.OrWith(nsRect(33, 27, 66, 7)); + r.OrWith(nsRect(0, 34, 99, 1)); + r.OrWith(nsRect(0, 35, 159, 27)); + r.OrWith(nsRect(0, 62, 122, 3)); + r.OrWith(nsRect(0, 65, 85, 11)); + r.OrWith(nsRect(91, 65, 97, 11)); + r.OrWith(nsRect(11, 76, 74, 2)); + r.OrWith(nsRect(91, 76, 97, 2)); + r.OrWith(nsRect(11, 78, 74, 12)); + r.OrWith(nsRect(11, 90, 13, 3)); + r.OrWith(nsRect(33, 90, 108, 3)); + r.OrWith(nsRect(16, 93, 8, 22)); + r.OrWith(nsRect(33, 93, 108, 22)); + r.OrWith(nsRect(16, 115, 8, 1)); + r.OrWith(nsRect(58, 115, 83, 1)); + r.OrWith(nsRect(58, 116, 83, 25)); + r.OrWith(nsRect(59, 37, 88, 92)); + } +#ifdef REGION_RANDOM_STRESS_TESTS + const uint32_t TestIterations = 100000; + const uint32_t RectsPerTest = 100; + + nsRect rects[RectsPerTest]; + + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r; + for (uint32_t n = 0; n < RectsPerTest; n++) { + rects[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + } + r.SetEmpty(); + for (uint32_t n = 0; n < RectsPerTest; n++) { + r.OrWith(rects[n]); + } + for (uint32_t n = 0; n < RectsPerTest; n++) { + EXPECT_TRUE(r.Contains(rects[n])); + } + } +#endif +} + +TEST(Gfx, RegionSubWith) +{ + { + nsRegion r1(nsRect(0, 0, 100, 50)); + r1.OrWith(nsRect(50, 50, 50, 50)); + nsRegion r2(nsRect(0, 0, 100, 50)); + r2.OrWith(nsRect(50, 50, 50, 50)); + r1.SubWith(r2); + EXPECT_FALSE(r1.Contains(1, 1)); + } + { + nsRegion r1(nsRect(0, 0, 800, 1000)); + nsRegion r2(nsRect(8, 108, 22, 20)); + r2.OrWith(nsRect(91, 138, 17, 18)); + r1.SubWith(r2); + EXPECT_TRUE(r1.Contains(400, 130)); + } + { + nsRegion r1(nsRect(392, 2, 28, 7)); + r1.OrWith(nsRect(115, 9, 305, 16)); + r1.OrWith(nsRect(392, 25, 28, 5)); + r1.OrWith(nsRect(0, 32, 1280, 41)); + nsRegion r2(nsRect(0, 0, 1280, 9)); + r2.OrWith(nsRect(0, 9, 115, 16)); + r2.OrWith(nsRect(331, 9, 949, 16)); + r2.OrWith(nsRect(0, 25, 1280, 7)); + r2.OrWith(nsRect(331, 32, 124, 1)); + r1.SubWith(r2); + EXPECT_FALSE(r1.Contains(350, 15)); + } + { + nsRegion r1(nsRect(552, 0, 2, 2)); + r1.OrWith(nsRect(362, 2, 222, 28)); + r1.OrWith(nsRect(552, 30, 2, 2)); + r1.OrWith(nsRect(0, 32, 1280, 41)); + nsRegion r2(nsRect(512, 0, 146, 9)); + r2.OrWith(nsRect(340, 9, 318, 16)); + r2.OrWith(nsRect(512, 25, 146, 8)); + r1.SubWith(r2); + EXPECT_FALSE(r1.Contains(350, 15)); + } + { + nsRegion r(nsRect(0, 0, 229380, 6780)); + r.OrWith(nsRect(76800, 6780, 76800, 4440)); + r.OrWith(nsRect(76800, 11220, 44082, 1800)); + r.OrWith(nsRect(122682, 11220, 30918, 1800)); + r.OrWith(nsRect(76800, 13020, 76800, 2340)); + r.OrWith(nsRect(85020, 15360, 59340, 75520)); + r.OrWith(nsRect(85020, 90880, 38622, 11332)); + r.OrWith(nsRect(143789, 90880, 571, 11332)); + r.OrWith(nsRect(85020, 102212, 59340, 960)); + r.OrWith(nsRect(85020, 103172, 38622, 1560)); + r.OrWith(nsRect(143789, 103172, 571, 1560)); + r.OrWith(nsRect(85020, 104732, 59340, 12292)); + r.OrWith(nsRect(85020, 117024, 38622, 1560)); + r.OrWith(nsRect(143789, 117024, 571, 1560)); + r.OrWith(nsRect(85020, 118584, 59340, 11976)); + r.SubWith(nsRect(123642, 89320, 20147, 1560)); + } + { + nsRegion r(nsRect(0, 0, 9480, 12900)); + r.OrWith(nsRect(0, 12900, 8460, 1020)); + r.SubWith(nsRect(8460, 0, 1020, 12900)); + } + { + nsRegion r1(nsRect(99, 1, 51, 2)); + r1.OrWith(nsRect(85, 3, 65, 1)); + r1.OrWith(nsRect(10, 4, 66, 5)); + r1.OrWith(nsRect(85, 4, 37, 5)); + r1.OrWith(nsRect(10, 9, 112, 3)); + r1.OrWith(nsRect(1, 12, 121, 1)); + r1.OrWith(nsRect(1, 13, 139, 3)); + r1.OrWith(nsRect(0, 16, 140, 3)); + r1.OrWith(nsRect(0, 19, 146, 3)); + r1.OrWith(nsRect(0, 22, 149, 2)); + r1.OrWith(nsRect(0, 24, 154, 2)); + r1.OrWith(nsRect(0, 26, 160, 23)); + r1.OrWith(nsRect(0, 49, 162, 31)); + r1.OrWith(nsRect(0, 80, 171, 19)); + r1.OrWith(nsRect(0, 99, 173, 11)); + r1.OrWith(nsRect(2, 110, 171, 6)); + r1.OrWith(nsRect(6, 116, 165, 5)); + r1.OrWith(nsRect(8, 121, 163, 1)); + r1.OrWith(nsRect(13, 122, 158, 11)); + r1.OrWith(nsRect(14, 133, 157, 23)); + r1.OrWith(nsRect(29, 156, 142, 10)); + r1.OrWith(nsRect(37, 166, 134, 6)); + r1.OrWith(nsRect(55, 172, 4, 4)); + r1.OrWith(nsRect(83, 172, 88, 4)); + r1.OrWith(nsRect(55, 176, 4, 2)); + r1.OrWith(nsRect(89, 176, 6, 2)); + r1.OrWith(nsRect(89, 178, 6, 4)); + nsRegion r2(nsRect(63, 11, 39, 11)); + r2.OrWith(nsRect(63, 22, 99, 16)); + r2.OrWith(nsRect(37, 38, 125, 61)); + r2.OrWith(nsRect(45, 99, 117, 8)); + r2.OrWith(nsRect(47, 107, 115, 7)); + r2.OrWith(nsRect(47, 114, 66, 1)); + r2.OrWith(nsRect(49, 115, 64, 2)); + r2.OrWith(nsRect(49, 117, 54, 30)); + r1.SubWith(r2); + } + { + nsRegion r1(nsRect(95, 2, 47, 1)); + r1.OrWith(nsRect(62, 3, 80, 2)); + r1.OrWith(nsRect(1, 5, 18, 3)); + r1.OrWith(nsRect(48, 5, 94, 3)); + r1.OrWith(nsRect(1, 8, 18, 3)); + r1.OrWith(nsRect(23, 8, 119, 3)); + r1.OrWith(nsRect(1, 11, 172, 9)); + r1.OrWith(nsRect(1, 20, 18, 8)); + r1.OrWith(nsRect(20, 20, 153, 8)); + r1.OrWith(nsRect(1, 28, 172, 13)); + r1.OrWith(nsRect(1, 41, 164, 1)); + r1.OrWith(nsRect(1, 42, 168, 1)); + r1.OrWith(nsRect(0, 43, 169, 15)); + r1.OrWith(nsRect(1, 58, 168, 26)); + r1.OrWith(nsRect(1, 84, 162, 2)); + r1.OrWith(nsRect(1, 86, 165, 23)); + r1.OrWith(nsRect(1, 109, 162, 23)); + r1.OrWith(nsRect(1, 132, 152, 4)); + r1.OrWith(nsRect(1, 136, 150, 12)); + r1.OrWith(nsRect(12, 148, 139, 4)); + r1.OrWith(nsRect(12, 152, 113, 2)); + r1.OrWith(nsRect(14, 154, 31, 3)); + r1.OrWith(nsRect(82, 154, 43, 3)); + r1.OrWith(nsRect(17, 157, 13, 19)); + r1.OrWith(nsRect(82, 157, 43, 19)); + r1.OrWith(nsRect(17, 176, 13, 16)); + nsRegion r2(nsRect(97, 9, 6, 10)); + r2.OrWith(nsRect(71, 19, 32, 2)); + r2.OrWith(nsRect(20, 21, 83, 2)); + r2.OrWith(nsRect(2, 23, 101, 9)); + r2.OrWith(nsRect(2, 32, 98, 1)); + r2.OrWith(nsRect(2, 33, 104, 5)); + r2.OrWith(nsRect(2, 38, 118, 2)); + r2.OrWith(nsRect(15, 40, 9, 11)); + r2.OrWith(nsRect(36, 40, 84, 11)); + r2.OrWith(nsRect(4, 51, 116, 33)); + r2.OrWith(nsRect(4, 84, 159, 8)); + r2.OrWith(nsRect(4, 92, 116, 13)); + r2.OrWith(nsRect(15, 105, 9, 7)); + r2.OrWith(nsRect(36, 105, 84, 7)); + r2.OrWith(nsRect(36, 112, 84, 22)); + r2.OrWith(nsRect(71, 134, 39, 46)); + r1.SubWith(r2); + } +#ifdef REGION_RANDOM_STRESS_TESTS + const uint32_t TestIterations = 100000; + const uint32_t RectsPerTest = 100; + const uint32_t SubRectsPerTest = 10; + + nsRect rects[RectsPerTest]; + nsRect subRects[SubRectsPerTest]; + + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r; + for (uint32_t n = 0; n < RectsPerTest; n++) { + rects[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + } + r.SetEmpty(); + for (uint32_t n = 0; n < RectsPerTest; n++) { + r.OrWith(rects[n]); + } + for (uint32_t n = 0; n < RectsPerTest; n++) { + EXPECT_TRUE(r.Contains(rects[n])); + } + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + subRects[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + } + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + r.SubWith(subRects[n]); + } + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + EXPECT_FALSE(r.Contains(subRects[n].x, subRects[n].y)); + EXPECT_FALSE(r.Contains(subRects[n].x, subRects[n].YMost() - 1)); + EXPECT_FALSE( + r.Contains(subRects[n].XMost() - 1, subRects[n].YMost() - 1)); + EXPECT_FALSE(r.Contains(subRects[n].XMost() - 1, subRects[n].Y())); + } + } + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r; + for (uint32_t n = 0; n < RectsPerTest; n++) { + rects[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + } + r.SetEmpty(); + for (uint32_t n = 0; n < RectsPerTest; n++) { + r.OrWith(rects[n]); + } + for (uint32_t n = 0; n < RectsPerTest; n++) { + EXPECT_TRUE(r.Contains(rects[n])); + } + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + subRects[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + } + nsRegion r2; + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + r2.OrWith(subRects[n]); + } + r.SubWith(r2); + + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + EXPECT_FALSE(r.Contains(subRects[n].x, subRects[n].y)); + EXPECT_FALSE(r.Contains(subRects[n].x, subRects[n].YMost() - 1)); + EXPECT_FALSE( + r.Contains(subRects[n].XMost() - 1, subRects[n].YMost() - 1)); + EXPECT_FALSE(r.Contains(subRects[n].XMost() - 1, subRects[n].Y())); + } + } + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r(nsRect(-1, -1, 202, 202)); + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + subRects[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + r.SubWith(subRects[n]); + } + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + EXPECT_FALSE(r.Contains(subRects[n].x, subRects[n].y)); + EXPECT_FALSE(r.Contains(subRects[n].x, subRects[n].YMost() - 1)); + EXPECT_FALSE( + r.Contains(subRects[n].XMost() - 1, subRects[n].YMost() - 1)); + EXPECT_FALSE(r.Contains(subRects[n].XMost() - 1, subRects[n].Y())); + } + EXPECT_TRUE(r.Contains(-1, -1)); + EXPECT_TRUE(r.Contains(-1, 200)); + EXPECT_TRUE(r.Contains(200, -1)); + EXPECT_TRUE(r.Contains(200, 200)); + } + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r(nsRect(-1, -1, 202, 202)); + nsRegion r2; + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + subRects[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + r2.OrWith(subRects[n]); + } + r.SubWith(r2); + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + EXPECT_FALSE(r.Contains(subRects[n].x, subRects[n].y)); + EXPECT_FALSE(r.Contains(subRects[n].x, subRects[n].YMost() - 1)); + EXPECT_FALSE( + r.Contains(subRects[n].XMost() - 1, subRects[n].YMost() - 1)); + EXPECT_FALSE(r.Contains(subRects[n].XMost() - 1, subRects[n].Y())); + } + EXPECT_TRUE(r.Contains(-1, -1)); + EXPECT_TRUE(r.Contains(-1, 200)); + EXPECT_TRUE(r.Contains(200, -1)); + EXPECT_TRUE(r.Contains(200, 200)); + } +#endif +} +TEST(Gfx, RegionSub) +{ + { + nsRegion r1(nsRect(0, 0, 100, 50)); + r1.OrWith(nsRect(50, 50, 50, 50)); + nsRegion r2(nsRect(0, 0, 100, 50)); + r2.OrWith(nsRect(50, 50, 50, 50)); + nsRegion r3; + r3.Sub(r1, r2); + EXPECT_FALSE(r3.Contains(1, 1)); + } + { + nsRegion r1(nsRect(0, 0, 800, 1000)); + nsRegion r2(nsRect(8, 108, 22, 20)); + r2.OrWith(nsRect(91, 138, 17, 18)); + nsRegion r3; + r3.Sub(r1, r2); + EXPECT_TRUE(r3.Contains(400, 130)); + } + { + nsRegion r1(nsRect(392, 2, 28, 7)); + r1.OrWith(nsRect(115, 9, 305, 16)); + r1.OrWith(nsRect(392, 25, 28, 5)); + r1.OrWith(nsRect(0, 32, 1280, 41)); + nsRegion r2(nsRect(0, 0, 1280, 9)); + r2.OrWith(nsRect(0, 9, 115, 16)); + r2.OrWith(nsRect(331, 9, 949, 16)); + r2.OrWith(nsRect(0, 25, 1280, 7)); + r2.OrWith(nsRect(331, 32, 124, 1)); + nsRegion r3; + r3.Sub(r1, r2); + EXPECT_FALSE(r3.Contains(350, 15)); + } + { + nsRegion r1(nsRect(552, 0, 2, 2)); + r1.OrWith(nsRect(362, 2, 222, 28)); + r1.OrWith(nsRect(552, 30, 2, 2)); + r1.OrWith(nsRect(0, 32, 1280, 41)); + nsRegion r2(nsRect(512, 0, 146, 9)); + r2.OrWith(nsRect(340, 9, 318, 16)); + r2.OrWith(nsRect(512, 25, 146, 8)); + nsRegion r3; + r3.Sub(r1, r2); + EXPECT_FALSE(r3.Contains(350, 15)); + } + { + nsRegion r1(nsRect(0, 0, 1265, 1024)); + nsRegion r2(nsRect(1265, 0, 15, 685)); + r2.OrWith(nsRect(0, 714, 1280, 221)); + nsRegion r3; + r3.Sub(r1, r2); + } + { + nsRegion r1(nsRect(6, 0, 64, 1)); + r1.OrWith(nsRect(6, 1, 67, 1)); + r1.OrWith(nsRect(6, 2, 67, 2)); + r1.OrWith(nsRect(79, 2, 67, 2)); + r1.OrWith(nsRect(6, 4, 67, 1)); + r1.OrWith(nsRect(79, 4, 98, 1)); + r1.OrWith(nsRect(6, 5, 171, 18)); + r1.OrWith(nsRect(1, 23, 176, 3)); + r1.OrWith(nsRect(1, 26, 178, 5)); + r1.OrWith(nsRect(1, 31, 176, 9)); + r1.OrWith(nsRect(0, 40, 177, 57)); + r1.OrWith(nsRect(0, 97, 176, 33)); + r1.OrWith(nsRect(0, 130, 12, 17)); + r1.OrWith(nsRect(15, 130, 161, 17)); + r1.OrWith(nsRect(0, 147, 12, 5)); + r1.OrWith(nsRect(15, 147, 111, 5)); + r1.OrWith(nsRect(0, 152, 12, 7)); + r1.OrWith(nsRect(17, 152, 109, 7)); + r1.OrWith(nsRect(0, 159, 12, 2)); + r1.OrWith(nsRect(17, 159, 98, 2)); + r1.OrWith(nsRect(17, 161, 98, 9)); + r1.OrWith(nsRect(27, 170, 63, 21)); + nsRegion r2(nsRect(9, 9, 37, 17)); + r2.OrWith(nsRect(92, 9, 26, 17)); + r2.OrWith(nsRect(9, 26, 37, 9)); + r2.OrWith(nsRect(84, 26, 65, 9)); + r2.OrWith(nsRect(9, 35, 37, 2)); + r2.OrWith(nsRect(51, 35, 98, 2)); + r2.OrWith(nsRect(51, 37, 98, 11)); + r2.OrWith(nsRect(51, 48, 78, 4)); + r2.OrWith(nsRect(87, 52, 42, 7)); + r2.OrWith(nsRect(19, 59, 12, 5)); + r2.OrWith(nsRect(87, 59, 42, 5)); + r2.OrWith(nsRect(19, 64, 12, 9)); + r2.OrWith(nsRect(32, 64, 97, 9)); + r2.OrWith(nsRect(19, 73, 12, 2)); + r2.OrWith(nsRect(32, 73, 104, 2)); + r2.OrWith(nsRect(19, 75, 117, 5)); + r2.OrWith(nsRect(18, 80, 118, 5)); + r2.OrWith(nsRect(18, 85, 111, 38)); + r2.OrWith(nsRect(87, 123, 42, 11)); + nsRegion r3; + r3.Sub(r1, r2); + } + { + nsRegion r1(nsRect(27, 0, 39, 1)); + r1.OrWith(nsRect(86, 0, 22, 1)); + r1.OrWith(nsRect(27, 1, 43, 1)); + r1.OrWith(nsRect(86, 1, 22, 1)); + r1.OrWith(nsRect(27, 2, 43, 1)); + r1.OrWith(nsRect(86, 2, 75, 1)); + r1.OrWith(nsRect(12, 3, 58, 1)); + r1.OrWith(nsRect(86, 3, 75, 1)); + r1.OrWith(nsRect(12, 4, 149, 5)); + r1.OrWith(nsRect(0, 9, 161, 9)); + r1.OrWith(nsRect(0, 18, 167, 17)); + r1.OrWith(nsRect(0, 35, 171, 5)); + r1.OrWith(nsRect(0, 40, 189, 28)); + r1.OrWith(nsRect(0, 68, 171, 16)); + r1.OrWith(nsRect(4, 84, 167, 5)); + r1.OrWith(nsRect(4, 89, 177, 9)); + r1.OrWith(nsRect(1, 98, 180, 59)); + r1.OrWith(nsRect(4, 157, 177, 1)); + r1.OrWith(nsRect(4, 158, 139, 15)); + r1.OrWith(nsRect(17, 173, 126, 2)); + r1.OrWith(nsRect(20, 175, 123, 2)); + r1.OrWith(nsRect(20, 177, 118, 6)); + r1.OrWith(nsRect(20, 183, 84, 2)); + nsRegion r2(nsRect(64, 2, 30, 6)); + r2.OrWith(nsRect(26, 11, 41, 17)); + r2.OrWith(nsRect(19, 28, 48, 23)); + r2.OrWith(nsRect(19, 51, 76, 8)); + r2.OrWith(nsRect(4, 59, 91, 31)); + r2.OrWith(nsRect(19, 90, 76, 29)); + r2.OrWith(nsRect(33, 119, 62, 25)); + r2.OrWith(nsRect(33, 144, 4, 21)); + nsRegion r3; + r3.Sub(r1, r2); + } +#ifdef REGION_RANDOM_STRESS_TESTS + const uint32_t TestIterations = 100000; + const uint32_t RectsPerTest = 100; + const uint32_t SubRectsPerTest = 10; + + nsRect rects[RectsPerTest]; + nsRect subRects[SubRectsPerTest]; + + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r; + for (uint32_t n = 0; n < RectsPerTest; n++) { + rects[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + } + r.SetEmpty(); + for (uint32_t n = 0; n < RectsPerTest; n++) { + r.OrWith(rects[n]); + } + for (uint32_t n = 0; n < RectsPerTest; n++) { + EXPECT_TRUE(r.Contains(rects[n])); + } + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + subRects[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + } + nsRegion r2; + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + r2.OrWith(subRects[n]); + } + nsRegion r3; + r3.Sub(r, r2); + + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + EXPECT_FALSE(r3.Contains(subRects[n].x, subRects[n].y)); + EXPECT_FALSE(r3.Contains(subRects[n].x, subRects[n].YMost() - 1)); + EXPECT_FALSE( + r3.Contains(subRects[n].XMost() - 1, subRects[n].YMost() - 1)); + EXPECT_FALSE(r3.Contains(subRects[n].XMost() - 1, subRects[n].Y())); + } + } + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r(nsRect(-1, -1, 202, 202)); + nsRegion r2; + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + subRects[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + r2.OrWith(subRects[n]); + } + nsRegion r3; + r3.Sub(r, r2); + for (uint32_t n = 0; n < SubRectsPerTest; n++) { + EXPECT_FALSE(r3.Contains(subRects[n].x, subRects[n].y)); + EXPECT_FALSE(r3.Contains(subRects[n].x, subRects[n].YMost() - 1)); + EXPECT_FALSE( + r3.Contains(subRects[n].XMost() - 1, subRects[n].YMost() - 1)); + EXPECT_FALSE(r3.Contains(subRects[n].XMost() - 1, subRects[n].Y())); + } + EXPECT_TRUE(r3.Contains(-1, -1)); + EXPECT_TRUE(r3.Contains(-1, 200)); + EXPECT_TRUE(r3.Contains(200, -1)); + EXPECT_TRUE(r3.Contains(200, 200)); + } +#endif +} + +TEST(Gfx, RegionAndWith) +{ + { + nsRegion r(nsRect(20, 0, 20, 20)); + r.OrWith(nsRect(0, 20, 40, 20)); + r.AndWith(nsRect(0, 0, 5, 5)); + EXPECT_FALSE(r.Contains(1, 1)); + } + { + nsRegion r1(nsRect(512, 1792, 256, 256)); + nsRegion r2(nsRect(17, 1860, 239, 35)); + r2.OrWith(nsRect(17, 1895, 239, 7)); + r2.OrWith(nsRect(768, 1895, 154, 7)); + r2.OrWith(nsRect(17, 1902, 905, 483)); + r1.AndWith(r2); + } +#ifdef REGION_RANDOM_STRESS_TESTS + const uint32_t TestIterations = 100000; + const uint32_t RectsPerTest = 50; + const uint32_t pointsTested = 100; + + { + nsRect rectsSet1[RectsPerTest]; + nsRect rectsSet2[RectsPerTest]; + + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r1; + nsRegion r2; + for (uint32_t n = 0; n < RectsPerTest; n++) { + rectsSet1[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + rectsSet2[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + r1.OrWith(rectsSet1[n]); + r2.OrWith(rectsSet1[n]); + } + + nsRegion r3 = r1; + r3.AndWith(r2); + + for (uint32_t n = 0; n < pointsTested; n++) { + nsPoint p(rand() % 200, rand() % 200); + if (r1.Contains(p.x, p.y) && r2.Contains(p.x, p.y)) { + EXPECT_TRUE(r3.Contains(p.x, p.y)); + } else { + EXPECT_FALSE(r3.Contains(p.x, p.y)); + } + } + } + } + + { + nsRect rectsSet[RectsPerTest]; + nsRect testRect; + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r; + for (uint32_t n = 0; n < RectsPerTest; n++) { + rectsSet[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + } + for (uint32_t n = 0; n < RectsPerTest; n++) { + r.OrWith(rectsSet[n]); + } + testRect.SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + + nsRegion r2 = r; + r2.AndWith(testRect); + + for (uint32_t n = 0; n < pointsTested; n++) { + nsPoint p(rand() % 200, rand() % 200); + if (r.Contains(p.x, p.y) && testRect.Contains(p.x, p.y)) { + EXPECT_TRUE(r2.Contains(p.x, p.y)); + } else { + EXPECT_FALSE(r2.Contains(p.x, p.y)); + } + } + } + } +#endif +} + +TEST(Gfx, RegionAnd) +{ + { + nsRegion r(nsRect(20, 0, 20, 20)); + r.OrWith(nsRect(0, 20, 40, 20)); + nsRegion r2; + r2.And(r, nsRect(0, 0, 5, 5)); + EXPECT_FALSE(r.Contains(1, 1)); + } + { + nsRegion r(nsRect(51, 2, 57, 5)); + r.OrWith(nsRect(36, 7, 72, 4)); + r.OrWith(nsRect(36, 11, 25, 1)); + r.OrWith(nsRect(69, 12, 6, 4)); + r.OrWith(nsRect(37, 16, 54, 2)); + r.OrWith(nsRect(37, 18, 82, 2)); + r.OrWith(nsRect(10, 20, 109, 3)); + r.OrWith(nsRect(1, 23, 136, 21)); + r.OrWith(nsRect(1, 44, 148, 2)); + r.OrWith(nsRect(1, 46, 176, 31)); + r.OrWith(nsRect(6, 77, 171, 1)); + r.OrWith(nsRect(5, 78, 172, 30)); + r.OrWith(nsRect(5, 108, 165, 45)); + r.OrWith(nsRect(5, 153, 61, 5)); + r.OrWith(nsRect(72, 153, 98, 5)); + r.OrWith(nsRect(38, 158, 25, 4)); + r.OrWith(nsRect(72, 158, 98, 4)); + r.OrWith(nsRect(58, 162, 5, 8)); + r.OrWith(nsRect(72, 162, 98, 8)); + r.OrWith(nsRect(72, 170, 98, 5)); + nsRegion r2; + r.And(r2, nsRect(18, 78, 53, 45)); + } +#ifdef REGION_RANDOM_STRESS_TESTS + const uint32_t TestIterations = 100000; + const uint32_t RectsPerTest = 50; + const uint32_t pointsTested = 100; + + { + nsRect rectsSet1[RectsPerTest]; + nsRect rectsSet2[RectsPerTest]; + + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r1; + nsRegion r2; + for (uint32_t n = 0; n < RectsPerTest; n++) { + rectsSet1[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + rectsSet2[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + r1.OrWith(rectsSet1[n]); + r2.OrWith(rectsSet1[n]); + } + + nsRegion r3; + r3.And(r1, r2); + + for (uint32_t n = 0; n < pointsTested; n++) { + nsPoint p(rand() % 200, rand() % 200); + if (r1.Contains(p.x, p.y) && r2.Contains(p.x, p.y)) { + EXPECT_TRUE(r3.Contains(p.x, p.y)); + } else { + EXPECT_FALSE(r3.Contains(p.x, p.y)); + } + } + } + } + + { + nsRect rectsSet[RectsPerTest]; + nsRect testRect; + for (uint32_t i = 0; i < TestIterations; i++) { + nsRegion r; + for (uint32_t n = 0; n < RectsPerTest; n++) { + rectsSet[n].SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + } + for (uint32_t n = 0; n < RectsPerTest; n++) { + r.OrWith(rectsSet[n]); + } + testRect.SetRect(rand() % 100, rand() % 100, rand() % 99 + 1, + rand() % 99 + 1); + + nsRegion r2; + r2.And(r, testRect); + + for (uint32_t n = 0; n < pointsTested; n++) { + nsPoint p(rand() % 200, rand() % 200); + if (r.Contains(p.x, p.y) && testRect.Contains(p.x, p.y)) { + EXPECT_TRUE(r2.Contains(p.x, p.y)); + } else { + EXPECT_FALSE(r2.Contains(p.x, p.y)); + } + } + } + } +#endif +} + +TEST(Gfx, RegionSimplify) +{ + { // ensure simplify works on a single rect + nsRegion r(nsRect(0, 100, 200, 100)); + + r.SimplifyOutwardByArea(100 * 100); + + nsRegion result(nsRect(0, 100, 200, 100)); + + EXPECT_TRUE(r.IsEqual(result)) << "regions not the same"; + } + + { // the rectangles will be merged + nsRegion r(nsRect(0, 100, 200, 100)); + r.Or(r, nsRect(0, 200, 300, 200)); + + r.SimplifyOutwardByArea(100 * 100); + + nsRegion result(nsRect(0, 100, 300, 300)); + + EXPECT_TRUE(r.IsEqual(result)) << "regions not merged"; + } + + { // two rectangle on the first span + // one on the second + nsRegion r(nsRect(0, 100, 200, 100)); + r.Or(r, nsRect(0, 200, 300, 200)); + r.Or(r, nsRect(250, 100, 50, 100)); + + EXPECT_TRUE(r.GetNumRects() == 3) << "wrong number of rects"; + + r.SimplifyOutwardByArea(100 * 100); + + nsRegion result(nsRect(0, 100, 300, 300)); + + EXPECT_TRUE(r.IsEqual(result)) << "regions not merged"; + } + + { // the rectangles will be merged + nsRegion r(nsRect(0, 100, 200, 100)); + r.Or(r, nsRect(0, 200, 300, 200)); + r.Or(r, nsRect(250, 100, 50, 100)); + r.Sub(r, nsRect(200, 200, 40, 200)); + + EXPECT_TRUE(r.GetNumRects() == 4) << "wrong number of rects"; + + r.SimplifyOutwardByArea(100 * 100); + + nsRegion result(nsRect(0, 100, 300, 300)); + result.Sub(result, nsRect(200, 100, 40, 300)); + + EXPECT_TRUE(r.IsEqual(result)) << "regions not merged"; + } + + { // three spans of rectangles + nsRegion r(nsRect(0, 100, 200, 100)); + r.Or(r, nsRect(0, 200, 300, 200)); + r.Or(r, nsRect(250, 100, 50, 50)); + r.Sub(r, nsRect(200, 200, 40, 200)); + + r.SimplifyOutwardByArea(100 * 100); + + nsRegion result(nsRect(0, 100, 300, 300)); + result.Sub(result, nsRect(200, 100, 40, 300)); + + EXPECT_TRUE(r.IsEqual(result)) << "regions not merged"; + } + + { // three spans of rectangles and an unmerged rectangle + nsRegion r(nsRect(0, 100, 200, 100)); + r.Or(r, nsRect(0, 200, 300, 200)); + r.Or(r, nsRect(250, 100, 50, 50)); + r.Sub(r, nsRect(200, 200, 40, 200)); + r.Or(r, nsRect(250, 900, 150, 50)); + + r.SimplifyOutwardByArea(100 * 100); + + nsRegion result(nsRect(0, 100, 300, 300)); + result.Sub(result, nsRect(200, 100, 40, 300)); + result.Or(result, nsRect(250, 900, 150, 50)); + + EXPECT_TRUE(r.IsEqual(result)) << "regions not merged"; + } + + { // unmerged regions + nsRegion r(nsRect(0, 100, 200, 100)); + r.Or(r, nsRect(0, 200, 300, 200)); + + r.SimplifyOutwardByArea(100); + + nsRegion result(nsRect(0, 100, 200, 100)); + result.Or(result, nsRect(0, 200, 300, 200)); + + EXPECT_TRUE(r.IsEqual(result)) << "regions not merged"; + } + + { // empty region + // just make sure this doesn't crash. + nsRegion r; + r.SimplifyOutwardByArea(100); + } +} + +TEST(Gfx, RegionContains) +{ + { // ensure Contains works on a simple region + nsRegion r(nsRect(0, 0, 100, 100)); + + EXPECT_TRUE(r.Contains(0, 0)); + EXPECT_TRUE(r.Contains(0, 99)); + EXPECT_TRUE(r.Contains(99, 0)); + EXPECT_TRUE(r.Contains(99, 99)); + + EXPECT_FALSE(r.Contains(-1, 50)); + EXPECT_FALSE(r.Contains(100, 50)); + EXPECT_FALSE(r.Contains(50, -1)); + EXPECT_FALSE(r.Contains(50, 100)); + + EXPECT_TRUE(r.Contains(nsRect(0, 0, 100, 100))); + EXPECT_TRUE(r.Contains(nsRect(99, 99, 1, 1))); + + EXPECT_FALSE(r.Contains(nsRect(100, 100, 1, 1))); + EXPECT_FALSE(r.Contains(nsRect(100, 100, 0, 0))); + } + + { // empty regions contain nothing + nsRegion r(nsRect(100, 100, 0, 0)); + + EXPECT_FALSE(r.Contains(0, 0)); + EXPECT_FALSE(r.Contains(100, 100)); + EXPECT_FALSE(r.Contains(nsRect(100, 100, 0, 0))); + EXPECT_FALSE(r.Contains(nsRect(100, 100, 1, 1))); + } + + { // complex region contain tests + // The region looks like this, with two squares that overlap. + // (hard to do accurately with ASCII art) + // +------+ + // | | + // | +--+ + // | | + // +--+ | + // | | + // +------+ + nsRegion r(nsRect(0, 0, 100, 100)); + r.OrWith(nsRect(50, 50, 100, 100)); + + EXPECT_TRUE(r.Contains(0, 0)); + EXPECT_TRUE(r.Contains(99, 99)); + EXPECT_TRUE(r.Contains(50, 100)); + EXPECT_TRUE(r.Contains(100, 50)); + EXPECT_TRUE(r.Contains(149, 149)); + + EXPECT_FALSE(r.Contains(49, 100)); + EXPECT_FALSE(r.Contains(100, 49)); + EXPECT_FALSE(r.Contains(150, 150)); + + EXPECT_TRUE(r.Contains(nsRect(100, 100, 1, 1))); + EXPECT_FALSE(r.Contains(nsRect(49, 99, 2, 2))); + } + + { // region with a hole + nsRegion r(nsRect(0, 0, 100, 100)); + r.SubOut(nsRect(40, 40, 10, 10)); + + EXPECT_TRUE(r.Contains(0, 0)); + EXPECT_TRUE(r.Contains(39, 39)); + EXPECT_FALSE(r.Contains(40, 40)); + EXPECT_FALSE(r.Contains(49, 49)); + EXPECT_TRUE(r.Contains(50, 50)); + + EXPECT_FALSE(r.Contains(nsRect(40, 40, 10, 10))); + EXPECT_FALSE(r.Contains(nsRect(39, 39, 2, 2))); + } +} + +#define DILATE_VALUE 0x88 +#define REGION_VALUE 0xff + +struct RegionBitmap { + RegionBitmap(unsigned char* bitmap, int width, int height) + : bitmap(bitmap), width(width), height(height) {} + + void clear() { + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + bitmap[x + y * width] = 0; + } + } + } + + void set(nsRegion& region) { + clear(); + for (auto iter = region.RectIter(); !iter.Done(); iter.Next()) { + const nsRect& r = iter.Get(); + for (int y = r.Y(); y < r.YMost(); y++) { + for (int x = r.X(); x < r.XMost(); x++) { + bitmap[x + y * width] = REGION_VALUE; + } + } + } + } + + void dilate() { + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + if (bitmap[x + y * width] == REGION_VALUE) { + for (int yn = std::max(y - 1, 0); yn <= std::min(y + 1, height - 1); + yn++) { + for (int xn = std::max(x - 1, 0); xn <= std::min(x + 1, width - 1); + xn++) { + if (bitmap[xn + yn * width] == 0) + bitmap[xn + yn * width] = DILATE_VALUE; + } + } + } + } + } + } + void compare(RegionBitmap& reference) { + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + EXPECT_EQ(bitmap[x + y * width], reference.bitmap[x + y * width]); + } + } + } + + unsigned char* bitmap; + int width; + int height; +}; + +static void VisitEdge(void* closure, VisitSide side, int x1, int y1, int x2, + int y2) { + EXPECT_GE(x2, x1); + RegionBitmap* visitor = static_cast<RegionBitmap*>(closure); + unsigned char* bitmap = visitor->bitmap; + const int width = visitor->width; + + if (side == VisitSide::TOP) { + while (x1 != x2) { + bitmap[x1 + (y1 - 1) * width] = DILATE_VALUE; + x1++; + } + } else if (side == VisitSide::BOTTOM) { + while (x1 != x2) { + bitmap[x1 + y1 * width] = DILATE_VALUE; + x1++; + } + } else if (side == VisitSide::LEFT) { + while (y1 != y2) { + bitmap[x1 - 1 + y1 * width] = DILATE_VALUE; + y1++; + } + } else if (side == VisitSide::RIGHT) { + while (y1 != y2) { + bitmap[x1 + y1 * width] = DILATE_VALUE; + y1++; + } + } +} + +static void TestVisit(nsRegion& r) { + auto reference = mozilla::MakeUnique<unsigned char[]>(600 * 600); + auto result = mozilla::MakeUnique<unsigned char[]>(600 * 600); + RegionBitmap ref(reference.get(), 600, 600); + RegionBitmap res(result.get(), 600, 600); + + ref.set(r); + ref.dilate(); + + res.set(r); + r.VisitEdges(VisitEdge, &res); + res.compare(ref); +} + +TEST(Gfx, RegionVisitEdges) +{ + { // visit edges + nsRegion r(nsRect(20, 20, 100, 100)); + r.Or(r, nsRect(20, 120, 200, 100)); + TestVisit(r); + } + + { // two rects side by side - 1 pixel inbetween + nsRegion r(nsRect(20, 20, 100, 100)); + r.Or(r, nsRect(121, 20, 100, 100)); + TestVisit(r); + } + + { // two rects side by side - 2 pixels inbetween + nsRegion r(nsRect(20, 20, 100, 100)); + r.Or(r, nsRect(122, 20, 100, 100)); + TestVisit(r); + } + + { + // only corner of the rects are touching + nsRegion r(nsRect(20, 20, 100, 100)); + r.Or(r, nsRect(120, 120, 100, 100)); + + TestVisit(r); + } + + { + // corners are 1 pixel away + nsRegion r(nsRect(20, 20, 100, 100)); + r.Or(r, nsRect(121, 120, 100, 100)); + + TestVisit(r); + } + + { + // vertically separated + nsRegion r(nsRect(20, 20, 100, 100)); + r.Or(r, nsRect(120, 125, 100, 100)); + + TestVisit(r); + } + + { + // not touching + nsRegion r(nsRect(20, 20, 100, 100)); + r.Or(r, nsRect(130, 120, 100, 100)); + r.Or(r, nsRect(240, 20, 100, 100)); + + TestVisit(r); + } + + { // rect with a hole in it + nsRegion r(nsRect(20, 20, 100, 100)); + r.Sub(r, nsRect(40, 40, 10, 10)); + + TestVisit(r); + } + { + // left overs + nsRegion r(nsRect(20, 20, 10, 10)); + r.Or(r, nsRect(50, 20, 10, 10)); + r.Or(r, nsRect(90, 20, 10, 10)); + r.Or(r, nsRect(24, 30, 10, 10)); + r.Or(r, nsRect(20, 40, 15, 10)); + r.Or(r, nsRect(50, 40, 15, 10)); + r.Or(r, nsRect(90, 40, 15, 10)); + + TestVisit(r); + } + + { + // vertically separated + nsRegion r(nsRect(20, 20, 100, 100)); + r.Or(r, nsRect(120, 125, 100, 100)); + + TestVisit(r); + } + + { + // two upper rects followed by a lower one + // on the same line + nsRegion r(nsRect(5, 5, 50, 50)); + r.Or(r, nsRect(100, 5, 50, 50)); + r.Or(r, nsRect(200, 50, 50, 50)); + + TestVisit(r); + } + + { + // bug 1130978. + nsRegion r(nsRect(4, 1, 61, 49)); + r.Or(r, nsRect(115, 1, 99, 49)); + r.Or(r, nsRect(115, 49, 99, 1)); + r.Or(r, nsRect(12, 50, 11, 5)); + r.Or(r, nsRect(25, 50, 28, 5)); + r.Or(r, nsRect(115, 50, 99, 5)); + r.Or(r, nsRect(115, 55, 99, 12)); + + TestVisit(r); + } +} diff --git a/gfx/tests/gtest/TestSkipChars.cpp b/gfx/tests/gtest/TestSkipChars.cpp new file mode 100644 index 0000000000..8f31777619 --- /dev/null +++ b/gfx/tests/gtest/TestSkipChars.cpp @@ -0,0 +1,156 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" + +#include "gfxSkipChars.h" +#include "mozilla/ArrayUtils.h" + +static bool TestConstructor() { + gfxSkipChars skipChars; + + EXPECT_TRUE(skipChars.GetOriginalCharCount() == 0) + << "[1] Make sure the gfxSkipChars was properly initialized with " + "constructor"; + + return true; +} + +static bool TestLength() { + gfxSkipChars skipChars; + + skipChars.KeepChars(100); + + EXPECT_TRUE(skipChars.GetOriginalCharCount() == 100) + << "[1] Check length after keeping chars"; + + skipChars.SkipChars(50); + + EXPECT_TRUE(skipChars.GetOriginalCharCount() == 150) + << "[2] Check length after skipping chars"; + + skipChars.SkipChars(50); + + EXPECT_TRUE(skipChars.GetOriginalCharCount() == 200) + << "[3] Check length after skipping more chars"; + + skipChars.KeepChar(); + + EXPECT_TRUE(skipChars.GetOriginalCharCount() == 201) + << "[4] Check length after keeping a final char"; + + return true; +} + +static bool TestIterator() { + // Test a gfxSkipChars that starts with kept chars + gfxSkipChars skipChars1; + + skipChars1.KeepChars(9); + skipChars1.SkipChar(); + skipChars1.KeepChars(9); + skipChars1.SkipChar(); + skipChars1.KeepChars(9); + + EXPECT_TRUE(skipChars1.GetOriginalCharCount() == 29) << "[1] Check length"; + + gfxSkipCharsIterator iter1(skipChars1); + + EXPECT_TRUE(iter1.GetOriginalOffset() == 0) + << "[2] Check initial original offset"; + EXPECT_TRUE(iter1.GetSkippedOffset() == 0) + << "[3] Check initial skipped offset"; + + EXPECT_TRUE(iter1.IsOriginalCharSkipped() == false) + << "[3a] Check IsOriginalCharSkipped for initial position"; + + uint32_t expectSkipped1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}; + + for (uint32_t i = 0; i < mozilla::ArrayLength(expectSkipped1); i++) { + EXPECT_TRUE(iter1.ConvertOriginalToSkipped(i) == expectSkipped1[i]) + << "[4] Check mapping of original to skipped for " << i; + } + + int32_t expectOriginal1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, + 10, 11, 12, 13, 14, 15, 16, 17, 18, + 20, 21, 22, 23, 24, 25, 26, 27, 28}; + + for (uint32_t i = 0; i < mozilla::ArrayLength(expectOriginal1); i++) { + EXPECT_TRUE(iter1.ConvertSkippedToOriginal(i) == expectOriginal1[i]) + << "[5] Check mapping of skipped to original for " << i; + } + + bool expectIsOriginalSkipped1[] = { + false, false, false, false, false, false, false, false, false, true, + false, false, false, false, false, false, false, false, false, true, + false, false, false, false, false, false, false, false, false}; + + for (uint32_t i = 0; i < mozilla::ArrayLength(expectIsOriginalSkipped1); + i++) { + iter1.SetOriginalOffset(i); + EXPECT_TRUE(iter1.IsOriginalCharSkipped() == expectIsOriginalSkipped1[i]) + << "[5.a] Check IsOriginalCharSkipped for " << i; + } + + // Test a gfxSkipChars that starts with skipped chars + gfxSkipChars skipChars2; + + skipChars2.SkipChars(9); + skipChars2.KeepChar(); + skipChars2.SkipChars(9); + skipChars2.KeepChar(); + skipChars2.SkipChars(9); + + EXPECT_TRUE(skipChars2.GetOriginalCharCount() == 29) << "[6] Check length"; + + gfxSkipCharsIterator iter2(skipChars2); + + EXPECT_TRUE(iter2.GetOriginalOffset() == 0) + << "[7] Check initial original offset"; + EXPECT_TRUE(iter2.GetSkippedOffset() == 0) + << "[8] Check initial skipped offset"; + + EXPECT_TRUE(iter2.IsOriginalCharSkipped() == true) + << "[8a] Check IsOriginalCharSkipped for initial position"; + + uint32_t expectSkipped2[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; + + for (uint32_t i = 0; i < mozilla::ArrayLength(expectSkipped2); i++) { + EXPECT_TRUE(iter2.ConvertOriginalToSkipped(i) == expectSkipped2[i]) + << "[9] Check mapping of original to skipped for " << i; + } + + int32_t expectOriginal2[] = {9, 19, 29}; + + for (uint32_t i = 0; i < mozilla::ArrayLength(expectOriginal2); i++) { + EXPECT_TRUE(iter2.ConvertSkippedToOriginal(i) == expectOriginal2[i]) + << "[10] Check mapping of skipped to original for " << i; + } + + bool expectIsOriginalSkipped2[] = { + true, true, true, true, true, true, true, true, true, false, + true, true, true, true, true, true, true, true, true, false, + true, true, true, true, true, true, true, true, true}; + + for (uint32_t i = 0; i < mozilla::ArrayLength(expectIsOriginalSkipped2); + i++) { + iter2.SetOriginalOffset(i); + EXPECT_TRUE(iter2.IsOriginalCharSkipped() == expectIsOriginalSkipped2[i]) + << "[10.a] Check IsOriginalCharSkipped for " << i; + } + + return true; +} + +TEST(Gfx, gfxSkipChars) +{ + TestConstructor(); + TestLength(); + TestIterator(); +} diff --git a/gfx/tests/gtest/TestSwizzle.cpp b/gfx/tests/gtest/TestSwizzle.cpp new file mode 100644 index 0000000000..c63b3cd682 --- /dev/null +++ b/gfx/tests/gtest/TestSwizzle.cpp @@ -0,0 +1,696 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" +#include "mozilla/ArrayUtils.h" +#include "mozilla/gfx/Swizzle.h" +#include "Orientation.h" + +using namespace mozilla; +using namespace mozilla::gfx; +using namespace mozilla::image; + +TEST(Moz2D, PremultiplyData) +{ + const uint8_t in_bgra[5 * 4] = { + 255, 255, 0, 255, // verify 255 alpha leaves RGB unchanged + 0, 0, 255, 255, + 0, 255, 255, 0, // verify 0 alpha zeroes out RGB + 0, 0, 0, 0, + 255, 0, 0, 128, // verify that 255 RGB maps to alpha + }; + uint8_t out[5 * 4]; + const uint8_t check_bgra[5 * 4] = { + 255, 255, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 128, + }; + // check swizzled output + const uint8_t check_rgba[5 * 4] = { + 0, 255, 255, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, + }; + const uint8_t check_argb[5 * 4] = { + 255, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 128, + }; + + PremultiplyData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out, + sizeof(in_bgra), SurfaceFormat::B8G8R8A8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out, check_bgra)); + + PremultiplyData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out, + sizeof(in_bgra), SurfaceFormat::R8G8B8A8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out, check_rgba)); + + PremultiplyData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out, + sizeof(in_bgra), SurfaceFormat::A8R8G8B8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out, check_argb)); +} + +TEST(Moz2D, PremultiplyRow) +{ + const uint8_t in_bgra[5 * 4] = { + 255, 255, 0, 255, // verify 255 alpha leaves RGB unchanged + 0, 0, 255, 255, + 0, 255, 255, 0, // verify 0 alpha zeroes out RGB + 0, 0, 0, 0, + 255, 0, 0, 128, // verify that 255 RGB maps to alpha + }; + uint8_t out[5 * 4]; + const uint8_t check_bgra[5 * 4] = { + 255, 255, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 128, + }; + // check swizzled output + const uint8_t check_rgba[5 * 4] = { + 0, 255, 255, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, + }; + const uint8_t check_argb[5 * 4] = { + 255, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 128, + }; + + SwizzleRowFn func = + PremultiplyRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::B8G8R8A8); + func(in_bgra, out, 5); + EXPECT_TRUE(ArrayEqual(out, check_bgra)); + + func = PremultiplyRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::R8G8B8A8); + func(in_bgra, out, 5); + EXPECT_TRUE(ArrayEqual(out, check_rgba)); + + func = PremultiplyRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::A8R8G8B8); + func(in_bgra, out, 5); + EXPECT_TRUE(ArrayEqual(out, check_argb)); +} + +TEST(Moz2D, PremultiplyYFlipData) +{ + const uint8_t stride = 2 * 4; + const uint8_t in_bgra[6 * 4] = { + 255, 255, 0, 255, // row 1: verify 255 alpha leaves RGB unchanged + 0, 0, 255, 255, + 0, 255, 255, 0, // row 2: verify 0 alpha zeroes out RGB + 0, 0, 0, 0, + 255, 0, 0, 128, // row 3: verify that 255 RGB maps to alpha + 255, 255, 255, 128, + }; + const uint8_t in_bgra_2[4 * 4] = { + 255, 255, 0, 255, // row 1: verify 255 alpha leaves RGB unchanged + 0, 0, 255, 255, + 0, 255, 255, 0, // row 2: verify 0 alpha zeroes out RGB + 0, 0, 0, 0, + }; + const uint8_t in_bgra_3[2 * 4] = { + 255, 0, 0, 128, // row 1: verify that 255 RGB maps to alpha + 255, 255, 255, 128, + }; + uint8_t out[6 * 4]; + uint8_t out_2[4 * 4]; + uint8_t out_3[2 * 4]; + const uint8_t check_bgra[6 * 4] = { + 128, 0, 0, 128, 128, 128, 128, 128, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 255, 255, + }; + const uint8_t check_bgra_2[4 * 4] = { + 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 255, 255, + }; + const uint8_t check_bgra_3[2 * 4] = { + 128, 0, 0, 128, 128, 128, 128, 128, + }; + // check swizzled output + const uint8_t check_rgba[6 * 4] = { + 0, 0, 128, 128, 128, 128, 128, 128, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 255, + }; + + // Premultiply. + PremultiplyYFlipData(in_bgra, stride, SurfaceFormat::B8G8R8A8, out, stride, + SurfaceFormat::B8G8R8A8, IntSize(2, 3)); + EXPECT_TRUE(ArrayEqual(out, check_bgra)); + + // Premultiply in-place with middle row. + memcpy(out, in_bgra, sizeof(out)); + PremultiplyYFlipData(out, stride, SurfaceFormat::B8G8R8A8, out, stride, + SurfaceFormat::B8G8R8A8, IntSize(2, 3)); + EXPECT_TRUE(ArrayEqual(out, check_bgra)); + + // Premultiply in-place without middle row. + memcpy(out_2, in_bgra_2, sizeof(out_2)); + PremultiplyYFlipData(out_2, stride, SurfaceFormat::B8G8R8A8, out_2, stride, + SurfaceFormat::B8G8R8A8, IntSize(2, 2)); + EXPECT_TRUE(ArrayEqual(out_2, check_bgra_2)); + + // Premultiply in-place only middle row. + memcpy(out_3, in_bgra_3, sizeof(out_3)); + PremultiplyYFlipData(out_3, stride, SurfaceFormat::B8G8R8A8, out_3, stride, + SurfaceFormat::B8G8R8A8, IntSize(2, 1)); + EXPECT_TRUE(ArrayEqual(out_3, check_bgra_3)); + + // Premultiply and swizzle with middle row. + PremultiplyYFlipData(in_bgra, stride, SurfaceFormat::B8G8R8A8, out, stride, + SurfaceFormat::R8G8B8A8, IntSize(2, 3)); + EXPECT_TRUE(ArrayEqual(out, check_rgba)); +} + +TEST(Moz2D, UnpremultiplyData) +{ + const uint8_t in_bgra[5 * 4] = { + 255, 255, 0, 255, // verify 255 alpha leaves RGB unchanged + 0, 0, 255, 255, 0, 0, 0, 0, // verify 0 alpha leaves RGB at 0 + 0, 0, 0, 64, // verify 0 RGB stays 0 with non-zero alpha + 128, 0, 0, 128, // verify that RGB == alpha maps to 255 + + }; + uint8_t out[5 * 4]; + const uint8_t check_bgra[5 * 4] = { + 255, 255, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 64, 255, 0, 0, 128, + }; + // check swizzled output + const uint8_t check_rgba[5 * 4] = { + 0, 255, 255, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 255, 128, + }; + const uint8_t check_argb[5 * 4] = { + 255, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 128, 0, 0, 255, + }; + + UnpremultiplyData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out, + sizeof(in_bgra), SurfaceFormat::B8G8R8A8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out, check_bgra)); + + UnpremultiplyData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out, + sizeof(in_bgra), SurfaceFormat::R8G8B8A8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out, check_rgba)); + + UnpremultiplyData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out, + sizeof(in_bgra), SurfaceFormat::A8R8G8B8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out, check_argb)); +} + +TEST(Moz2D, UnpremultiplyRow) +{ + const uint8_t in_bgra[5 * 4] = { + 255, 255, 0, 255, // verify 255 alpha leaves RGB unchanged + 0, 0, 255, 255, 0, 0, 0, 0, // verify 0 alpha leaves RGB at 0 + 0, 0, 0, 64, // verify 0 RGB stays 0 with non-zero alpha + 128, 0, 0, 128, // verify that RGB == alpha maps to 255 + + }; + uint8_t out[5 * 4]; + const uint8_t check_bgra[5 * 4] = { + 255, 255, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 64, 255, 0, 0, 128, + }; + // check swizzled output + const uint8_t check_rgba[5 * 4] = { + 0, 255, 255, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 255, 128, + }; + const uint8_t check_argb[5 * 4] = { + 255, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 128, 0, 0, 255, + }; + + SwizzleRowFn func = + UnpremultiplyRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::B8G8R8A8); + func(in_bgra, out, 5); + EXPECT_TRUE(ArrayEqual(out, check_bgra)); + + func = UnpremultiplyRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::R8G8B8A8); + func(in_bgra, out, 5); + EXPECT_TRUE(ArrayEqual(out, check_rgba)); + + func = UnpremultiplyRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::A8R8G8B8); + func(in_bgra, out, 5); + EXPECT_TRUE(ArrayEqual(out, check_argb)); +} + +TEST(Moz2D, SwizzleData) +{ + const uint8_t in_bgra[5 * 4] = { + 253, 254, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 1, 2, 3, 64, 127, 0, 9, 128, + + }; + uint8_t out[5 * 4]; + // check copy + const uint8_t check_bgra[5 * 4] = { + 253, 254, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 1, 2, 3, 64, 127, 0, 9, 128, + }; + // check swaps + const uint8_t check_rgba[5 * 4] = { + 0, 254, 253, 255, 255, 0, 0, 255, 0, 0, 0, 0, 3, 2, 1, 64, 9, 0, 127, 128, + }; + const uint8_t check_argb[5 * 4] = { + 255, 0, 254, 253, 255, 255, 0, 0, 0, 0, 0, 0, 64, 3, 2, 1, 128, 9, 0, 127, + }; + // check opaquifying + const uint8_t check_rgbx[5 * 4] = { + 0, 254, 253, 255, 255, 0, 0, 255, 0, 0, + 0, 255, 3, 2, 1, 255, 9, 0, 127, 255, + }; + // check packing + uint8_t out24[5 * 3]; + const uint8_t check_bgr[5 * 3] = {253, 254, 0, 0, 0, 255, 0, 0, + 0, 1, 2, 3, 127, 0, 9}; + const uint8_t check_rgb[5 * 3] = { + 0, 254, 253, 255, 0, 0, 0, 0, 0, 3, 2, 1, 9, 0, 127, + }; + uint8_t out8[5]; + const uint8_t check_a[5] = {255, 255, 0, 64, 128}; + uint16_t out16[5]; +#define PACK_RGB565(b, g, r) \ + (((b & 0xF8) >> 3) | ((g & 0xFC) << 3) | ((r & 0xF8) << 8)) + const uint16_t check_16[5] = { + PACK_RGB565(253, 254, 0), PACK_RGB565(0, 0, 255), PACK_RGB565(0, 0, 0), + PACK_RGB565(1, 2, 3), PACK_RGB565(127, 0, 9), + }; + + SwizzleData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out, + sizeof(out), SurfaceFormat::B8G8R8A8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out, check_bgra)); + + SwizzleData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out, + sizeof(out), SurfaceFormat::R8G8B8A8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out, check_rgba)); + + SwizzleData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out, + sizeof(out), SurfaceFormat::A8R8G8B8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out, check_argb)); + + SwizzleData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out, + sizeof(out), SurfaceFormat::R8G8B8X8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out, check_rgbx)); + + SwizzleData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out24, + sizeof(out24), SurfaceFormat::B8G8R8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out24, check_bgr)); + + SwizzleData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out24, + sizeof(out24), SurfaceFormat::R8G8B8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out24, check_rgb)); + + SwizzleData(in_bgra, sizeof(in_bgra), SurfaceFormat::B8G8R8A8, out8, + sizeof(out8), SurfaceFormat::A8, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out8, check_a)); + + const uint8_t* uint32_argb; + +#if MOZ_BIG_ENDIAN() + EXPECT_EQ(SurfaceFormat::A8R8G8B8_UINT32, SurfaceFormat::A8R8G8B8); + uint32_argb = check_argb; +#else + EXPECT_EQ(SurfaceFormat::A8R8G8B8_UINT32, SurfaceFormat::B8G8R8A8); + uint32_argb = check_bgra; +#endif + + SwizzleData(uint32_argb, sizeof(in_bgra), SurfaceFormat::A8R8G8B8_UINT32, + reinterpret_cast<uint8_t*>(out16), sizeof(out16), + SurfaceFormat::R5G6B5_UINT16, IntSize(5, 1)); + EXPECT_TRUE(ArrayEqual(out16, check_16)); +} + +TEST(Moz2D, SwizzleYFlipData) +{ + const uint8_t stride = 2 * 4; + const uint8_t in_bgra[6 * 4] = { + 255, 255, 0, 255, // row 1 + 0, 0, 255, 255, 0, 255, 255, 0, // row 2 + 0, 0, 0, 0, 255, 0, 0, 128, // row 3 + 255, 255, 255, 128, + }; + const uint8_t in_bgra_2[4 * 4] = { + 255, 255, 0, 255, // row 1 + 0, 0, 255, 255, 0, 255, 255, 0, // row 2 + 0, 0, 0, 0, + }; + const uint8_t in_bgra_3[2 * 4] = { + 255, 0, 0, 128, // row 1 + 255, 255, 255, 128, + }; + uint8_t out[6 * 4]; + uint8_t out_2[4 * 4]; + uint8_t out_3[2 * 4]; + const uint8_t check_rgba[6 * 4] = { + 0, 0, 255, 128, 255, 255, 255, 128, 255, 255, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 255, + }; + const uint8_t check_rgba_2[4 * 4] = { + 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 255, + }; + const uint8_t check_rgba_3[2 * 4] = { + 0, 0, 255, 128, 255, 255, 255, 128, + }; + + // Swizzle. + SwizzleYFlipData(in_bgra, stride, SurfaceFormat::B8G8R8A8, out, stride, + SurfaceFormat::R8G8B8A8, IntSize(2, 3)); + EXPECT_TRUE(ArrayEqual(out, check_rgba)); + + // Swizzle in-place with middle row. + memcpy(out, in_bgra, sizeof(out)); + SwizzleYFlipData(out, stride, SurfaceFormat::B8G8R8A8, out, stride, + SurfaceFormat::R8G8B8A8, IntSize(2, 3)); + EXPECT_TRUE(ArrayEqual(out, check_rgba)); + + // Swizzle in-place without middle row. + memcpy(out_2, in_bgra_2, sizeof(out_2)); + SwizzleYFlipData(out_2, stride, SurfaceFormat::B8G8R8A8, out_2, stride, + SurfaceFormat::R8G8B8A8, IntSize(2, 2)); + EXPECT_TRUE(ArrayEqual(out_2, check_rgba_2)); + + // Swizzle in-place only middle row. + memcpy(out_3, in_bgra_3, sizeof(out_3)); + SwizzleYFlipData(out_3, stride, SurfaceFormat::B8G8R8A8, out_3, stride, + SurfaceFormat::R8G8B8A8, IntSize(2, 1)); + EXPECT_TRUE(ArrayEqual(out_3, check_rgba_3)); +} + +TEST(Moz2D, SwizzleRow) +{ + const uint8_t in_bgra[5 * 4] = { + 253, 254, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 1, 2, 3, 64, 127, 0, 9, 128, + + }; + uint8_t out[5 * 4]; + // check swaps + const uint8_t check_rgba[5 * 4] = { + 0, 254, 253, 255, 255, 0, 0, 255, 0, 0, 0, 0, 3, 2, 1, 64, 9, 0, 127, 128, + }; + // check opaquifying + const uint8_t check_rgbx[5 * 4] = { + 0, 254, 253, 255, 255, 0, 0, 255, 0, 0, + 0, 255, 3, 2, 1, 255, 9, 0, 127, 255, + }; + // check packing + uint8_t out24[5 * 3]; + const uint8_t check_bgr[5 * 3] = {253, 254, 0, 0, 0, 255, 0, 0, + 0, 1, 2, 3, 127, 0, 9}; + const uint8_t check_rgb[5 * 3] = { + 0, 254, 253, 255, 0, 0, 0, 0, 0, 3, 2, 1, 9, 0, 127, + }; + // check unpacking + uint8_t out_unpack[16 * 4]; + const uint8_t in_rgb[16 * 3] = { + 0, 254, 253, 255, 0, 0, 0, 0, 0, 3, 2, 1, 9, 0, 127, 4, + 5, 6, 9, 8, 7, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + }; + const uint8_t check_unpack_rgbx[16 * 4] = { + 0, 254, 253, 255, 255, 0, 0, 255, 0, 0, 0, 255, 3, 2, 1, 255, + 9, 0, 127, 255, 4, 5, 6, 255, 9, 8, 7, 255, 10, 11, 12, 255, + 13, 14, 15, 255, 16, 17, 18, 255, 19, 20, 21, 255, 22, 23, 24, 255, + 25, 26, 27, 255, 28, 29, 30, 255, 31, 32, 33, 255, 34, 35, 36, 255, + }; + const uint8_t check_unpack_bgrx[16 * 4] = { + 253, 254, 0, 255, 0, 0, 255, 255, 0, 0, 0, 255, 1, 2, 3, 255, + 127, 0, 9, 255, 6, 5, 4, 255, 7, 8, 9, 255, 12, 11, 10, 255, + 15, 14, 13, 255, 18, 17, 16, 255, 21, 20, 19, 255, 24, 23, 22, 255, + 27, 26, 25, 255, 30, 29, 28, 255, 33, 32, 31, 255, 36, 35, 34, 255, + }; + const uint8_t check_unpack_xrgb[16 * 4] = { + 255, 0, 254, 253, 255, 255, 0, 0, 255, 0, 0, 0, 255, 3, 2, 1, + 255, 9, 0, 127, 255, 4, 5, 6, 255, 9, 8, 7, 255, 10, 11, 12, + 255, 13, 14, 15, 255, 16, 17, 18, 255, 19, 20, 21, 255, 22, 23, 24, + 255, 25, 26, 27, 255, 28, 29, 30, 255, 31, 32, 33, 255, 34, 35, 36, + }; + + SwizzleRowFn func = + SwizzleRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::R8G8B8A8); + func(in_bgra, out, 5); + EXPECT_TRUE(ArrayEqual(out, check_rgba)); + + func = SwizzleRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::R8G8B8X8); + func(in_bgra, out, 5); + EXPECT_TRUE(ArrayEqual(out, check_rgbx)); + + func = SwizzleRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::B8G8R8A8); + func(in_bgra, out, 5); + EXPECT_TRUE(ArrayEqual(out, in_bgra)); + + func = SwizzleRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::B8G8R8); + func(in_bgra, out24, 5); + EXPECT_TRUE(ArrayEqual(out24, check_bgr)); + + func = SwizzleRow(SurfaceFormat::B8G8R8A8, SurfaceFormat::R8G8B8); + func(in_bgra, out24, 5); + EXPECT_TRUE(ArrayEqual(out24, check_rgb)); + + func = SwizzleRow(SurfaceFormat::R8G8B8, SurfaceFormat::B8G8R8X8); + func(in_rgb, out_unpack, 16); + EXPECT_TRUE(ArrayEqual(out_unpack, check_unpack_bgrx)); + + memset(out_unpack, 0xE5, sizeof(out_unpack)); + memcpy(out_unpack, in_rgb, sizeof(in_rgb)); + func(out_unpack, out_unpack, 16); + EXPECT_TRUE(ArrayEqual(out_unpack, check_unpack_bgrx)); + + func = SwizzleRow(SurfaceFormat::R8G8B8, SurfaceFormat::R8G8B8X8); + func(in_rgb, out_unpack, 16); + EXPECT_TRUE(ArrayEqual(out_unpack, check_unpack_rgbx)); + + memset(out_unpack, 0xE5, sizeof(out_unpack)); + memcpy(out_unpack, in_rgb, sizeof(in_rgb)); + func(out_unpack, out_unpack, 16); + EXPECT_TRUE(ArrayEqual(out_unpack, check_unpack_rgbx)); + + func = SwizzleRow(SurfaceFormat::R8G8B8, SurfaceFormat::X8R8G8B8); + func(in_rgb, out_unpack, 16); + EXPECT_TRUE(ArrayEqual(out_unpack, check_unpack_xrgb)); + + memset(out_unpack, 0xE5, sizeof(out_unpack)); + memcpy(out_unpack, in_rgb, sizeof(in_rgb)); + func(out_unpack, out_unpack, 16); + EXPECT_TRUE(ArrayEqual(out_unpack, check_unpack_xrgb)); +} + +TEST(Moz2D, ReorientRow) +{ + // Input is a 3x4 image. + const uint8_t in_row0[3 * 4] = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + }; + const uint8_t in_row1[3 * 4] = { + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + }; + const uint8_t in_row2[3 * 4] = { + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + }; + const uint8_t in_row3[3 * 4] = { + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + }; + + // Output is either a 3x4 image or 4x3 image. + uint8_t out[3 * 4 * 4]; + IntSize outSize(3, 4); + IntSize outSizeSwap(4, 3); + int32_t outStride = 3 * 4; + int32_t outStrideSwap = 4 * 4; + IntRect dirty; + + auto func = ReorientRow(Orientation()); + dirty = func(in_row0, 0, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 0, 3, 1)); + dirty = func(in_row1, 1, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 1, 3, 1)); + dirty = func(in_row2, 2, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 2, 3, 1)); + dirty = func(in_row3, 3, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 3, 3, 1)); + + // clang-format off + const uint8_t check_identity[3 * 4 * 4] = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + }; + // clang-format on + EXPECT_TRUE(ArrayEqual(out, check_identity)); + + func = ReorientRow(Orientation(Angle::D90)); + dirty = func(in_row0, 0, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(3, 0, 1, 3)); + dirty = func(in_row1, 1, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(2, 0, 1, 3)); + dirty = func(in_row2, 2, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(1, 0, 1, 3)); + dirty = func(in_row3, 3, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(0, 0, 1, 3)); + + // clang-format off + const uint8_t check_d90[3 * 4 * 4] = { + 36, 37, 38, 39, 24, 25, 26, 27, 12, 13, 14, 15, 0, 1, 2, 3, + 40, 41, 42, 43, 28, 29, 30, 31, 16, 17, 18, 19, 4, 5, 6, 7, + 44, 45, 46, 47, 32, 33, 34, 35, 20, 21, 22, 23, 8, 9, 10, 11, + }; + // clang-format on + EXPECT_TRUE(ArrayEqual(out, check_d90)); + + func = ReorientRow(Orientation(Angle::D180)); + dirty = func(in_row0, 0, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 3, 3, 1)); + dirty = func(in_row1, 1, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 2, 3, 1)); + dirty = func(in_row2, 2, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 1, 3, 1)); + dirty = func(in_row3, 3, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 0, 3, 1)); + + // clang-format off + const uint8_t check_d180[3 * 4 * 4] = { + 44, 45, 46, 47, 40, 41, 42, 43, 36, 37, 38, 39, + 32, 33, 34, 35, 28, 29, 30, 31, 24, 25, 26, 27, + 20, 21, 22, 23, 16, 17, 18, 19, 12, 13, 14, 15, + 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3, + }; + // clang-format on + EXPECT_TRUE(ArrayEqual(out, check_d180)); + + func = ReorientRow(Orientation(Angle::D270)); + dirty = func(in_row0, 0, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(0, 0, 1, 3)); + dirty = func(in_row1, 1, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(1, 0, 1, 3)); + dirty = func(in_row2, 2, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(2, 0, 1, 3)); + dirty = func(in_row3, 3, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(3, 0, 1, 3)); + + // clang-format off + const uint8_t check_d270[3 * 4 * 4] = { + 8, 9, 10, 11, 20, 21, 22, 23, 32, 33, 34, 35, 44, 45, 46, 47, + 4, 5, 6, 7, 16, 17, 18, 19, 28, 29, 30, 31, 40, 41, 42, 43, + 0, 1, 2, 3, 12, 13, 14, 15, 24, 25, 26, 27, 36, 37, 38, 39, + }; + // clang-format on + EXPECT_TRUE(ArrayEqual(out, check_d270)); + + func = ReorientRow(Orientation(Angle::D0, Flip::Horizontal)); + dirty = func(in_row0, 0, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 0, 3, 1)); + dirty = func(in_row1, 1, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 1, 3, 1)); + dirty = func(in_row2, 2, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 2, 3, 1)); + dirty = func(in_row3, 3, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 3, 3, 1)); + + // clang-format off + const uint8_t check_d0_flip[3 * 4 * 4] = { + 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3, + 20, 21, 22, 23, 16, 17, 18, 19, 12, 13, 14, 15, + 32, 33, 34, 35, 28, 29, 30, 31, 24, 25, 26, 27, + 44, 45, 46, 47, 40, 41, 42, 43, 36, 37, 38, 39, + }; + // clang-format on + EXPECT_TRUE(ArrayEqual(out, check_d0_flip)); + + func = ReorientRow(Orientation(Angle::D90, Flip::Horizontal)); + dirty = func(in_row0, 0, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(0, 0, 1, 3)); + dirty = func(in_row1, 1, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(1, 0, 1, 3)); + dirty = func(in_row2, 2, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(2, 0, 1, 3)); + dirty = func(in_row3, 3, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(3, 0, 1, 3)); + + // clang-format off + const uint8_t check_d90_flip[3 * 4 * 4] = { + 0, 1, 2, 3, 12, 13, 14, 15, 24, 25, 26, 27, 36, 37, 38, 39, + 4, 5, 6, 7, 16, 17, 18, 19, 28, 29, 30, 31, 40, 41, 42, 43, + 8, 9, 10, 11, 20, 21, 22, 23, 32, 33, 34, 35, 44, 45, 46, 47, + }; + // clang-format on + EXPECT_TRUE(ArrayEqual(out, check_d90_flip)); + + func = ReorientRow(Orientation(Angle::D180, Flip::Horizontal)); + dirty = func(in_row0, 0, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 3, 3, 1)); + dirty = func(in_row1, 1, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 2, 3, 1)); + dirty = func(in_row2, 2, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 1, 3, 1)); + dirty = func(in_row3, 3, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 0, 3, 1)); + + // clang-format off + const uint8_t check_d180_flip[3 * 4 * 4] = { + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + }; + // clang-format on + EXPECT_TRUE(ArrayEqual(out, check_d180_flip)); + + func = ReorientRow(Orientation(Angle::D270, Flip::Horizontal)); + dirty = func(in_row0, 0, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(3, 0, 1, 3)); + dirty = func(in_row1, 1, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(2, 0, 1, 3)); + dirty = func(in_row2, 2, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(1, 0, 1, 3)); + dirty = func(in_row3, 3, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(0, 0, 1, 3)); + + // clang-format off + const uint8_t check_d270_flip[3 * 4 * 4] = { + 44, 45, 46, 47, 32, 33, 34, 35, 20, 21, 22, 23, 8, 9, 10, 11, + 40, 41, 42, 43, 28, 29, 30, 31, 16, 17, 18, 19, 4, 5, 6, 7, + 36, 37, 38, 39, 24, 25, 26, 27, 12, 13, 14, 15, 0, 1, 2, 3, + }; + // clang-format on + EXPECT_TRUE(ArrayEqual(out, check_d270_flip)); + + func = ReorientRow( + Orientation(Angle::D0, Flip::Horizontal, /* aFlipFirst */ true)); + dirty = func(in_row0, 0, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 0, 3, 1)); + dirty = func(in_row1, 1, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 1, 3, 1)); + dirty = func(in_row2, 2, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 2, 3, 1)); + dirty = func(in_row3, 3, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 3, 3, 1)); + + // No rotation, so flipping before and after are the same. + EXPECT_TRUE(ArrayEqual(out, check_d0_flip)); + + func = ReorientRow( + Orientation(Angle::D90, Flip::Horizontal, /* aFlipFirst */ true)); + dirty = func(in_row0, 0, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(3, 0, 1, 3)); + dirty = func(in_row1, 1, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(2, 0, 1, 3)); + dirty = func(in_row2, 2, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(1, 0, 1, 3)); + dirty = func(in_row3, 3, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(0, 0, 1, 3)); + + // Flip, rotate 90 degrees is the same as rotate 270 degrees, flip. + EXPECT_TRUE(ArrayEqual(out, check_d270_flip)); + + func = ReorientRow( + Orientation(Angle::D180, Flip::Horizontal, /* aFlipFirst */ true)); + dirty = func(in_row0, 0, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 3, 3, 1)); + dirty = func(in_row1, 1, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 2, 3, 1)); + dirty = func(in_row2, 2, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 1, 3, 1)); + dirty = func(in_row3, 3, out, outSize, outStride); + EXPECT_EQ(dirty, IntRect(0, 0, 3, 1)); + + // Flip, rotate 180 degrees is the same as rotate 180 degrees, flip. + EXPECT_TRUE(ArrayEqual(out, check_d180_flip)); + + func = ReorientRow( + Orientation(Angle::D270, Flip::Horizontal, /* aFlipFirst */ true)); + dirty = func(in_row0, 0, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(0, 0, 1, 3)); + dirty = func(in_row1, 1, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(1, 0, 1, 3)); + dirty = func(in_row2, 2, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(2, 0, 1, 3)); + dirty = func(in_row3, 3, out, outSizeSwap, outStrideSwap); + EXPECT_EQ(dirty, IntRect(3, 0, 1, 3)); + + // Flip, rotate 270 degrees is the same as rotate 90 degrees, flip. + EXPECT_TRUE(ArrayEqual(out, check_d90_flip)); +} diff --git a/gfx/tests/gtest/TestTextures.cpp b/gfx/tests/gtest/TestTextures.cpp new file mode 100644 index 0000000000..da129a3486 --- /dev/null +++ b/gfx/tests/gtest/TestTextures.cpp @@ -0,0 +1,287 @@ +/* vim:set ts=2 sw=2 sts=2 et: */ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +#include "gtest/gtest.h" +#include "gmock/gmock.h" + +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/Tools.h" +#include "mozilla/layers/BufferTexture.h" +#include "mozilla/layers/ImageBridgeChild.h" // for ImageBridgeChild +#include "mozilla/layers/TextureClient.h" +#include "mozilla/layers/TextureHost.h" +#include "mozilla/RefPtr.h" +#include "gfx2DGlue.h" +#include "gfxImageSurface.h" +#include "gfxPlatform.h" +#include "gfxTypes.h" +#include "ImageContainer.h" +#include "mozilla/layers/ImageDataSerializer.h" + +using namespace mozilla; +using namespace mozilla::gfx; +using namespace mozilla::layers; + +/* + * This test performs the following actions: + * - creates a surface + * - initialize a texture client with it + * - serilaizes the texture client + * - deserializes the data into a texture host + * - reads the surface from the texture host. + * + * The surface in the end should be equal to the inital one. + * This test is run for different combinations of texture types and + * image formats. + */ + +namespace mozilla { +namespace layers { + +class TestSurfaceAllocator final : public ISurfaceAllocator { + public: + TestSurfaceAllocator() = default; + virtual ~TestSurfaceAllocator() = default; + + bool IsSameProcess() const override { return true; } +}; + +// fills the surface with values betwee 0 and 100. +static void SetupSurface(gfxImageSurface* surface) { + int bpp = gfxASurface::BytePerPixelFromFormat(surface->Format()); + int stride = surface->Stride(); + uint8_t val = 0; + uint8_t* data = surface->Data(); + for (int y = 0; y < surface->Height(); ++y) { + for (int x = 0; x < surface->Height(); ++x) { + for (int b = 0; b < bpp; ++b) { + data[y * stride + x * bpp + b] = val; + if (val == 100) { + val = 0; + } else { + ++val; + } + } + } + } +} + +// return true if two surfaces contain the same data +static void AssertSurfacesEqual(gfxImageSurface* surface1, + gfxImageSurface* surface2) { + ASSERT_EQ(surface1->GetSize(), surface2->GetSize()); + ASSERT_EQ(surface1->Format(), surface2->Format()); + + uint8_t* data1 = surface1->Data(); + uint8_t* data2 = surface2->Data(); + int stride1 = surface1->Stride(); + int stride2 = surface2->Stride(); + int bpp = gfxASurface::BytePerPixelFromFormat(surface1->Format()); + + for (int y = 0; y < surface1->Height(); ++y) { + for (int x = 0; x < surface1->Width(); ++x) { + for (int b = 0; b < bpp; ++b) { + ASSERT_EQ(data1[y * stride1 + x * bpp + b], + data2[y * stride2 + x * bpp + b]); + } + } + } +} + +static void AssertSurfacesEqual(SourceSurface* surface1, + SourceSurface* surface2) { + ASSERT_EQ(surface1->GetSize(), surface2->GetSize()); + ASSERT_EQ(surface1->GetFormat(), surface2->GetFormat()); + + RefPtr<DataSourceSurface> dataSurface1 = surface1->GetDataSurface(); + RefPtr<DataSourceSurface> dataSurface2 = surface2->GetDataSurface(); + DataSourceSurface::MappedSurface map1; + DataSourceSurface::MappedSurface map2; + if (!dataSurface1->Map(DataSourceSurface::READ, &map1)) { + return; + } + if (!dataSurface2->Map(DataSourceSurface::READ, &map2)) { + dataSurface1->Unmap(); + return; + } + uint8_t* data1 = map1.mData; + uint8_t* data2 = map2.mData; + int stride1 = map1.mStride; + int stride2 = map2.mStride; + int bpp = BytesPerPixel(surface1->GetFormat()); + int width = surface1->GetSize().width; + int height = surface1->GetSize().height; + + for (int y = 0; y < height; ++y) { + for (int x = 0; x < width; ++x) { + for (int b = 0; b < bpp; ++b) { + ASSERT_EQ(data1[y * stride1 + x * bpp + b], + data2[y * stride2 + x * bpp + b]); + } + } + } + + dataSurface1->Unmap(); + dataSurface2->Unmap(); +} + +// Run the test for a texture client and a surface +void TestTextureClientSurface(TextureClient* texture, + gfxImageSurface* surface) { + // client allocation + ASSERT_TRUE(texture->CanExposeDrawTarget()); + + ASSERT_TRUE(texture->Lock(OpenMode::OPEN_READ_WRITE)); + // client painting + RefPtr<DrawTarget> dt = texture->BorrowDrawTarget(); + RefPtr<SourceSurface> source = + gfxPlatform::GetPlatform()->GetSourceSurfaceForSurface(dt, surface); + dt->CopySurface(source, IntRect(IntPoint(), source->GetSize()), IntPoint()); + + RefPtr<SourceSurface> snapshot = dt->Snapshot(); + + AssertSurfacesEqual(snapshot, source); + + dt = nullptr; // drop reference before calling Unlock() + texture->Unlock(); + + // client serialization + SurfaceDescriptor descriptor; + ASSERT_TRUE(texture->ToSurfaceDescriptor(descriptor)); + + ASSERT_NE(descriptor.type(), SurfaceDescriptor::Tnull_t); + + // host deserialization + RefPtr<TestSurfaceAllocator> deallocator = new TestSurfaceAllocator(); + RefPtr<TextureHost> host = CreateBackendIndependentTextureHost( + descriptor, deallocator, LayersBackend::LAYERS_NONE, texture->GetFlags()); + + ASSERT_TRUE(host.get() != nullptr); + ASSERT_EQ(host->GetFlags(), texture->GetFlags()); +} + +// Same as above, for YCbCr surfaces +void TestTextureClientYCbCr(TextureClient* client, PlanarYCbCrData& ycbcrData) { + client->Lock(OpenMode::OPEN_READ_WRITE); + UpdateYCbCrTextureClient(client, ycbcrData); + client->Unlock(); + + // client serialization + SurfaceDescriptor descriptor; + ASSERT_TRUE(client->ToSurfaceDescriptor(descriptor)); + + ASSERT_EQ(descriptor.type(), SurfaceDescriptor::TSurfaceDescriptorBuffer); + auto bufferDesc = descriptor.get_SurfaceDescriptorBuffer(); + ASSERT_EQ(bufferDesc.desc().type(), BufferDescriptor::TYCbCrDescriptor); + auto ycbcrDesc = bufferDesc.desc().get_YCbCrDescriptor(); + ASSERT_EQ(ycbcrDesc.ySize(), ycbcrData.YDataSize()); + ASSERT_EQ(ycbcrDesc.cbCrSize(), ycbcrData.CbCrDataSize()); + ASSERT_EQ(ycbcrDesc.stereoMode(), ycbcrData.mStereoMode); + + // host deserialization + RefPtr<TestSurfaceAllocator> deallocator = new TestSurfaceAllocator(); + RefPtr<TextureHost> textureHost = CreateBackendIndependentTextureHost( + descriptor, deallocator, LayersBackend::LAYERS_NONE, client->GetFlags()); + + RefPtr<BufferTextureHost> host = + static_cast<BufferTextureHost*>(textureHost.get()); + + ASSERT_TRUE(host.get() != nullptr); + ASSERT_EQ(host->GetFlags(), client->GetFlags()); +} + +} // namespace layers +} // namespace mozilla + +TEST(Layers, TextureSerialization) +{ + // the test is run on all the following image formats + gfxImageFormat formats[3] = { + SurfaceFormat::A8R8G8B8_UINT32, + SurfaceFormat::X8R8G8B8_UINT32, + SurfaceFormat::A8, + }; + + for (int f = 0; f < 3; ++f) { + RefPtr<gfxImageSurface> surface = + new gfxImageSurface(IntSize(400, 300), formats[f]); + SetupSurface(surface.get()); + AssertSurfacesEqual(surface, surface); + + auto texData = BufferTextureData::Create( + surface->GetSize(), gfx::ImageFormatToSurfaceFormat(surface->Format()), + gfx::BackendType::CAIRO, LayersBackend::LAYERS_NONE, + TextureFlags::DEALLOCATE_CLIENT, ALLOC_DEFAULT, nullptr); + ASSERT_TRUE(!!texData); + + RefPtr<TextureClient> client = + new TextureClient(texData, TextureFlags::DEALLOCATE_CLIENT, nullptr); + + TestTextureClientSurface(client, surface); + + // XXX - Test more texture client types. + } +} + +TEST(Layers, TextureYCbCrSerialization) +{ + RefPtr<gfxImageSurface> ySurface = + new gfxImageSurface(IntSize(400, 300), SurfaceFormat::A8); + RefPtr<gfxImageSurface> cbSurface = + new gfxImageSurface(IntSize(200, 150), SurfaceFormat::A8); + RefPtr<gfxImageSurface> crSurface = + new gfxImageSurface(IntSize(200, 150), SurfaceFormat::A8); + SetupSurface(ySurface.get()); + SetupSurface(cbSurface.get()); + SetupSurface(crSurface.get()); + + PlanarYCbCrData clientData; + clientData.mYChannel = ySurface->Data(); + clientData.mCbChannel = cbSurface->Data(); + clientData.mCrChannel = crSurface->Data(); + clientData.mPictureRect = IntRect(IntPoint(0, 0), ySurface->GetSize()); + clientData.mYStride = ySurface->Stride(); + clientData.mCbCrStride = cbSurface->Stride(); + clientData.mStereoMode = StereoMode::MONO; + clientData.mYUVColorSpace = YUVColorSpace::BT601; + clientData.mColorDepth = ColorDepth::COLOR_8; + clientData.mChromaSubsampling = ChromaSubsampling::HALF_WIDTH_AND_HEIGHT; + clientData.mYSkip = 0; + clientData.mCbSkip = 0; + clientData.mCrSkip = 0; + clientData.mCrSkip = 0; + + uint32_t namespaceId = 1; + ImageBridgeChild::InitSameProcess(namespaceId); + + RefPtr<ImageBridgeChild> imageBridge = ImageBridgeChild::GetSingleton(); + static int retry = 5; + while (!imageBridge->IPCOpen() && retry) { + // IPDL connection takes time especially in slow testing environment, like + // VM machines. Here we added retry mechanism to wait for IPDL connnection. +#ifdef XP_WIN + Sleep(1); +#else + sleep(1); +#endif + retry--; + } + + // Skip this testing if IPDL connection is not ready + if (!retry && !imageBridge->IPCOpen()) { + return; + } + + RefPtr<TextureClient> client = TextureClient::CreateForYCbCr( + imageBridge, clientData.mPictureRect, clientData.YDataSize(), + clientData.mYStride, clientData.CbCrDataSize(), clientData.mCbCrStride, + StereoMode::MONO, ColorDepth::COLOR_8, YUVColorSpace::BT601, + ColorRange::LIMITED, clientData.mChromaSubsampling, + TextureFlags::DEALLOCATE_CLIENT); + + TestTextureClientYCbCr(client, clientData); + + // XXX - Test more texture client types. +} diff --git a/gfx/tests/gtest/TestTreeTraversal.cpp b/gfx/tests/gtest/TestTreeTraversal.cpp new file mode 100644 index 0000000000..7e538ca514 --- /dev/null +++ b/gfx/tests/gtest/TestTreeTraversal.cpp @@ -0,0 +1,1408 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include <vector> +#include "mozilla/RefPtr.h" +#include "gtest/gtest.h" +#include "nsRegion.h" +#include "nsRect.h" +#include "TreeTraversal.h" +#include <stack> +#include <queue> + +using namespace mozilla::layers; +using namespace mozilla; + +enum class SearchNodeType { Needle, Hay }; +enum class ForEachNodeType { Continue, Skip }; + +template <class T> +class TestNodeBase { + public: + NS_INLINE_DECL_REFCOUNTING(TestNodeBase<T>); + explicit TestNodeBase(T aType, int aExpectedTraversalRank = -1); + explicit TestNodeBase(); + void SetActualTraversalRank(int aRank); + void SetValue(int aValue); + void SetType(T aType); + void SetRegion(nsRegion aRegion); + int GetExpectedTraversalRank(); + int GetActualTraversalRank(); + int GetValue(); + T GetType(); + nsRegion GetRegion(); + virtual bool IsLeaf() = 0; + + private: + MOZ_INIT_OUTSIDE_CTOR int mExpectedTraversalRank; + MOZ_INIT_OUTSIDE_CTOR int mActualTraversalRank; + MOZ_INIT_OUTSIDE_CTOR int mValue; + MOZ_INIT_OUTSIDE_CTOR nsRegion mRegion; + MOZ_INIT_OUTSIDE_CTOR T mType; + + protected: + virtual ~TestNodeBase() = default; +}; + +template <class T> +class TestNodeReverse : public TestNodeBase<T> { + public: + explicit TestNodeReverse(T aType, int aExpectedTraversalRank = -1); + explicit TestNodeReverse(); + void AddChild(RefPtr<TestNodeReverse<T>> aNode); + TestNodeReverse<T>* GetLastChild(); + TestNodeReverse<T>* GetPrevSibling(); + bool IsLeaf(); + + private: + void SetPrevSibling(RefPtr<TestNodeReverse<T>> aNode); + void SetLastChild(RefPtr<TestNodeReverse<T>> aNode); + RefPtr<TestNodeReverse<T>> mSiblingNode; + RefPtr<TestNodeReverse<T>> mLastChildNode; + ~TestNodeReverse() = default; +}; + +template <class T> +class TestNodeForward : public TestNodeBase<T> { + public: + explicit TestNodeForward(T aType, int aExpectedTraversalRank = -1); + explicit TestNodeForward(); + void AddChild(RefPtr<TestNodeForward<T>> aNode); + TestNodeForward<T>* GetFirstChild(); + TestNodeForward<T>* GetNextSibling(); + bool IsLeaf(); + + private: + void SetNextSibling(RefPtr<TestNodeForward<T>> aNode); + void SetLastChild(RefPtr<TestNodeForward<T>> aNode); + void SetFirstChild(RefPtr<TestNodeForward<T>> aNode); + RefPtr<TestNodeForward<T>> mSiblingNode = nullptr; + RefPtr<TestNodeForward<T>> mFirstChildNode = nullptr; + // Track last child to facilitate appending children + RefPtr<TestNodeForward<T>> mLastChildNode = nullptr; + ~TestNodeForward() = default; +}; + +template <class T> +TestNodeReverse<T>::TestNodeReverse(T aType, int aExpectedTraversalRank) + : TestNodeBase<T>(aType, aExpectedTraversalRank) {} + +template <class T> +TestNodeReverse<T>::TestNodeReverse() : TestNodeBase<T>() {} + +template <class T> +void TestNodeReverse<T>::SetLastChild(RefPtr<TestNodeReverse<T>> aNode) { + mLastChildNode = aNode; +} + +template <class T> +void TestNodeReverse<T>::AddChild(RefPtr<TestNodeReverse<T>> aNode) { + aNode->SetPrevSibling(mLastChildNode); + SetLastChild(aNode); +} + +template <class T> +void TestNodeReverse<T>::SetPrevSibling(RefPtr<TestNodeReverse<T>> aNode) { + mSiblingNode = aNode; +} + +template <class T> +TestNodeReverse<T>* TestNodeReverse<T>::GetLastChild() { + return mLastChildNode; +} + +template <class T> +TestNodeReverse<T>* TestNodeReverse<T>::GetPrevSibling() { + return mSiblingNode; +} + +template <class T> +bool TestNodeReverse<T>::IsLeaf() { + return !mLastChildNode; +} + +template <class T> +TestNodeForward<T>::TestNodeForward(T aType, int aExpectedTraversalRank) + : TestNodeBase<T>(aType, aExpectedTraversalRank) {} + +template <class T> +TestNodeForward<T>::TestNodeForward() : TestNodeBase<T>() {} + +template <class T> +void TestNodeForward<T>::AddChild(RefPtr<TestNodeForward<T>> aNode) { + if (mFirstChildNode == nullptr) { + SetFirstChild(aNode); + SetLastChild(aNode); + } else { + mLastChildNode->SetNextSibling(aNode); + SetLastChild(aNode); + } +} + +template <class T> +void TestNodeForward<T>::SetLastChild(RefPtr<TestNodeForward<T>> aNode) { + mLastChildNode = aNode; +} + +template <class T> +void TestNodeForward<T>::SetFirstChild(RefPtr<TestNodeForward<T>> aNode) { + mFirstChildNode = aNode; +} + +template <class T> +void TestNodeForward<T>::SetNextSibling(RefPtr<TestNodeForward<T>> aNode) { + mSiblingNode = aNode; +} + +template <class T> +bool TestNodeForward<T>::IsLeaf() { + return !mFirstChildNode; +} + +template <class T> +TestNodeForward<T>* TestNodeForward<T>::GetFirstChild() { + return mFirstChildNode; +} + +template <class T> +TestNodeForward<T>* TestNodeForward<T>::GetNextSibling() { + return mSiblingNode; +} + +template <class T> +TestNodeBase<T>::TestNodeBase(T aType, int aExpectedTraversalRank) + : mExpectedTraversalRank(aExpectedTraversalRank), + mActualTraversalRank(-1), + mType(aType) {} + +template <class T> +TestNodeBase<T>::TestNodeBase() = default; + +template <class T> +int TestNodeBase<T>::GetActualTraversalRank() { + return mActualTraversalRank; +} + +template <class T> +void TestNodeBase<T>::SetActualTraversalRank(int aRank) { + mActualTraversalRank = aRank; +} + +template <class T> +int TestNodeBase<T>::GetExpectedTraversalRank() { + return mExpectedTraversalRank; +} + +template <class T> +T TestNodeBase<T>::GetType() { + return mType; +} + +template <class T> +void TestNodeBase<T>::SetType(T aType) { + mType = aType; +} + +template <class T> +nsRegion TestNodeBase<T>::GetRegion() { + return mRegion; +} + +template <class T> +void TestNodeBase<T>::SetRegion(nsRegion aRegion) { + mRegion = aRegion; +} + +template <class T> +int TestNodeBase<T>::GetValue() { + return mValue; +} + +template <class T> +void TestNodeBase<T>::SetValue(int aValue) { + mValue = aValue; +} + +typedef TestNodeBase<SearchNodeType> SearchTestNode; +typedef TestNodeBase<ForEachNodeType> ForEachTestNode; +typedef TestNodeReverse<SearchNodeType> SearchTestNodeReverse; +typedef TestNodeReverse<ForEachNodeType> ForEachTestNodeReverse; +typedef TestNodeForward<SearchNodeType> SearchTestNodeForward; +typedef TestNodeForward<ForEachNodeType> ForEachTestNodeForward; + +TEST(TreeTraversal, DepthFirstSearchNull) +{ + RefPtr<SearchTestNodeReverse> nullNode; + RefPtr<SearchTestNodeReverse> result = + DepthFirstSearch<layers::ReverseIterator>( + nullNode.get(), [](SearchTestNodeReverse* aNode) { + return aNode->GetType() == SearchNodeType::Needle; + }); + ASSERT_EQ(result.get(), nullptr) + << "Null root did not return null search result."; +} + +TEST(TreeTraversal, DepthFirstSearchValueExists) +{ + int visitCount = 0; + size_t expectedNeedleTraversalRank = 7; + RefPtr<SearchTestNodeForward> needleNode; + std::vector<RefPtr<SearchTestNodeForward>> nodeList; + nodeList.reserve(10); + for (size_t i = 0; i < 10; i++) { + if (i == expectedNeedleTraversalRank) { + needleNode = new SearchTestNodeForward(SearchNodeType::Needle, i); + nodeList.push_back(needleNode); + } else if (i < expectedNeedleTraversalRank) { + nodeList.push_back(new SearchTestNodeForward(SearchNodeType::Hay, i)); + } else { + nodeList.push_back(new SearchTestNodeForward(SearchNodeType::Hay)); + } + } + + RefPtr<SearchTestNodeForward> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[1]); + nodeList[0]->AddChild(nodeList[4]); + nodeList[1]->AddChild(nodeList[2]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[4]->AddChild(nodeList[5]); + nodeList[4]->AddChild(nodeList[6]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[8]); + nodeList[7]->AddChild(nodeList[9]); + + RefPtr<SearchTestNodeForward> foundNode = + DepthFirstSearch<layers::ForwardIterator>( + root.get(), [&visitCount](SearchTestNodeForward* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode, needleNode) << "Search did not return expected node."; + ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle) + << "Returned node does not match expected value (something odd " + "happened)."; +} + +TEST(TreeTraversal, DepthFirstSearchValueExistsReverse) +{ + int visitCount = 0; + size_t expectedNeedleTraversalRank = 7; + RefPtr<SearchTestNodeReverse> needleNode; + std::vector<RefPtr<SearchTestNodeReverse>> nodeList; + nodeList.reserve(10); + for (size_t i = 0; i < 10; i++) { + if (i == expectedNeedleTraversalRank) { + needleNode = new SearchTestNodeReverse(SearchNodeType::Needle, i); + nodeList.push_back(needleNode); + } else if (i < expectedNeedleTraversalRank) { + nodeList.push_back(new SearchTestNodeReverse(SearchNodeType::Hay, i)); + } else { + nodeList.push_back(new SearchTestNodeReverse(SearchNodeType::Hay)); + } + } + + RefPtr<SearchTestNodeReverse> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[4]); + nodeList[0]->AddChild(nodeList[1]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[1]->AddChild(nodeList[2]); + nodeList[4]->AddChild(nodeList[6]); + nodeList[4]->AddChild(nodeList[5]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[9]); + nodeList[7]->AddChild(nodeList[8]); + + RefPtr<SearchTestNodeReverse> foundNode = + DepthFirstSearch<layers::ReverseIterator>( + root.get(), [&visitCount](SearchTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode, needleNode) << "Search did not return expected node."; + ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle) + << "Returned node does not match expected value (something odd " + "happened)."; +} + +TEST(TreeTraversal, DepthFirstSearchRootIsNeedle) +{ + RefPtr<SearchTestNodeReverse> root = + new SearchTestNodeReverse(SearchNodeType::Needle, 0); + RefPtr<SearchTestNodeReverse> childNode1 = + new SearchTestNodeReverse(SearchNodeType::Hay); + RefPtr<SearchTestNodeReverse> childNode2 = + new SearchTestNodeReverse(SearchNodeType::Hay); + int visitCount = 0; + RefPtr<SearchTestNodeReverse> result = + DepthFirstSearch<layers::ReverseIterator>( + root.get(), [&visitCount](SearchTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + ASSERT_EQ(result, root) << "Search starting at needle did not return needle."; + ASSERT_EQ(root->GetExpectedTraversalRank(), root->GetActualTraversalRank()) + << "Search starting at needle did not return needle."; + ASSERT_EQ(childNode1->GetExpectedTraversalRank(), + childNode1->GetActualTraversalRank()) + << "Search starting at needle continued past needle."; + ASSERT_EQ(childNode2->GetExpectedTraversalRank(), + childNode2->GetActualTraversalRank()) + << "Search starting at needle continued past needle."; +} + +TEST(TreeTraversal, DepthFirstSearchValueDoesNotExist) +{ + int visitCount = 0; + std::vector<RefPtr<SearchTestNodeForward>> nodeList; + nodeList.reserve(10); + for (int i = 0; i < 10; i++) { + nodeList.push_back(new SearchTestNodeForward(SearchNodeType::Hay, i)); + } + + RefPtr<SearchTestNodeForward> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[1]); + nodeList[0]->AddChild(nodeList[4]); + nodeList[1]->AddChild(nodeList[2]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[4]->AddChild(nodeList[5]); + nodeList[4]->AddChild(nodeList[6]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[8]); + nodeList[7]->AddChild(nodeList[9]); + + RefPtr<SearchTestNodeForward> foundNode = + DepthFirstSearch<layers::ForwardIterator>( + root.get(), [&visitCount](SearchTestNodeForward* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (int i = 0; i < 10; i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode.get(), nullptr) + << "Search found something that should not exist."; +} + +TEST(TreeTraversal, DepthFirstSearchValueDoesNotExistReverse) +{ + int visitCount = 0; + std::vector<RefPtr<SearchTestNodeReverse>> nodeList; + nodeList.reserve(10); + for (int i = 0; i < 10; i++) { + nodeList.push_back(new SearchTestNodeReverse(SearchNodeType::Hay, i)); + } + + RefPtr<SearchTestNodeReverse> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[4]); + nodeList[0]->AddChild(nodeList[1]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[1]->AddChild(nodeList[2]); + nodeList[4]->AddChild(nodeList[6]); + nodeList[4]->AddChild(nodeList[5]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[9]); + nodeList[7]->AddChild(nodeList[8]); + + RefPtr<SearchTestNodeReverse> foundNode = + DepthFirstSearch<layers::ReverseIterator>( + root.get(), [&visitCount](SearchTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (int i = 0; i < 10; i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode.get(), nullptr) + << "Search found something that should not exist."; +} + +TEST(TreeTraversal, DepthFirstSearchPostOrderNull) +{ + RefPtr<SearchTestNodeReverse> nullNode; + RefPtr<SearchTestNodeReverse> result = + DepthFirstSearchPostOrder<layers::ReverseIterator>( + nullNode.get(), [](SearchTestNodeReverse* aNode) { + return aNode->GetType() == SearchNodeType::Needle; + }); + ASSERT_EQ(result.get(), nullptr) + << "Null root did not return null search result."; +} + +TEST(TreeTraversal, DepthFirstSearchPostOrderValueExists) +{ + int visitCount = 0; + size_t expectedNeedleTraversalRank = 7; + RefPtr<SearchTestNodeForward> needleNode; + std::vector<RefPtr<SearchTestNodeForward>> nodeList; + for (size_t i = 0; i < 10; i++) { + if (i == expectedNeedleTraversalRank) { + needleNode = new SearchTestNodeForward(SearchNodeType::Needle, i); + nodeList.push_back(needleNode); + } else if (i < expectedNeedleTraversalRank) { + nodeList.push_back(new SearchTestNodeForward(SearchNodeType::Hay, i)); + } else { + nodeList.push_back(new SearchTestNodeForward(SearchNodeType::Hay)); + } + } + + RefPtr<SearchTestNodeForward> root = nodeList[9]; + nodeList[9]->AddChild(nodeList[2]); + nodeList[9]->AddChild(nodeList[8]); + nodeList[2]->AddChild(nodeList[0]); + nodeList[2]->AddChild(nodeList[1]); + nodeList[8]->AddChild(nodeList[6]); + nodeList[8]->AddChild(nodeList[7]); + nodeList[6]->AddChild(nodeList[5]); + nodeList[5]->AddChild(nodeList[3]); + nodeList[5]->AddChild(nodeList[4]); + + RefPtr<SearchTestNodeForward> foundNode = + DepthFirstSearchPostOrder<layers::ForwardIterator>( + root.get(), [&visitCount](SearchTestNodeForward* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode, needleNode) << "Search did not return expected node."; + ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle) + << "Returned node does not match expected value (something odd " + "happened)."; +} + +TEST(TreeTraversal, DepthFirstSearchPostOrderValueExistsReverse) +{ + int visitCount = 0; + size_t expectedNeedleTraversalRank = 7; + RefPtr<SearchTestNodeReverse> needleNode; + std::vector<RefPtr<SearchTestNodeReverse>> nodeList; + for (size_t i = 0; i < 10; i++) { + if (i == expectedNeedleTraversalRank) { + needleNode = new SearchTestNodeReverse(SearchNodeType::Needle, i); + nodeList.push_back(needleNode); + } else if (i < expectedNeedleTraversalRank) { + nodeList.push_back(new SearchTestNodeReverse(SearchNodeType::Hay, i)); + } else { + nodeList.push_back(new SearchTestNodeReverse(SearchNodeType::Hay)); + } + } + + RefPtr<SearchTestNodeReverse> root = nodeList[9]; + nodeList[9]->AddChild(nodeList[8]); + nodeList[9]->AddChild(nodeList[2]); + nodeList[2]->AddChild(nodeList[1]); + nodeList[2]->AddChild(nodeList[0]); + nodeList[8]->AddChild(nodeList[7]); + nodeList[8]->AddChild(nodeList[6]); + nodeList[6]->AddChild(nodeList[5]); + nodeList[5]->AddChild(nodeList[4]); + nodeList[5]->AddChild(nodeList[3]); + + RefPtr<SearchTestNodeReverse> foundNode = + DepthFirstSearchPostOrder<layers::ReverseIterator>( + root.get(), [&visitCount](SearchTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode, needleNode) << "Search did not return expected node."; + ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle) + << "Returned node does not match expected value (something odd " + "happened)."; +} + +TEST(TreeTraversal, DepthFirstSearchPostOrderRootIsNeedle) +{ + RefPtr<SearchTestNodeReverse> root = + new SearchTestNodeReverse(SearchNodeType::Needle, 0); + RefPtr<SearchTestNodeReverse> childNode1 = + new SearchTestNodeReverse(SearchNodeType::Hay); + RefPtr<SearchTestNodeReverse> childNode2 = + new SearchTestNodeReverse(SearchNodeType::Hay); + int visitCount = 0; + RefPtr<SearchTestNodeReverse> result = + DepthFirstSearchPostOrder<layers::ReverseIterator>( + root.get(), [&visitCount](SearchTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + ASSERT_EQ(result, root) << "Search starting at needle did not return needle."; + ASSERT_EQ(root->GetExpectedTraversalRank(), root->GetActualTraversalRank()) + << "Search starting at needle did not return needle."; + ASSERT_EQ(childNode1->GetExpectedTraversalRank(), + childNode1->GetActualTraversalRank()) + << "Search starting at needle continued past needle."; + ASSERT_EQ(childNode2->GetExpectedTraversalRank(), + childNode2->GetActualTraversalRank()) + << "Search starting at needle continued past needle."; +} + +TEST(TreeTraversal, DepthFirstSearchPostOrderValueDoesNotExist) +{ + int visitCount = 0; + std::vector<RefPtr<SearchTestNodeForward>> nodeList; + nodeList.reserve(10); + for (int i = 0; i < 10; i++) { + nodeList.push_back(new SearchTestNodeForward(SearchNodeType::Hay, i)); + } + + RefPtr<SearchTestNodeForward> root = nodeList[9]; + nodeList[9]->AddChild(nodeList[2]); + nodeList[9]->AddChild(nodeList[8]); + nodeList[2]->AddChild(nodeList[0]); + nodeList[2]->AddChild(nodeList[1]); + nodeList[8]->AddChild(nodeList[6]); + nodeList[8]->AddChild(nodeList[7]); + nodeList[6]->AddChild(nodeList[5]); + nodeList[5]->AddChild(nodeList[3]); + nodeList[5]->AddChild(nodeList[4]); + + RefPtr<SearchTestNodeForward> foundNode = + DepthFirstSearchPostOrder<layers::ForwardIterator>( + root.get(), [&visitCount](SearchTestNodeForward* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (int i = 0; i < 10; i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode.get(), nullptr) + << "Search found something that should not exist."; +} + +TEST(TreeTraversal, DepthFirstSearchPostOrderValueDoesNotExistReverse) +{ + int visitCount = 0; + std::vector<RefPtr<SearchTestNodeReverse>> nodeList; + nodeList.reserve(10); + for (int i = 0; i < 10; i++) { + nodeList.push_back(new SearchTestNodeReverse(SearchNodeType::Hay, i)); + } + + RefPtr<SearchTestNodeReverse> root = nodeList[9]; + nodeList[9]->AddChild(nodeList[8]); + nodeList[9]->AddChild(nodeList[2]); + nodeList[2]->AddChild(nodeList[1]); + nodeList[2]->AddChild(nodeList[0]); + nodeList[8]->AddChild(nodeList[7]); + nodeList[8]->AddChild(nodeList[6]); + nodeList[6]->AddChild(nodeList[5]); + nodeList[5]->AddChild(nodeList[4]); + nodeList[5]->AddChild(nodeList[3]); + + RefPtr<SearchTestNodeReverse> foundNode = + DepthFirstSearchPostOrder<layers::ReverseIterator>( + root.get(), [&visitCount](SearchTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (int i = 0; i < 10; i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode.get(), nullptr) + << "Search found something that should not exist."; +} + +TEST(TreeTraversal, BreadthFirstSearchNull) +{ + RefPtr<SearchTestNodeReverse> nullNode; + RefPtr<SearchTestNodeReverse> result = + BreadthFirstSearch<layers::ReverseIterator>( + nullNode.get(), [](SearchTestNodeReverse* aNode) { + return aNode->GetType() == SearchNodeType::Needle; + }); + ASSERT_EQ(result.get(), nullptr) + << "Null root did not return null search result."; +} + +TEST(TreeTraversal, BreadthFirstSearchRootIsNeedle) +{ + RefPtr<SearchTestNodeReverse> root = + new SearchTestNodeReverse(SearchNodeType::Needle, 0); + RefPtr<SearchTestNodeReverse> childNode1 = + new SearchTestNodeReverse(SearchNodeType::Hay); + RefPtr<SearchTestNodeReverse> childNode2 = + new SearchTestNodeReverse(SearchNodeType::Hay); + int visitCount = 0; + RefPtr<SearchTestNodeReverse> result = + BreadthFirstSearch<layers::ReverseIterator>( + root.get(), [&visitCount](SearchTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + ASSERT_EQ(result, root) << "Search starting at needle did not return needle."; + ASSERT_EQ(root->GetExpectedTraversalRank(), root->GetActualTraversalRank()) + << "Search starting at needle did not return needle."; + ASSERT_EQ(childNode1->GetExpectedTraversalRank(), + childNode1->GetActualTraversalRank()) + << "Search starting at needle continued past needle."; + ASSERT_EQ(childNode2->GetExpectedTraversalRank(), + childNode2->GetActualTraversalRank()) + << "Search starting at needle continued past needle."; +} + +TEST(TreeTraversal, BreadthFirstSearchValueExists) +{ + int visitCount = 0; + size_t expectedNeedleTraversalRank = 7; + RefPtr<SearchTestNodeForward> needleNode; + std::vector<RefPtr<SearchTestNodeForward>> nodeList; + nodeList.reserve(10); + for (size_t i = 0; i < 10; i++) { + if (i == expectedNeedleTraversalRank) { + needleNode = new SearchTestNodeForward(SearchNodeType::Needle, i); + nodeList.push_back(needleNode); + } else if (i < expectedNeedleTraversalRank) { + nodeList.push_back(new SearchTestNodeForward(SearchNodeType::Hay, i)); + } else { + nodeList.push_back(new SearchTestNodeForward(SearchNodeType::Hay)); + } + } + + RefPtr<SearchTestNodeForward> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[1]); + nodeList[0]->AddChild(nodeList[2]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[1]->AddChild(nodeList[4]); + nodeList[2]->AddChild(nodeList[5]); + nodeList[2]->AddChild(nodeList[6]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[8]); + nodeList[7]->AddChild(nodeList[9]); + + RefPtr<SearchTestNodeForward> foundNode = + BreadthFirstSearch<layers::ForwardIterator>( + root.get(), [&visitCount](SearchTestNodeForward* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode, needleNode) << "Search did not return expected node."; + ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle) + << "Returned node does not match expected value (something odd " + "happened)."; +} + +TEST(TreeTraversal, BreadthFirstSearchValueExistsReverse) +{ + int visitCount = 0; + size_t expectedNeedleTraversalRank = 7; + RefPtr<SearchTestNodeReverse> needleNode; + std::vector<RefPtr<SearchTestNodeReverse>> nodeList; + nodeList.reserve(10); + for (size_t i = 0; i < 10; i++) { + if (i == expectedNeedleTraversalRank) { + needleNode = new SearchTestNodeReverse(SearchNodeType::Needle, i); + nodeList.push_back(needleNode); + } else if (i < expectedNeedleTraversalRank) { + nodeList.push_back(new SearchTestNodeReverse(SearchNodeType::Hay, i)); + } else { + nodeList.push_back(new SearchTestNodeReverse(SearchNodeType::Hay)); + } + } + + RefPtr<SearchTestNodeReverse> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[2]); + nodeList[0]->AddChild(nodeList[1]); + nodeList[1]->AddChild(nodeList[4]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[2]->AddChild(nodeList[6]); + nodeList[2]->AddChild(nodeList[5]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[9]); + nodeList[7]->AddChild(nodeList[8]); + + RefPtr<SearchTestNodeReverse> foundNode = + BreadthFirstSearch<layers::ReverseIterator>( + root.get(), [&visitCount](SearchTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode, needleNode) << "Search did not return expected node."; + ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle) + << "Returned node does not match expected value (something odd " + "happened)."; +} + +TEST(TreeTraversal, BreadthFirstSearchValueDoesNotExist) +{ + int visitCount = 0; + std::vector<RefPtr<SearchTestNodeForward>> nodeList; + nodeList.reserve(10); + for (int i = 0; i < 10; i++) { + nodeList.push_back(new SearchTestNodeForward(SearchNodeType::Hay, i)); + } + + RefPtr<SearchTestNodeForward> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[1]); + nodeList[0]->AddChild(nodeList[2]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[1]->AddChild(nodeList[4]); + nodeList[2]->AddChild(nodeList[5]); + nodeList[2]->AddChild(nodeList[6]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[8]); + nodeList[7]->AddChild(nodeList[9]); + + RefPtr<SearchTestNodeForward> foundNode = + BreadthFirstSearch<layers::ForwardIterator>( + root.get(), [&visitCount](SearchTestNodeForward* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode.get(), nullptr) + << "Search found something that should not exist."; +} + +TEST(TreeTraversal, BreadthFirstSearchValueDoesNotExistReverse) +{ + int visitCount = 0; + std::vector<RefPtr<SearchTestNodeReverse>> nodeList; + nodeList.reserve(10); + for (int i = 0; i < 10; i++) { + nodeList.push_back(new SearchTestNodeReverse(SearchNodeType::Hay, i)); + } + + RefPtr<SearchTestNodeReverse> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[2]); + nodeList[0]->AddChild(nodeList[1]); + nodeList[1]->AddChild(nodeList[4]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[2]->AddChild(nodeList[6]); + nodeList[2]->AddChild(nodeList[5]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[9]); + nodeList[7]->AddChild(nodeList[8]); + + RefPtr<SearchTestNodeReverse> foundNode = + BreadthFirstSearch<layers::ReverseIterator>( + root.get(), [&visitCount](SearchTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == SearchNodeType::Needle; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + ASSERT_EQ(foundNode.get(), nullptr) + << "Search found something that should not exist."; +} + +TEST(TreeTraversal, ForEachNodeNullStillRuns) +{ + RefPtr<ForEachTestNodeReverse> nullNode; + ForEachNode<layers::ReverseIterator>( + nullNode.get(), + [](ForEachTestNodeReverse* aNode) { return TraversalFlag::Continue; }); +} + +TEST(TreeTraversal, ForEachNodeAllEligible) +{ + std::vector<RefPtr<ForEachTestNodeForward>> nodeList; + int visitCount = 0; + nodeList.reserve(10); + for (int i = 0; i < 10; i++) { + nodeList.push_back( + new ForEachTestNodeForward(ForEachNodeType::Continue, i)); + } + + RefPtr<ForEachTestNodeForward> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[1]); + nodeList[0]->AddChild(nodeList[4]); + nodeList[1]->AddChild(nodeList[2]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[4]->AddChild(nodeList[5]); + nodeList[4]->AddChild(nodeList[6]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[8]); + nodeList[7]->AddChild(nodeList[9]); + + ForEachNode<layers::ForwardIterator>( + root.get(), [&visitCount](ForEachTestNodeForward* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == ForEachNodeType::Continue + ? TraversalFlag::Continue + : TraversalFlag::Skip; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } +} + +TEST(TreeTraversal, ForEachNodeAllEligibleReverse) +{ + std::vector<RefPtr<ForEachTestNodeReverse>> nodeList; + int visitCount = 0; + nodeList.reserve(10); + for (int i = 0; i < 10; i++) { + nodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Continue, i)); + } + + RefPtr<ForEachTestNodeReverse> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[4]); + nodeList[0]->AddChild(nodeList[1]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[1]->AddChild(nodeList[2]); + nodeList[4]->AddChild(nodeList[6]); + nodeList[4]->AddChild(nodeList[5]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[9]); + nodeList[7]->AddChild(nodeList[8]); + + ForEachNode<layers::ReverseIterator>( + root.get(), [&visitCount](ForEachTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == ForEachNodeType::Continue + ? TraversalFlag::Continue + : TraversalFlag::Skip; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } +} + +TEST(TreeTraversal, ForEachNodeSomeIneligibleNodes) +{ + std::vector<RefPtr<ForEachTestNodeForward>> expectedVisitedNodeList; + std::vector<RefPtr<ForEachTestNodeForward>> expectedSkippedNodeList; + int visitCount = 0; + + expectedVisitedNodeList.push_back( + new ForEachTestNodeForward(ForEachNodeType::Continue, 0)); + expectedVisitedNodeList.push_back( + new ForEachTestNodeForward(ForEachNodeType::Skip, 1)); + expectedVisitedNodeList.push_back( + new ForEachTestNodeForward(ForEachNodeType::Continue, 2)); + expectedVisitedNodeList.push_back( + new ForEachTestNodeForward(ForEachNodeType::Skip, 3)); + + expectedSkippedNodeList.push_back( + new ForEachTestNodeForward(ForEachNodeType::Continue)); + expectedSkippedNodeList.push_back( + new ForEachTestNodeForward(ForEachNodeType::Continue)); + expectedSkippedNodeList.push_back( + new ForEachTestNodeForward(ForEachNodeType::Skip)); + expectedSkippedNodeList.push_back( + new ForEachTestNodeForward(ForEachNodeType::Skip)); + + RefPtr<ForEachTestNodeForward> root = expectedVisitedNodeList[0]; + expectedVisitedNodeList[0]->AddChild(expectedVisitedNodeList[1]); + expectedVisitedNodeList[0]->AddChild(expectedVisitedNodeList[2]); + expectedVisitedNodeList[1]->AddChild(expectedSkippedNodeList[0]); + expectedVisitedNodeList[1]->AddChild(expectedSkippedNodeList[1]); + expectedVisitedNodeList[2]->AddChild(expectedVisitedNodeList[3]); + expectedVisitedNodeList[3]->AddChild(expectedSkippedNodeList[2]); + expectedVisitedNodeList[3]->AddChild(expectedSkippedNodeList[3]); + + ForEachNode<layers::ForwardIterator>( + root.get(), [&visitCount](ForEachTestNodeForward* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == ForEachNodeType::Continue + ? TraversalFlag::Continue + : TraversalFlag::Skip; + }); + + for (size_t i = 0; i < expectedVisitedNodeList.size(); i++) { + ASSERT_EQ(expectedVisitedNodeList[i]->GetExpectedTraversalRank(), + expectedVisitedNodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + for (size_t i = 0; i < expectedSkippedNodeList.size(); i++) { + ASSERT_EQ(expectedSkippedNodeList[i]->GetExpectedTraversalRank(), + expectedSkippedNodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << "was not expected to be hit."; + } +} + +TEST(TreeTraversal, ForEachNodeSomeIneligibleNodesReverse) +{ + std::vector<RefPtr<ForEachTestNodeReverse>> expectedVisitedNodeList; + std::vector<RefPtr<ForEachTestNodeReverse>> expectedSkippedNodeList; + int visitCount = 0; + + expectedVisitedNodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Continue, 0)); + expectedVisitedNodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Skip, 1)); + expectedVisitedNodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Continue, 2)); + expectedVisitedNodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Skip, 3)); + + expectedSkippedNodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Continue)); + expectedSkippedNodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Continue)); + expectedSkippedNodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Skip)); + expectedSkippedNodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Skip)); + + RefPtr<ForEachTestNodeReverse> root = expectedVisitedNodeList[0]; + expectedVisitedNodeList[0]->AddChild(expectedVisitedNodeList[2]); + expectedVisitedNodeList[0]->AddChild(expectedVisitedNodeList[1]); + expectedVisitedNodeList[1]->AddChild(expectedSkippedNodeList[1]); + expectedVisitedNodeList[1]->AddChild(expectedSkippedNodeList[0]); + expectedVisitedNodeList[2]->AddChild(expectedVisitedNodeList[3]); + expectedVisitedNodeList[3]->AddChild(expectedSkippedNodeList[3]); + expectedVisitedNodeList[3]->AddChild(expectedSkippedNodeList[2]); + + ForEachNode<layers::ReverseIterator>( + root.get(), [&visitCount](ForEachTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == ForEachNodeType::Continue + ? TraversalFlag::Continue + : TraversalFlag::Skip; + }); + + for (size_t i = 0; i < expectedVisitedNodeList.size(); i++) { + ASSERT_EQ(expectedVisitedNodeList[i]->GetExpectedTraversalRank(), + expectedVisitedNodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } + + for (size_t i = 0; i < expectedSkippedNodeList.size(); i++) { + ASSERT_EQ(expectedSkippedNodeList[i]->GetExpectedTraversalRank(), + expectedSkippedNodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << "was not expected to be hit."; + } +} + +TEST(TreeTraversal, ForEachNodeIneligibleRoot) +{ + int visitCount = 0; + + RefPtr<ForEachTestNodeReverse> root = + new ForEachTestNodeReverse(ForEachNodeType::Skip, 0); + RefPtr<ForEachTestNodeReverse> childNode1 = + new ForEachTestNodeReverse(ForEachNodeType::Continue); + RefPtr<ForEachTestNodeReverse> chlidNode2 = + new ForEachTestNodeReverse(ForEachNodeType::Skip); + + ForEachNode<layers::ReverseIterator>( + root.get(), [&visitCount](ForEachTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == ForEachNodeType::Continue + ? TraversalFlag::Continue + : TraversalFlag::Skip; + }); + + ASSERT_EQ(root->GetExpectedTraversalRank(), root->GetActualTraversalRank()) + << "Root was hit out of order."; + ASSERT_EQ(childNode1->GetExpectedTraversalRank(), + childNode1->GetActualTraversalRank()) + << "Eligible child was still hit."; + ASSERT_EQ(chlidNode2->GetExpectedTraversalRank(), + chlidNode2->GetActualTraversalRank()) + << "Ineligible child was still hit."; +} + +TEST(TreeTraversal, ForEachNodeLeavesIneligible) +{ + std::vector<RefPtr<ForEachTestNodeForward>> nodeList; + nodeList.reserve(10); + int visitCount = 0; + for (int i = 0; i < 10; i++) { + if (i == 1 || i == 9) { + nodeList.push_back(new ForEachTestNodeForward(ForEachNodeType::Skip, i)); + } else { + nodeList.push_back( + new ForEachTestNodeForward(ForEachNodeType::Continue, i)); + } + } + + RefPtr<ForEachTestNodeForward> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[1]); + nodeList[0]->AddChild(nodeList[2]); + nodeList[2]->AddChild(nodeList[3]); + nodeList[2]->AddChild(nodeList[4]); + nodeList[4]->AddChild(nodeList[5]); + nodeList[4]->AddChild(nodeList[6]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[8]); + nodeList[7]->AddChild(nodeList[9]); + + ForEachNode<layers::ForwardIterator>( + root.get(), [&visitCount](ForEachTestNodeForward* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == ForEachNodeType::Continue + ? TraversalFlag::Continue + : TraversalFlag::Skip; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } +} + +TEST(TreeTraversal, ForEachNodeLeavesIneligibleReverse) +{ + std::vector<RefPtr<ForEachTestNodeReverse>> nodeList; + nodeList.reserve(10); + int visitCount = 0; + for (int i = 0; i < 10; i++) { + if (i == 1 || i == 9) { + nodeList.push_back(new ForEachTestNodeReverse(ForEachNodeType::Skip, i)); + } else { + nodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Continue, i)); + } + } + + RefPtr<ForEachTestNodeReverse> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[2]); + nodeList[0]->AddChild(nodeList[1]); + nodeList[2]->AddChild(nodeList[4]); + nodeList[2]->AddChild(nodeList[3]); + nodeList[4]->AddChild(nodeList[6]); + nodeList[4]->AddChild(nodeList[5]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[9]); + nodeList[7]->AddChild(nodeList[8]); + + ForEachNode<layers::ReverseIterator>( + root.get(), [&visitCount](ForEachTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + return aNode->GetType() == ForEachNodeType::Continue + ? TraversalFlag::Continue + : TraversalFlag::Skip; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } +} + +TEST(TreeTraversal, ForEachNodeLambdaReturnsVoid) +{ + std::vector<RefPtr<ForEachTestNodeReverse>> nodeList; + nodeList.reserve(10); + int visitCount = 0; + for (int i = 0; i < 10; i++) { + nodeList.push_back( + new ForEachTestNodeReverse(ForEachNodeType::Continue, i)); + } + + RefPtr<ForEachTestNodeReverse> root = nodeList[0]; + nodeList[0]->AddChild(nodeList[4]); + nodeList[0]->AddChild(nodeList[1]); + nodeList[1]->AddChild(nodeList[3]); + nodeList[1]->AddChild(nodeList[2]); + nodeList[4]->AddChild(nodeList[6]); + nodeList[4]->AddChild(nodeList[5]); + nodeList[6]->AddChild(nodeList[7]); + nodeList[7]->AddChild(nodeList[9]); + nodeList[7]->AddChild(nodeList[8]); + + ForEachNode<layers::ReverseIterator>( + root.get(), [&visitCount](ForEachTestNodeReverse* aNode) { + aNode->SetActualTraversalRank(visitCount); + visitCount++; + }); + + for (size_t i = 0; i < nodeList.size(); i++) { + ASSERT_EQ(nodeList[i]->GetExpectedTraversalRank(), + nodeList[i]->GetActualTraversalRank()) + << "Node at index " << i << " was hit out of order."; + } +} + +struct AssignSearchNodeTypesWithLastLeafAsNeedle { + RefPtr<SearchTestNodeForward>& node; + void operator()(SearchTestNodeForward* aNode) { + aNode->SetType(SearchNodeType::Hay); + if (aNode->IsLeaf()) { + node = aNode; + } + } +}; + +struct AssignSearchNodeTypesAllHay { + void operator()(SearchTestNode* aNode) { + aNode->SetType(SearchNodeType::Hay); + } +}; + +struct AssignSearchNodeTypesWithFirstLeafAsNeedle { + RefPtr<SearchTestNodeReverse>& needleNode; + void operator()(SearchTestNodeReverse* aNode) { + if (!needleNode && aNode->IsLeaf()) { + needleNode = aNode; + } + aNode->SetType(SearchNodeType::Hay); + } +}; + +struct AssignSearchNodeValuesAllFalseValuesReverse { + int falseValue; + RefPtr<SearchTestNodeReverse>& needleNode; + void operator()(SearchTestNodeReverse* aNode) { + aNode->SetValue(falseValue); + if (!needleNode && aNode->IsLeaf()) { + needleNode = aNode; + } + } +}; + +struct AssignSearchNodeValuesAllFalseValuesForward { + int falseValue; + RefPtr<SearchTestNodeForward>& needleNode; + void operator()(SearchTestNodeForward* aNode) { + aNode->SetValue(falseValue); + needleNode = aNode; + } +}; + +struct AllocateUnitRegionsToLeavesOnly { + int& xWrap; + int& squareCount; + void operator()(ForEachTestNode* aNode) { + if (aNode->IsLeaf()) { + int x = squareCount % xWrap; + int y = squareCount / xWrap; + aNode->SetRegion(nsRegion(nsRect(x, y, 1, 1))); + squareCount++; + } + } +}; + +template <typename Node> +static RefPtr<Node> DepthFirstSearchForwardRecursive(RefPtr<Node> aNode) { + if (aNode->GetType() == SearchNodeType::Needle) { + return aNode; + } + for (RefPtr<Node> node = aNode->GetFirstChild(); node != nullptr; + node = node->GetNextSibling()) { + if (RefPtr<Node> foundNode = DepthFirstSearchForwardRecursive(node)) { + return foundNode; + } + } + return nullptr; +} + +template <typename Node> +static RefPtr<Node> DepthFirstSearchCaptureVariablesForwardRecursive( + RefPtr<Node> aNode, int a, int b, int c, int d, int e, int f, int g, int h, + int i, int j, int k, int l, int m, int& n, int& o, int& p, int& q, int& r, + int& s, int& t, int& u, int& v, int& w, int& x, int& y, int& z) { + if (aNode->GetValue() == a + b + c + d + e + f + g + h + i + j + k + l + m + + n + o + p + q + r + s + t + u + v + w + x + y + + z) { + return aNode; + } + for (RefPtr<Node> node = aNode->GetFirstChild(); node != nullptr; + node = node->GetNextSibling()) { + if (RefPtr<Node> foundNode = + DepthFirstSearchCaptureVariablesForwardRecursive( + node, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, + t, u, v, w, x, y, z)) { + return foundNode; + } + } + return nullptr; +} + +template <typename Node> +static RefPtr<Node> DepthFirstSearchPostOrderForwardRecursive( + RefPtr<Node> aNode) { + for (RefPtr<Node> node = aNode->GetFirstChild(); node != nullptr; + node = node->GetNextSibling()) { + if (RefPtr<Node> foundNode = + DepthFirstSearchPostOrderForwardRecursive(node)) { + return foundNode; + } + } + if (aNode->GetType() == SearchNodeType::Needle) { + return aNode; + } + return nullptr; +} + +template <typename Node> +static RefPtr<Node> BreadthFirstSearchForwardQueue(RefPtr<Node> aNode) { + std::queue<RefPtr<Node>> nodes; + nodes.push(aNode); + while (!nodes.empty()) { + RefPtr<Node> node = nodes.front(); + nodes.pop(); + if (node->GetType() == SearchNodeType::Needle) { + return node; + } + for (RefPtr<Node> childNode = node->GetFirstChild(); childNode != nullptr; + childNode = childNode->GetNextSibling()) { + nodes.push(childNode); + } + } + return nullptr; +} + +template <typename Node> +static RefPtr<Node> DepthFirstSearchReverseRecursive(RefPtr<Node> aNode) { + if (aNode->GetType() == SearchNodeType::Needle) { + return aNode; + } + for (RefPtr<Node> node = aNode->GetLastChild(); node != nullptr; + node = node->GetPrevSibling()) { + if (RefPtr<Node> foundNode = DepthFirstSearchReverseRecursive(node)) { + return foundNode; + } + } + return nullptr; +} + +template <typename Node> +static RefPtr<Node> DepthFirstSearchCaptureVariablesReverseRecursive( + RefPtr<Node> aNode, int a, int b, int c, int d, int e, int f, int g, int h, + int i, int j, int k, int l, int m, int& n, int& o, int& p, int& q, int& r, + int& s, int& t, int& u, int& v, int& w, int& x, int& y, int& z) { + if (aNode->GetValue() == a + b + c + d + e + f + g + h + i + j + k + l + m + + n + o + p + q + r + s + t + u + v + w + x + y + + z) { + return aNode; + } + for (RefPtr<Node> node = aNode->GetLastChild(); node != nullptr; + node = node->GetPrevSibling()) { + if (RefPtr<Node> foundNode = + DepthFirstSearchCaptureVariablesReverseRecursive( + node, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, + t, u, v, w, x, y, z)) { + return foundNode; + } + } + return nullptr; +} + +template <typename Node> +static RefPtr<Node> DepthFirstSearchPostOrderReverseRecursive( + RefPtr<Node> aNode) { + for (RefPtr<Node> node = aNode->GetLastChild(); node != nullptr; + node = node->GetPrevSibling()) { + if (RefPtr<Node> foundNode = + DepthFirstSearchPostOrderReverseRecursive(node)) { + return foundNode; + } + } + if (aNode->GetType() == SearchNodeType::Needle) { + return aNode; + } + return nullptr; +} + +template <typename Node> +static RefPtr<Node> BreadthFirstSearchReverseQueue(RefPtr<Node> aNode) { + std::queue<RefPtr<Node>> nodes; + nodes.push(aNode); + while (!nodes.empty()) { + RefPtr<Node> node = nodes.front(); + nodes.pop(); + if (node->GetType() == SearchNodeType::Needle) { + return node; + } + for (RefPtr<Node> childNode = node->GetLastChild(); childNode != nullptr; + childNode = childNode->GetPrevSibling()) { + nodes.push(childNode); + } + } + return nullptr; +} diff --git a/gfx/tests/gtest/TestVsync.cpp b/gfx/tests/gtest/TestVsync.cpp new file mode 100644 index 0000000000..7249e7d26c --- /dev/null +++ b/gfx/tests/gtest/TestVsync.cpp @@ -0,0 +1,173 @@ +/* vim:set ts=2 sw=2 sts=2 et: */ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +#include "gmock/gmock.h" +#include "gtest/gtest.h" +#include "gfxPlatform.h" + +#include "MainThreadUtils.h" +#include "nsIThread.h" +#include "mozilla/RefPtr.h" +#include "SoftwareVsyncSource.h" +#include "VsyncSource.h" +#include "mozilla/gtest/MozAssertions.h" +#include "mozilla/Monitor.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/VsyncDispatcher.h" + +using namespace mozilla; +using namespace mozilla::gfx; +using namespace mozilla::layers; +using ::testing::_; + +// Timeout for vsync events to occur in milliseconds +// Windows 8.1 has intermittents at 50 ms. Raise limit to 5 vsync intervals. +const int kVsyncTimeoutMS = 80; + +class TestVsyncObserver : public VsyncObserver { + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(TestVsyncObserver, override) + + public: + TestVsyncObserver() + : mDidGetVsyncNotification(false), mVsyncMonitor("VsyncMonitor") {} + + virtual void NotifyVsync(const VsyncEvent& aVsync) override { + MonitorAutoLock lock(mVsyncMonitor); + mDidGetVsyncNotification = true; + mVsyncMonitor.Notify(); + } + + void WaitForVsyncNotification() { + MOZ_ASSERT(NS_IsMainThread()); + if (DidGetVsyncNotification()) { + return; + } + + { // scope lock + MonitorAutoLock lock(mVsyncMonitor); + lock.Wait(TimeDuration::FromMilliseconds(kVsyncTimeoutMS)); + } + } + + bool DidGetVsyncNotification() { + MonitorAutoLock lock(mVsyncMonitor); + return mDidGetVsyncNotification; + } + + void ResetVsyncNotification() { + MonitorAutoLock lock(mVsyncMonitor); + mDidGetVsyncNotification = false; + } + + private: + ~TestVsyncObserver() = default; + + bool mDidGetVsyncNotification; + + private: + Monitor mVsyncMonitor MOZ_UNANNOTATED; +}; + +class VsyncTester : public ::testing::Test { + protected: + explicit VsyncTester() { + gfxPlatform::GetPlatform(); + mVsyncDispatcher = gfxPlatform::GetPlatform()->GetGlobalVsyncDispatcher(); + mVsyncSource = mVsyncDispatcher->GetCurrentVsyncSource(); + MOZ_RELEASE_ASSERT(mVsyncSource, "GFX: Vsync source not found."); + } + + virtual ~VsyncTester() { mVsyncSource = nullptr; } + + RefPtr<VsyncDispatcher> mVsyncDispatcher; + RefPtr<VsyncSource> mVsyncSource; +}; + +static void FlushMainThreadLoop() { + // Some tasks are pushed onto the main thread when adding vsync observers + // This function will ensure all tasks are executed on the main thread + // before returning. + nsCOMPtr<nsIThread> mainThread; + nsresult rv = NS_GetMainThread(getter_AddRefs(mainThread)); + ASSERT_NS_SUCCEEDED(rv); + + rv = NS_OK; + bool processed = true; + while (processed && NS_SUCCEEDED(rv)) { + rv = mainThread->ProcessNextEvent(false, &processed); + } +} + +// Tests that we can enable/disable vsync notifications +TEST_F(VsyncTester, EnableVsync) { + mVsyncSource->DisableVsync(); + ASSERT_FALSE(mVsyncSource->IsVsyncEnabled()); + + mVsyncSource->EnableVsync(); + ASSERT_TRUE(mVsyncSource->IsVsyncEnabled()); + + mVsyncSource->DisableVsync(); + ASSERT_FALSE(mVsyncSource->IsVsyncEnabled()); +} + +// Test that if we have vsync enabled, the source should get vsync +// notifications +TEST_F(VsyncTester, CompositorGetVsyncNotifications) { + mVsyncSource->DisableVsync(); + ASSERT_FALSE(mVsyncSource->IsVsyncEnabled()); + + RefPtr<CompositorVsyncDispatcher> vsyncDispatcher = + new CompositorVsyncDispatcher(mVsyncDispatcher); + RefPtr<TestVsyncObserver> testVsyncObserver = new TestVsyncObserver(); + + vsyncDispatcher->SetCompositorVsyncObserver(testVsyncObserver); + FlushMainThreadLoop(); + ASSERT_TRUE(mVsyncSource->IsVsyncEnabled()); + + testVsyncObserver->WaitForVsyncNotification(); + ASSERT_TRUE(testVsyncObserver->DidGetVsyncNotification()); + + vsyncDispatcher->SetCompositorVsyncObserver(nullptr); + FlushMainThreadLoop(); + + vsyncDispatcher = nullptr; + testVsyncObserver = nullptr; + ASSERT_FALSE(mVsyncSource->IsVsyncEnabled()); +} + +// Test that child refresh vsync observers get vsync notifications +TEST_F(VsyncTester, ChildRefreshDriverGetVsyncNotifications) { + mVsyncSource->DisableVsync(); + ASSERT_FALSE(mVsyncSource->IsVsyncEnabled()); + + ASSERT_TRUE(mVsyncDispatcher != nullptr); + + RefPtr<TestVsyncObserver> testVsyncObserver = new TestVsyncObserver(); + mVsyncDispatcher->AddVsyncObserver(testVsyncObserver); + ASSERT_TRUE(mVsyncSource->IsVsyncEnabled()); + + testVsyncObserver->WaitForVsyncNotification(); + ASSERT_TRUE(testVsyncObserver->DidGetVsyncNotification()); + + mVsyncDispatcher->RemoveVsyncObserver(testVsyncObserver); + testVsyncObserver->ResetVsyncNotification(); + testVsyncObserver->WaitForVsyncNotification(); + ASSERT_FALSE(testVsyncObserver->DidGetVsyncNotification()); + + testVsyncObserver = nullptr; + + mVsyncSource->DisableVsync(); + ASSERT_FALSE(mVsyncSource->IsVsyncEnabled()); +} + +// Test that we can read the vsync rate +TEST_F(VsyncTester, VsyncSourceHasVsyncRate) { + TimeDuration vsyncRate = mVsyncSource->GetVsyncRate(); + ASSERT_NE(vsyncRate, TimeDuration::Forever()); + ASSERT_GT(vsyncRate.ToMilliseconds(), 0); + + mVsyncSource->DisableVsync(); + ASSERT_FALSE(mVsyncSource->IsVsyncEnabled()); +} diff --git a/gfx/tests/gtest/TextureHelper.h b/gfx/tests/gtest/TextureHelper.h new file mode 100644 index 0000000000..9fa1a07096 --- /dev/null +++ b/gfx/tests/gtest/TextureHelper.h @@ -0,0 +1,134 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include <vector> + +#include "Types.h" +#include "gfxImageSurface.h" +#include "gfxPlatform.h" +#include "mozilla/RefPtr.h" +#include "mozilla/gfx/Point.h" +#include "mozilla/layers/BufferTexture.h" +#include "mozilla/layers/LayersTypes.h" +#include "mozilla/layers/TextureClient.h" +#include "mozilla/layers/TextureHost.h" +#ifdef XP_WIN +# include "IMFYCbCrImage.h" +# include "mozilla/gfx/DeviceManagerDx.h" +# include "mozilla/layers/D3D11YCbCrImage.h" +# include "mozilla/layers/TextureD3D11.h" +#endif + +namespace mozilla { +namespace layers { + +using gfx::BackendType; +using gfx::IntSize; +using gfx::SurfaceFormat; + +/** + * Create a YCbCrTextureClient according to the given backend. + */ +static already_AddRefed<TextureClient> CreateYCbCrTextureClientWithBackend( + LayersBackend aLayersBackend) { + TextureData* data = nullptr; + IntSize size = IntSize(200, 150); + IntSize ySize = IntSize(400, 300); + + RefPtr<gfxImageSurface> ySurface = + new gfxImageSurface(ySize, SurfaceFormat::A8); + RefPtr<gfxImageSurface> cbSurface = + new gfxImageSurface(size, SurfaceFormat::A8); + RefPtr<gfxImageSurface> crSurface = + new gfxImageSurface(size, SurfaceFormat::A8); + + PlanarYCbCrData clientData; + clientData.mYChannel = ySurface->Data(); + clientData.mCbChannel = cbSurface->Data(); + clientData.mCrChannel = crSurface->Data(); + clientData.mPictureRect = IntRect(IntPoint(0, 0), ySurface->GetSize()); + clientData.mYStride = ySurface->Stride(); + clientData.mCbCrStride = cbSurface->Stride(); + clientData.mStereoMode = StereoMode::MONO; + clientData.mChromaSubsampling = ChromaSubsampling::HALF_WIDTH_AND_HEIGHT; + clientData.mYSkip = 0; + clientData.mCbSkip = 0; + clientData.mCrSkip = 0; + clientData.mCrSkip = 0; + + // Create YCbCrTexture for basic backend. + if (aLayersBackend == LayersBackend::LAYERS_BASIC) { + return TextureClient::CreateForYCbCr( + nullptr, clientData.mPictureRect, clientData.YDataSize(), + clientData.mYStride, clientData.CbCrDataSize(), clientData.mCbCrStride, + StereoMode::MONO, gfx::ColorDepth::COLOR_8, gfx::YUVColorSpace::BT601, + gfx::ColorRange::LIMITED, clientData.mChromaSubsampling, + TextureFlags::DEALLOCATE_CLIENT); + } + + if (data) { + return MakeAndAddRef<TextureClient>(data, TextureFlags::DEALLOCATE_CLIENT, + nullptr); + } + + return nullptr; +} + +/** + * Create a TextureClient according to the given backend. + */ +static already_AddRefed<TextureClient> CreateTextureClientWithBackend( + LayersBackend aLayersBackend) { + TextureData* data = nullptr; + SurfaceFormat format = gfxPlatform::GetPlatform()->Optimal2DFormatForContent( + gfxContentType::COLOR_ALPHA); + BackendType moz2DBackend = + gfxPlatform::GetPlatform()->GetContentBackendFor(aLayersBackend); + TextureAllocationFlags allocFlags = TextureAllocationFlags::ALLOC_DEFAULT; + IntSize size = IntSize(400, 300); + TextureFlags textureFlags = TextureFlags::DEALLOCATE_CLIENT; + + if (!gfx::Factory::AllowedSurfaceSize(size)) { + return nullptr; + } + + if (!data && aLayersBackend == LayersBackend::LAYERS_BASIC) { + // Create BufferTextureData. + data = BufferTextureData::Create(size, format, moz2DBackend, aLayersBackend, + textureFlags, allocFlags, nullptr); + } + + if (data) { + return MakeAndAddRef<TextureClient>(data, textureFlags, nullptr); + } + + return nullptr; +} + +/** + * Create a TextureHost according to the given TextureClient. + */ +already_AddRefed<TextureHost> CreateTextureHostWithBackend( + TextureClient* aClient, ISurfaceAllocator* aDeallocator, + LayersBackend& aLayersBackend) { + if (!aClient) { + return nullptr; + } + + // client serialization + SurfaceDescriptor descriptor; + ReadLockDescriptor readLock = null_t(); + RefPtr<TextureHost> textureHost; + + aClient->ToSurfaceDescriptor(descriptor); + + wr::MaybeExternalImageId id = Nothing(); + return TextureHost::Create(descriptor, readLock, aDeallocator, aLayersBackend, + aClient->GetFlags(), id); +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/tests/gtest/gfxSurfaceRefCountTest.cpp b/gfx/tests/gtest/gfxSurfaceRefCountTest.cpp new file mode 100644 index 0000000000..77ab5aeb91 --- /dev/null +++ b/gfx/tests/gtest/gfxSurfaceRefCountTest.cpp @@ -0,0 +1,155 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include <stdio.h> + +#include "gtest/gtest.h" + +#include "gfxASurface.h" +#include "gfxImageSurface.h" + +#include "nsISupportsUtils.h" // for NS_ADDREF + +#include "cairo.h" + +static int GetASurfaceRefCount(gfxASurface* s) { + NS_ADDREF(s); + return s->Release(); +} + +static int CheckInt(int value, int expected) { + if (value != expected) { + fprintf(stderr, "Expected %d got %d\n", expected, value); + return 1; + } + + return 0; +} + +static int CheckPointer(void* value, void* expected) { + if (value != expected) { + fprintf(stderr, "Expected %p got %p\n", expected, value); + return 1; + } + + return 0; +} + +static cairo_user_data_key_t destruction_key; +static void SurfaceDestroyNotifier(void* data) { *(int*)data = 1; } + +static int TestNewSurface() { + int failures = 0; + int destroyed = 0; + + RefPtr<gfxASurface> s = + new gfxImageSurface(mozilla::gfx::IntSize(10, 10), + mozilla::gfx::SurfaceFormat::A8R8G8B8_UINT32); + cairo_surface_t* cs = s->CairoSurface(); + + cairo_surface_set_user_data(cs, &destruction_key, &destroyed, + SurfaceDestroyNotifier); + + failures += CheckInt(GetASurfaceRefCount(s.get()), 1); + failures += CheckInt(cairo_surface_get_reference_count(cs), 1); + failures += CheckInt(destroyed, 0); + + cairo_surface_reference(cs); + + failures += CheckInt(GetASurfaceRefCount(s.get()), 2); + failures += CheckInt(cairo_surface_get_reference_count(cs), 2); + failures += CheckInt(destroyed, 0); + + gfxASurface* savedWrapper = s.get(); + + s = nullptr; + + failures += CheckInt(cairo_surface_get_reference_count(cs), 1); + failures += CheckInt(destroyed, 0); + + s = gfxASurface::Wrap(cs); + + failures += CheckPointer(s.get(), savedWrapper); + failures += CheckInt(GetASurfaceRefCount(s.get()), 2); + failures += CheckInt(cairo_surface_get_reference_count(cs), 2); + failures += CheckInt(destroyed, 0); + + cairo_surface_destroy(cs); + + failures += CheckInt(GetASurfaceRefCount(s.get()), 1); + failures += CheckInt(cairo_surface_get_reference_count(cs), 1); + failures += CheckInt(destroyed, 0); + + s = nullptr; + + failures += CheckInt(destroyed, 1); + + return failures; +} + +static int TestExistingSurface() { + int failures = 0; + int destroyed = 0; + + cairo_surface_t* cs = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 10, 10); + + cairo_surface_set_user_data(cs, &destruction_key, &destroyed, + SurfaceDestroyNotifier); + + failures += CheckInt(cairo_surface_get_reference_count(cs), 1); + failures += CheckInt(destroyed, 0); + + RefPtr<gfxASurface> s = gfxASurface::Wrap(cs); + + failures += CheckInt(GetASurfaceRefCount(s.get()), 2); + + cairo_surface_reference(cs); + + failures += CheckInt(GetASurfaceRefCount(s.get()), 3); + failures += CheckInt(cairo_surface_get_reference_count(cs), 3); + failures += CheckInt(destroyed, 0); + + gfxASurface* savedWrapper = s.get(); + + s = nullptr; + + failures += CheckInt(cairo_surface_get_reference_count(cs), 2); + failures += CheckInt(destroyed, 0); + + s = gfxASurface::Wrap(cs); + + failures += CheckPointer(s.get(), savedWrapper); + failures += CheckInt(GetASurfaceRefCount(s.get()), 3); + failures += CheckInt(cairo_surface_get_reference_count(cs), 3); + failures += CheckInt(destroyed, 0); + + cairo_surface_destroy(cs); + + failures += CheckInt(GetASurfaceRefCount(s.get()), 2); + failures += CheckInt(cairo_surface_get_reference_count(cs), 2); + failures += CheckInt(destroyed, 0); + + s = nullptr; + + failures += CheckInt(cairo_surface_get_reference_count(cs), 1); + failures += CheckInt(destroyed, 0); + + cairo_surface_destroy(cs); + + failures += CheckInt(destroyed, 1); + + return failures; +} + +TEST(Gfx, SurfaceRefCount) +{ + int fail; + + fail = TestNewSurface(); + EXPECT_TRUE(fail == 0) << "TestNewSurface: " << fail << " failures"; + fail = TestExistingSurface(); + EXPECT_TRUE(fail == 0) << "TestExistingSurface: " << fail << " failures"; +} diff --git a/gfx/tests/gtest/moz.build b/gfx/tests/gtest/moz.build new file mode 100644 index 0000000000..a561ae20af --- /dev/null +++ b/gfx/tests/gtest/moz.build @@ -0,0 +1,76 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +UNIFIED_SOURCES += [ + "gfxSurfaceRefCountTest.cpp", + "MockWidget.cpp", + "PolygonTestUtils.cpp", + "TestArena.cpp", + "TestArrayView.cpp", + "TestBSPTree.cpp", + "TestBufferRotation.cpp", + "TestColorNames.cpp", + "TestConfigManager.cpp", + "TestCoord.cpp", + "TestGfxWidgets.cpp", + "TestMatrix.cpp", + "TestMoz2D.cpp", + "TestPolygon.cpp", + "TestQcms.cpp", + "TestRegion.cpp", + "TestSkipChars.cpp", + "TestSwizzle.cpp", + "TestTextures.cpp", + "TestTreeTraversal.cpp", +] + +# skip the test on windows10-aarch64 due to perma-crash - bug 1544961 +if not (CONFIG["OS_TARGET"] == "WINNT" and CONFIG["CPU_ARCH"] == "aarch64"): + UNIFIED_SOURCES += [ + "TestVsync.cpp", + ] + +if CONFIG["OS_TARGET"] != "Android": + UNIFIED_SOURCES += [ + "TestRect.cpp", + ] + +UNIFIED_SOURCES += [ + "/gfx/2d/unittest/%s" % p + for p in [ + "TestBase.cpp", + "TestBugs.cpp", + "TestCairo.cpp", + "TestPoint.cpp", + "TestScaling.cpp", + ] +] + +UNIFIED_SOURCES += [ + "/gfx/ots/tests/cff_charstring_test.cc", +] + +# ICC profiles used for verifying QCMS transformations. The copyright +# notice embedded in the profiles should be reviewed to ensure there are +# no known restrictions on distribution. +TEST_HARNESS_FILES.gtest += [ + "../../qcms/profiles/lcms_samsung_syncmaster.icc", + "../../qcms/profiles/lcms_thinkpad_w540.icc", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +LOCAL_INCLUDES += [ + "/gfx/2d", + "/gfx/2d/unittest", + "/gfx/cairo/cairo/src", + "/gfx/config", + "/gfx/layers", + "/gfx/ots/src", + "/gfx/qcms", +] + +FINAL_LIBRARY = "xul-gtest" |