insets_unittest.cc File Reference

#include "insets.h"
#include "gtest/gtest.h"
#include "insets_f.h"
#include "rect.h"
#include "size.h"
#include "vector2d.h"

Go to the source code of this file.

Functions
	TEST (InsetsTest, InsetsDefault)
	TEST (InsetsTest, Insets)
	TEST (InsetsTest, SetTop)
	TEST (InsetsTest, SetBottom)
	TEST (InsetsTest, SetLeft)
	TEST (InsetsTest, SetRight)
	TEST (InsetsTest, Set)
	TEST (InsetsTest, Operators)
	TEST (InsetsFTest, Operators)
	TEST (InsetsTest, Equality)
	TEST (InsetsTest, ToString)
	TEST (InsetsTest, Offset)
	TEST (InsetsTest, Scale)
	TEST (InsetsTest, IntegerOverflow)
	TEST (InsetsTest, IntegerUnderflow)
	TEST (InsetsTest, IntegerOverflowSetVariants)
	TEST (InsetsTest, IntegerUnderflowSetVariants)
	TEST (InsetsTest, IntegerOverflowSet)
	TEST (InsetsTest, IntegerOverflowOffset)
	TEST (InsetsTest, IntegerUnderflowOffset)
	TEST (InsetsTest, Size)

Function Documentation

TEST() [1/21]

TEST	(	InsetsFTest	,
		Operators
	)

Definition at line 96 of file insets_unittest.cc.

                             {
  gfx::InsetsF insets;
  insets.Set(1.f, 2.5f, 3.3f, 4.1f);
  insets += gfx::InsetsF(5.8f, 6.7f, 7.6f, 8.5f);
  EXPECT_FLOAT_EQ(6.8f, insets.top());
  EXPECT_FLOAT_EQ(9.2f, insets.left());
  EXPECT_FLOAT_EQ(10.9f, insets.bottom());
  EXPECT_FLOAT_EQ(12.6f, insets.right());
 
  insets -= gfx::InsetsF(-1.f, 0, 1.1f, 2.2f);
  EXPECT_FLOAT_EQ(7.8f, insets.top());
  EXPECT_FLOAT_EQ(9.2f, insets.left());
  EXPECT_FLOAT_EQ(9.8f, insets.bottom());
  EXPECT_FLOAT_EQ(10.4f, insets.right());
 
  insets = gfx::InsetsF(10, 10.1f, 10.01f, 10.001f) +
           gfx::InsetsF(5.5f, 5.f, 0, -20.2f);
  EXPECT_FLOAT_EQ(15.5f, insets.top());
  EXPECT_FLOAT_EQ(15.1f, insets.left());
  EXPECT_FLOAT_EQ(10.01f, insets.bottom());
  EXPECT_FLOAT_EQ(-10.199f, insets.right());
 
  insets = gfx::InsetsF(10, 10.1f, 10.01f, 10.001f) -
           gfx::InsetsF(5.5f, 5.f, 0, -20.2f);
  EXPECT_FLOAT_EQ(4.5f, insets.top());
  EXPECT_FLOAT_EQ(5.1f, insets.left());
  EXPECT_FLOAT_EQ(10.01f, insets.bottom());
  EXPECT_FLOAT_EQ(30.201f, insets.right());
}

TEST() [2/21]

TEST	(	InsetsTest	,
		Equality
	)

Definition at line 126 of file insets_unittest.cc.

                           {
  gfx::Insets insets1;
  insets1.Set(1, 2, 3, 4);
  gfx::Insets insets2;
  // Test operator== and operator!=.
  EXPECT_FALSE(insets1 == insets2);
  EXPECT_TRUE(insets1 != insets2);
 
  insets2.Set(1, 2, 3, 4);
  EXPECT_TRUE(insets1 == insets2);
  EXPECT_FALSE(insets1 != insets2);
}

TEST() [3/21]

TEST	(	InsetsTest	,
		Insets
	)

Definition at line 24 of file insets_unittest.cc.

                         {
  gfx::Insets insets(1, 2, 3, 4);
  EXPECT_EQ(1, insets.top());
  EXPECT_EQ(2, insets.left());
  EXPECT_EQ(3, insets.bottom());
  EXPECT_EQ(4, insets.right());
  EXPECT_EQ(6, insets.width());   // Left + right.
  EXPECT_EQ(4, insets.height());  // Top + bottom.
  EXPECT_FALSE(insets.IsEmpty());
}

TEST() [4/21]

TEST	(	InsetsTest	,
		InsetsDefault
	)

Definition at line 13 of file insets_unittest.cc.

                                {
  gfx::Insets insets;
  EXPECT_EQ(0, insets.top());
  EXPECT_EQ(0, insets.left());
  EXPECT_EQ(0, insets.bottom());
  EXPECT_EQ(0, insets.right());
  EXPECT_EQ(0, insets.width());
  EXPECT_EQ(0, insets.height());
  EXPECT_TRUE(insets.IsEmpty());
}

TEST() [5/21]

TEST	(	InsetsTest	,
		IntegerOverflow
	)

