/* -*- 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 "nsRect.h"

#include "gfxRect.h"

#include "mozilla/WritingModes.h"

#ifdef XP_WIN

#include <windows.h>

#endif

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;

}

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestConstructors<nsRect>()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestConstructors<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> >()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestConstructors<mozilla::gfx::RectTyped<mozilla::gfx::UnknownUnits, double> >()

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;

}

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestEqualityOperator<nsRect>()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestEqualityOperator<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> >()

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;

}

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestContainment<nsRect>()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestContainment<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> >()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestContainment<mozilla::gfx::RectTyped<mozilla::gfx::UnknownUnits, double> >()

// 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;

}

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestIntersects<nsRect>()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestIntersects<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> >()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestIntersects<mozilla::gfx::RectTyped<mozilla::gfx::UnknownUnits, double> >()

// 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;

}

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestIntersection<nsRect>()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestIntersection<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> >()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestIntersection<mozilla::gfx::RectTyped<mozilla::gfx::UnknownUnits, double> >()

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;

}

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestUnion<nsRect>()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestUnion<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> >()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestUnion<mozilla::gfx::RectTyped<mozilla::gfx::UnknownUnits, double> >()

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;

}

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestBug1135677<nsRect>()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestBug1135677<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> >()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestBug1135677<mozilla::gfx::RectTyped<mozilla::gfx::UnknownUnits, double> >()

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;

}

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestSetWH<nsRect>()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestSetWH<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> >()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestSetWH<mozilla::gfx::RectTyped<mozilla::gfx::UnknownUnits, double> >()

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;

}

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestSwap<nsRect>()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestSwap<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> >()

Unexecuted instantiation: Unified_cpp_gfx_tests_gtest1.cpp:bool TestSwap<mozilla::gfx::RectTyped<mozilla::gfx::UnknownUnits, double> >()

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(WritingMode()), r1.BStart(WritingMode()),

                                            r1.ISize(WritingMode()), r1.BSize(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(WritingMode()), r4.BStart(WritingMode()),

                                            r4.ISize(WritingMode()), r4.BSize(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(WritingMode()), r7.BStart(WritingMode()),

                                            r7.ISize(WritingMode()), r7.BSize(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>();

  TestBug1135677<nsRect>();

  TestSetWH<nsRect>();

  TestSwap<nsRect>();

}

TEST(Gfx, nsIntRect) {

  TestConstructors<nsIntRect>();

  TestEqualityOperator<nsIntRect>();

  TestContainment<nsIntRect>();

  TestIntersects<nsIntRect>();

  TestIntersection<nsIntRect>();

  TestUnion<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>();

  TestBug1135677<gfxRect>();

  TestFiniteGfx();

  TestSetWH<gfxRect>();

  TestSwap<gfxRect>();

}