252 lines
7.6 KiB
C++
252 lines
7.6 KiB
C++
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
#include "ui/gfx/geometry/size.h"
|
|
#include "ui/gfx/geometry/size_conversions.h"
|
|
#include "ui/gfx/geometry/size_f.h"
|
|
|
|
namespace gfx {
|
|
|
|
namespace {
|
|
|
|
int TestSizeF(const SizeF& s) {
|
|
return s.width();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
TEST(SizeTest, ToSizeF) {
|
|
// Check that explicit conversion from integer to float compiles.
|
|
Size a(10, 20);
|
|
float width = TestSizeF(gfx::SizeF(a));
|
|
EXPECT_EQ(width, a.width());
|
|
|
|
SizeF b(10, 20);
|
|
|
|
EXPECT_EQ(b, gfx::SizeF(a));
|
|
}
|
|
|
|
TEST(SizeTest, ToFlooredSize) {
|
|
EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0, 0)));
|
|
EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.0001f, 0.0001f)));
|
|
EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.4999f, 0.4999f)));
|
|
EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.5f, 0.5f)));
|
|
EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.9999f, 0.9999f)));
|
|
|
|
EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10, 10)));
|
|
EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.0001f, 10.0001f)));
|
|
EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.4999f, 10.4999f)));
|
|
EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.5f, 10.5f)));
|
|
EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.9999f, 10.9999f)));
|
|
}
|
|
|
|
TEST(SizeTest, ToCeiledSize) {
|
|
EXPECT_EQ(Size(0, 0), ToCeiledSize(SizeF(0, 0)));
|
|
EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.0001f, 0.0001f)));
|
|
EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.4999f, 0.4999f)));
|
|
EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.5f, 0.5f)));
|
|
EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.9999f, 0.9999f)));
|
|
|
|
EXPECT_EQ(Size(10, 10), ToCeiledSize(SizeF(10, 10)));
|
|
EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.0001f, 10.0001f)));
|
|
EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.4999f, 10.4999f)));
|
|
EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.5f, 10.5f)));
|
|
EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.9999f, 10.9999f)));
|
|
}
|
|
|
|
TEST(SizeTest, ToRoundedSize) {
|
|
EXPECT_EQ(Size(0, 0), ToRoundedSize(SizeF(0, 0)));
|
|
EXPECT_EQ(Size(0, 0), ToRoundedSize(SizeF(0.0001f, 0.0001f)));
|
|
EXPECT_EQ(Size(0, 0), ToRoundedSize(SizeF(0.4999f, 0.4999f)));
|
|
EXPECT_EQ(Size(1, 1), ToRoundedSize(SizeF(0.5f, 0.5f)));
|
|
EXPECT_EQ(Size(1, 1), ToRoundedSize(SizeF(0.9999f, 0.9999f)));
|
|
|
|
EXPECT_EQ(Size(10, 10), ToRoundedSize(SizeF(10, 10)));
|
|
EXPECT_EQ(Size(10, 10), ToRoundedSize(SizeF(10.0001f, 10.0001f)));
|
|
EXPECT_EQ(Size(10, 10), ToRoundedSize(SizeF(10.4999f, 10.4999f)));
|
|
EXPECT_EQ(Size(11, 11), ToRoundedSize(SizeF(10.5f, 10.5f)));
|
|
EXPECT_EQ(Size(11, 11), ToRoundedSize(SizeF(10.9999f, 10.9999f)));
|
|
}
|
|
|
|
TEST(SizeTest, ClampSize) {
|
|
Size a;
|
|
|
|
a = Size(3, 5);
|
|
EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
|
|
a.SetToMax(Size(2, 4));
|
|
EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
|
|
a.SetToMax(Size(3, 5));
|
|
EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
|
|
a.SetToMax(Size(4, 2));
|
|
EXPECT_EQ(Size(4, 5).ToString(), a.ToString());
|
|
a.SetToMax(Size(8, 10));
|
|
EXPECT_EQ(Size(8, 10).ToString(), a.ToString());
|
|
|
|
a.SetToMin(Size(9, 11));
|
|
EXPECT_EQ(Size(8, 10).ToString(), a.ToString());
|
|
a.SetToMin(Size(8, 10));
|
|
EXPECT_EQ(Size(8, 10).ToString(), a.ToString());
|
|
a.SetToMin(Size(11, 9));
|
|
EXPECT_EQ(Size(8, 9).ToString(), a.ToString());
|
|
a.SetToMin(Size(7, 11));
|
|
EXPECT_EQ(Size(7, 9).ToString(), a.ToString());
|
|
a.SetToMin(Size(3, 5));
|
|
EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
|
|
}
|
|
|
|
TEST(SizeTest, ClampSizeF) {
|
|
SizeF a;
|
|
|
|
a = SizeF(3.5f, 5.5f);
|
|
EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
|
|
a.SetToMax(SizeF(2.5f, 4.5f));
|
|
EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
|
|
a.SetToMax(SizeF(3.5f, 5.5f));
|
|
EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
|
|
a.SetToMax(SizeF(4.5f, 2.5f));
|
|
EXPECT_EQ(SizeF(4.5f, 5.5f).ToString(), a.ToString());
|
|
a.SetToMax(SizeF(8.5f, 10.5f));
|
|
EXPECT_EQ(SizeF(8.5f, 10.5f).ToString(), a.ToString());
|
|
|
|
a.SetToMin(SizeF(9.5f, 11.5f));
|
|
EXPECT_EQ(SizeF(8.5f, 10.5f).ToString(), a.ToString());
|
|
a.SetToMin(SizeF(8.5f, 10.5f));
|
|
EXPECT_EQ(SizeF(8.5f, 10.5f).ToString(), a.ToString());
|
|
a.SetToMin(SizeF(11.5f, 9.5f));
|
|
EXPECT_EQ(SizeF(8.5f, 9.5f).ToString(), a.ToString());
|
|
a.SetToMin(SizeF(7.5f, 11.5f));
|
|
EXPECT_EQ(SizeF(7.5f, 9.5f).ToString(), a.ToString());
|
|
a.SetToMin(SizeF(3.5f, 5.5f));
|
|
EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
|
|
}
|
|
|
|
TEST(SizeTest, Enlarge) {
|
|
Size test(3, 4);
|
|
test.Enlarge(5, -8);
|
|
EXPECT_EQ(test, Size(8, -4));
|
|
}
|
|
|
|
TEST(SizeTest, IntegerOverflow) {
|
|
int int_max = std::numeric_limits<int>::max();
|
|
int int_min = std::numeric_limits<int>::min();
|
|
|
|
Size max_size(int_max, int_max);
|
|
Size min_size(int_min, int_min);
|
|
Size test;
|
|
|
|
test = Size();
|
|
test.Enlarge(int_max, int_max);
|
|
EXPECT_EQ(test, max_size);
|
|
|
|
test = Size();
|
|
test.Enlarge(int_min, int_min);
|
|
EXPECT_EQ(test, min_size);
|
|
|
|
test = Size(10, 20);
|
|
test.Enlarge(int_max, int_max);
|
|
EXPECT_EQ(test, max_size);
|
|
|
|
test = Size(-10, -20);
|
|
test.Enlarge(int_min, int_min);
|
|
EXPECT_EQ(test, min_size);
|
|
}
|
|
|
|
// This checks that we set IsEmpty appropriately.
|
|
TEST(SizeTest, TrivialDimensionTests) {
|
|
const float clearly_trivial = SizeF::kTrivial / 2.f;
|
|
const float massize_dimension = 4e13f;
|
|
|
|
// First, using the constructor.
|
|
EXPECT_TRUE(SizeF(clearly_trivial, 1.f).IsEmpty());
|
|
EXPECT_TRUE(SizeF(.01f, clearly_trivial).IsEmpty());
|
|
EXPECT_TRUE(SizeF(0.f, 0.f).IsEmpty());
|
|
EXPECT_FALSE(SizeF(.01f, .01f).IsEmpty());
|
|
|
|
// Then use the setter.
|
|
SizeF test(2.f, 1.f);
|
|
EXPECT_FALSE(test.IsEmpty());
|
|
|
|
test.SetSize(clearly_trivial, 1.f);
|
|
EXPECT_TRUE(test.IsEmpty());
|
|
|
|
test.SetSize(.01f, clearly_trivial);
|
|
EXPECT_TRUE(test.IsEmpty());
|
|
|
|
test.SetSize(0.f, 0.f);
|
|
EXPECT_TRUE(test.IsEmpty());
|
|
|
|
test.SetSize(.01f, .01f);
|
|
EXPECT_FALSE(test.IsEmpty());
|
|
|
|
// Now just one dimension at a time.
|
|
test.set_width(clearly_trivial);
|
|
EXPECT_TRUE(test.IsEmpty());
|
|
|
|
test.set_width(massize_dimension);
|
|
test.set_height(clearly_trivial);
|
|
EXPECT_TRUE(test.IsEmpty());
|
|
|
|
test.set_width(clearly_trivial);
|
|
test.set_height(massize_dimension);
|
|
EXPECT_TRUE(test.IsEmpty());
|
|
|
|
test.set_width(2.f);
|
|
EXPECT_FALSE(test.IsEmpty());
|
|
}
|
|
|
|
// These are the ramifications of the decision to keep the recorded size
|
|
// at zero for trivial sizes.
|
|
TEST(SizeTest, ClampsToZero) {
|
|
const float clearly_trivial = SizeF::kTrivial / 2.f;
|
|
const float nearly_trivial = SizeF::kTrivial * 1.5f;
|
|
|
|
SizeF test(clearly_trivial, 1.f);
|
|
|
|
EXPECT_FLOAT_EQ(0.f, test.width());
|
|
EXPECT_FLOAT_EQ(1.f, test.height());
|
|
|
|
test.SetSize(.01f, clearly_trivial);
|
|
|
|
EXPECT_FLOAT_EQ(.01f, test.width());
|
|
EXPECT_FLOAT_EQ(0.f, test.height());
|
|
|
|
test.SetSize(nearly_trivial, nearly_trivial);
|
|
|
|
EXPECT_FLOAT_EQ(nearly_trivial, test.width());
|
|
EXPECT_FLOAT_EQ(nearly_trivial, test.height());
|
|
|
|
test.Scale(0.5f);
|
|
|
|
EXPECT_FLOAT_EQ(0.f, test.width());
|
|
EXPECT_FLOAT_EQ(0.f, test.height());
|
|
|
|
test.SetSize(0.f, 0.f);
|
|
test.Enlarge(clearly_trivial, clearly_trivial);
|
|
test.Enlarge(clearly_trivial, clearly_trivial);
|
|
test.Enlarge(clearly_trivial, clearly_trivial);
|
|
|
|
EXPECT_EQ(SizeF(0.f, 0.f), test);
|
|
}
|
|
|
|
// These make sure the constructor and setter have the same effect on the
|
|
// boundary case. This claims to know the boundary, but not which way it goes.
|
|
TEST(SizeTest, ConsistentClamping) {
|
|
SizeF resized;
|
|
|
|
resized.SetSize(SizeF::kTrivial, 0.f);
|
|
EXPECT_EQ(SizeF(SizeF::kTrivial, 0.f), resized);
|
|
|
|
resized.SetSize(0.f, SizeF::kTrivial);
|
|
EXPECT_EQ(SizeF(0.f, SizeF::kTrivial), resized);
|
|
}
|
|
|
|
// Let's make sure we don't unexpectedly grow the struct by adding constants.
|
|
// Also, if some platform packs floats inefficiently, it would be worth noting.
|
|
TEST(SizeTest, StaysSmall) {
|
|
EXPECT_EQ(2 * sizeof(float), sizeof(SizeF));
|
|
}
|
|
|
|
} // namespace gfx
|