Definition at line 176 of file insets_unittest.cc.

                                  {
  constexpr int int_min = std::numeric_limits<int>::min();
  constexpr int int_max = std::numeric_limits<int>::max();
 
  gfx::Insets width_height_test(int_max);
  EXPECT_EQ(int_max, width_height_test.width());
  EXPECT_EQ(int_max, width_height_test.height());
 
  gfx::Insets plus_test(int_max);
  plus_test += gfx::Insets(int_max);
  EXPECT_EQ(gfx::Insets(int_max), plus_test);
 
  gfx::Insets negation_test = -gfx::Insets(int_min);
  EXPECT_EQ(gfx::Insets(int_max), negation_test);
 
  gfx::Insets scale_test(int_max);
  scale_test = scale_test.Scale(2.f, 2.f);
  EXPECT_EQ(gfx::Insets(int_max), scale_test);
}

TEST() [6/21]

TEST	(	InsetsTest	,
		IntegerOverflowOffset
	)

Definition at line 265 of file insets_unittest.cc.

                                        {
  constexpr int int_max = std::numeric_limits<int>::max();
 
  const gfx::Vector2d max_vector(int_max, int_max);
  gfx::Insets insets(1, 2, 3, 4);
  gfx::Insets offset_test = insets.Offset(max_vector);
  EXPECT_EQ(gfx::Insets(int_max, int_max, 3 - int_max, 4 - int_max),
            offset_test);
}

TEST() [7/21]

TEST	(	InsetsTest	,
		IntegerOverflowSet
	)

Definition at line 257 of file insets_unittest.cc.

                                     {
  constexpr int int_max = std::numeric_limits<int>::max();
 
  gfx::Insets set_all_test;
  set_all_test.Set(10, 20, int_max, int_max);
  EXPECT_EQ(gfx::Insets(10, 20, int_max - 10, int_max - 20), set_all_test);
}

TEST() [8/21]

TEST	(	InsetsTest	,
		IntegerOverflowSetVariants
	)

Definition at line 213 of file insets_unittest.cc.

                                             {
  constexpr int int_max = std::numeric_limits<int>::max();
 
  gfx::Insets set_test(20);
  set_test.set_top(int_max);
  EXPECT_EQ(int_max, set_test.top());
  EXPECT_EQ(0, set_test.bottom());
 
  set_test.set_left(int_max);
  EXPECT_EQ(int_max, set_test.left());
  EXPECT_EQ(0, set_test.right());
 
  set_test = gfx::Insets(30);
  set_test.set_bottom(int_max);
  EXPECT_EQ(int_max - 30, set_test.bottom());
  EXPECT_EQ(30, set_test.top());
 
  set_test.set_right(int_max);
  EXPECT_EQ(int_max - 30, set_test.right());
  EXPECT_EQ(30, set_test.left());
}

TEST() [9/21]

TEST	(	InsetsTest	,
		IntegerUnderflow
	)

Definition at line 196 of file insets_unittest.cc.

                                   {
  constexpr int int_min = std::numeric_limits<int>::min();
  constexpr int int_max = std::numeric_limits<int>::max();
 
  gfx::Insets width_height_test = gfx::Insets(int_min);
  EXPECT_EQ(int_min, width_height_test.width());
  EXPECT_EQ(int_min, width_height_test.height());
 
  gfx::Insets minus_test(int_min);
  minus_test -= gfx::Insets(int_max);
  EXPECT_EQ(gfx::Insets(int_min), minus_test);
 
  gfx::Insets scale_test = gfx::Insets(int_min);
  scale_test = scale_test.Scale(2.f, 2.f);
  EXPECT_EQ(gfx::Insets(int_min), scale_test);
}

TEST() [10/21]

TEST	(	InsetsTest	,
		IntegerUnderflowOffset
	)

Definition at line 275 of file insets_unittest.cc.

                                         {
  constexpr int int_min = std::numeric_limits<int>::min();
 
  const gfx::Vector2d min_vector(int_min, int_min);
  gfx::Insets insets(-10);
  gfx::Insets offset_test = insets.Offset(min_vector);
  EXPECT_EQ(gfx::Insets(int_min, int_min, -10 - int_min, -10 - int_min),
            offset_test);
}

TEST() [11/21]

TEST	(	InsetsTest	,
		IntegerUnderflowSetVariants
	)

Definition at line 235 of file insets_unittest.cc.

                                              {
  constexpr int int_min = std::numeric_limits<int>::min();
 
  gfx::Insets set_test(-20);
  set_test.set_top(int_min);
  EXPECT_EQ(int_min, set_test.top());
  EXPECT_EQ(0, set_test.bottom());
 
  set_test.set_left(int_min);
  EXPECT_EQ(int_min, set_test.left());
  EXPECT_EQ(0, set_test.right());
 
  set_test = gfx::Insets(-30);
  set_test.set_bottom(int_min);
  EXPECT_EQ(int_min + 30, set_test.bottom());
  EXPECT_EQ(-30, set_test.top());
 
  set_test.set_right(int_min);
  EXPECT_EQ(int_min + 30, set_test.right());
  EXPECT_EQ(-30, set_test.left());
}

TEST() [12/21]

TEST	(	InsetsTest	,
		Offset
	)

Definition at line 144 of file insets_unittest.cc.

                         {
  const gfx::Insets insets(1, 2, 3, 4);
  const gfx::Rect rect(5, 6, 7, 8);
  const gfx::Vector2d vector(9, 10);
 
  // Whether you inset then offset the rect, offset then inset the rect, or
  // offset the insets then apply to the rect, the outcome should be the same.
  gfx::Rect inset_first = rect;
  inset_first.Inset(insets);
  inset_first.Offset(vector);
 
  gfx::Rect offset_first = rect;
  offset_first.Offset(vector);
  offset_first.Inset(insets);
 
  gfx::Rect inset_by_offset = rect;
  inset_by_offset.Inset(insets.Offset(vector));
 
  EXPECT_EQ(inset_first, offset_first);
  EXPECT_EQ(inset_by_offset, inset_first);
}

TEST() [13/21]

TEST	(	InsetsTest	,
		Operators
	)

Definition at line 68 of file insets_unittest.cc.

                            {
  gfx::Insets insets;
  insets.Set(1, 2, 3, 4);
  insets += gfx::Insets(5, 6, 7, 8);
  EXPECT_EQ(6, insets.top());
  EXPECT_EQ(8, insets.left());
  EXPECT_EQ(10, insets.bottom());
  EXPECT_EQ(12, insets.right());
 
  insets -= gfx::Insets(-1, 0, 1, 2);
  EXPECT_EQ(7, insets.top());
  EXPECT_EQ(8, insets.left());
  EXPECT_EQ(9, insets.bottom());
  EXPECT_EQ(10, insets.right());
 
  insets = gfx::Insets(10, 10, 10, 10) + gfx::Insets(5, 5, 0, -20);
  EXPECT_EQ(15, insets.top());
  EXPECT_EQ(15, insets.left());
  EXPECT_EQ(10, insets.bottom());
  EXPECT_EQ(-10, insets.right());
 
  insets = gfx::Insets(10, 10, 10, 10) - gfx::Insets(5, 5, 0, -20);
  EXPECT_EQ(5, insets.top());
  EXPECT_EQ(5, insets.left());
  EXPECT_EQ(10, insets.bottom());
  EXPECT_EQ(30, insets.right());
}

TEST() [14/21]

TEST	(	InsetsTest	,
		Scale
	)

Definition at line 166 of file insets_unittest.cc.

                        {
  gfx::Insets test(10, 5);
  test = test.Scale(2.f, 3.f);
  EXPECT_EQ(gfx::Insets(30, 10), test);
 
  test = gfx::Insets(7, 3);
  test = test.Scale(-2.f, -3.f);
  EXPECT_EQ(gfx::Insets(-21, -6), test);
}

TEST() [15/21]

TEST	(	InsetsTest	,
		Set
	)

Definition at line 59 of file insets_unittest.cc.

                      {
  gfx::Insets insets;
  insets.Set(1, 2, 3, 4);
  EXPECT_EQ(1, insets.top());
  EXPECT_EQ(2, insets.left());
  EXPECT_EQ(3, insets.bottom());
  EXPECT_EQ(4, insets.right());
}

TEST() [16/21]

TEST	(	InsetsTest	,
		SetBottom
	)

Definition at line 41 of file insets_unittest.cc.

                            {
  gfx::Insets insets(1);
  insets.set_bottom(2);
  EXPECT_EQ(gfx::Insets(1, 1, 2, 1), insets);
}

TEST() [17/21]

TEST	(	InsetsTest	,
		SetLeft
	)

Definition at line 47 of file insets_unittest.cc.

                          {
  gfx::Insets insets(1);
  insets.set_left(2);
  EXPECT_EQ(gfx::Insets(1, 2, 1, 1), insets);
}

TEST() [18/21]

TEST	(	InsetsTest	,
		SetRight
	)

Definition at line 53 of file insets_unittest.cc.

                           {
  gfx::Insets insets(1);
  insets.set_right(2);
  EXPECT_EQ(gfx::Insets(1, 1, 1, 2), insets);
}

TEST() [19/21]

TEST	(	InsetsTest	,
		SetTop
	)

Definition at line 35 of file insets_unittest.cc.

                         {
  gfx::Insets insets(1);
  insets.set_top(2);
  EXPECT_EQ(gfx::Insets(2, 1, 1, 1), insets);
}

TEST() [20/21]

TEST	(	InsetsTest	,
		Size
	)

Definition at line 285 of file insets_unittest.cc.

                       {
  gfx::Insets insets(1, 2, 3, 4);
  EXPECT_EQ(gfx::Size(6, 4), insets.size());
}

TEST() [21/21]

TEST	(	InsetsTest	,
		ToString
	)

Definition at line 139 of file insets_unittest.cc.

                           {
  gfx::Insets insets(1, 2, 3, 4);
  EXPECT_EQ("1,2,3,4", insets.ToString());
}