Added new class gfx::ImageFamily.

ui/gfx/image/image_family_unittest.cc

Index: ui/gfx/image/image_family_unittest.cc
diff --git a/ui/gfx/image/image_family_unittest.cc b/ui/gfx/image/image_family_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7a5ab249bf9126cf8f27ece3f930e4227f2bb4b4
--- /dev/null
+++ b/ui/gfx/image/image_family_unittest.cc
@@ -0,0 +1,177 @@
+// Copyright 2013 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/image/image.h"
+#include "ui/gfx/image/image_family.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_unittest_util.h"
+
+namespace {
+
+namespace gt = gfx::test;
+
+// Tests that |image| != NULL, and has the given width and height.
+// This is a macro instead of a function, so that the correct line numbers are
+// reported when a test fails.

[pkotwicz, 2013/03/29 00:25:35]

Can you use a function instead of a macro?

[Matt Giuca, 2013/03/30 00:54:14]

The reason I used a macro is so that when the expectations fail, it reports the
line number of the test that failed instead of simply line 22 or 23. I had it as
a function before, and it was completely useless for identifying which test had
failed.

[Robert Sesek, 2013/04/01 20:57:45]

When I've done this in the past, I just pass __LINE__ to a function.

[Matt Giuca, 2013/04/02 06:11:28]

Can you show me an example? I don't understand what I'd do with __LINE__ once I
had it (the EXPECT is still going to report Line 22). And this would also
require that every call to this function include __LINE__ which would be
annoying.

tapted also suggested using SCOPED_TRACE, but that would require four lines of
code for each call to this function.

Is there a really good reason not to use a macro here? It seems to solve this
problem perfectly, and it's fairly small and contained to this module.

[Robert Sesek, 2013/04/02 20:37:29]

You'd do it like:

ImageFamilyTest::CheckNonNullAndSize(gfx::Image*, int width, int height, int
line) {
  const char kTestLine[] = "From test at line ";
  EXPECT_TRUE(image) << kTestLine << line;
  EXPECT_EQ(width, image->Width()) << kTestLine << line;
  EXPECT_EQ(height, image->Height()) << kTestLine << line;
}

TEST_F() {
   CheckNonNullAndSize(image, width, height, __LINE__); 
}

But I guess this is fine.

+#define EXPECT_IMAGE_NON_NULL_AND_SIZE(image, expected_width, expected_height) \
+do { \
+  const gfx::Image* image_ = image; \
+  EXPECT_TRUE(image_); \
+  EXPECT_EQ(expected_width, image_->Width()); \
+  EXPECT_EQ(expected_height, image_->Height()); \
+} while(0)
+
+class ImageFamilyTest : public testing::Test {
+ public:
+  // Construct an ImageFamily. Implicitly tests Add and Empty.
+  virtual void SetUp() OVERRIDE {
+    EXPECT_TRUE(image_family_.empty());
+
+    // Aspect ratio 1:1.
+    image_family_.Add(gt::CreateImageSkia(32, 32));
+    EXPECT_FALSE(image_family_.empty());
+    image_family_.Add(gt::CreateImageSkia(16, 16));
+    image_family_.Add(gt::CreateImageSkia(64, 64));
+    // Duplicate (should override previous one).
+    // Insert an Image directly, instead of an ImageSkia.
+    gfx::Image image(gt::CreateImageSkia(32, 32));
+    image_family_.Add(image);
+    // Aspect ratio 1:4.
+    image_family_.Add(gt::CreateImageSkia(3, 12));
+    image_family_.Add(gt::CreateImageSkia(12, 48));
+    // Aspect ratio 4:1.
+    image_family_.Add(gt::CreateImageSkia(512, 128));
+    image_family_.Add(gt::CreateImageSkia(256, 64));
+
+    EXPECT_FALSE(image_family_.empty());
+  }
+
+  gfx::ImageFamily image_family_;
+};
+
+TEST_F(ImageFamilyTest, Clear) {
+  image_family_.clear();
+  EXPECT_TRUE(image_family_.empty());
+}
+
+// Tests iteration over an ImageFamily.
+TEST_F(ImageFamilyTest, Iteration) {
+  gfx::ImageFamily::const_iterator it = image_family_.begin();
+  gfx::ImageFamily::const_iterator end = image_family_.end();
+
+  // Expect iteration in order of aspect ratio (from thinnest to widest), then
+  // size.
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(3, 12), it->Size());
+  ++it;
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(12, 48), it->Size());
+  it++;   // Test post-increment.
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(16, 16), it->Size());
+  ++it;
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(32, 32), it->Size());
+  --it;   // Test decrement
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(16, 16), it->Size());
+  ++it;
+  ++it;
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(64, 64), (*it).Size());   // Test operator*.
+  ++it;
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(256, 64), it->Size());
+  ++it;
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(512, 128), it->Size());
+  ++it;
+
+  EXPECT_TRUE(it == end);
+}
+
+TEST_F(ImageFamilyTest, Get) {
+  // Get on an empty family.
+  gfx::ImageFamily empty_family;
+  EXPECT_TRUE(empty_family.empty());
+  EXPECT_FALSE(empty_family.Get(32, 32));
+  EXPECT_FALSE(empty_family.Get(0, 32));
+  EXPECT_FALSE(empty_family.Get(32, 0));
+
+  // Get various aspect ratios and sizes on the sample family.
+
+  // 0x0 (expect the smallest square image).
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(0, 0), 16, 16);
+  // Get(0, N) or Get(N, 0) should be treated the same as Get(0, 0).
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(0, 16), 16, 16);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(0, 64), 16, 16);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(16, 0), 16, 16);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(64, 0), 16, 16);
+
+  // Thinner than thinnest image.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(2, 12), 3, 12);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(2, 13), 12, 48);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(10, 60), 12, 48);
+
+  // Between two images' aspect ratio.
+  // Note: Testing the boundary around 1:2 and 2:1, half way to 1:4 and 4:1.
+  // Ties are broken by favouring the thinner aspect ratio.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(63, 32), 64, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(64, 32), 64, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(65, 32), 256, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(32, 63), 64, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(32, 64), 12, 48);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(32, 65), 12, 48);
+
+  // Exact match aspect ratio.
+  // Exact match size.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(32, 32), 32, 32);
+  // Slightly smaller.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(31, 31), 32, 32);
+  // Much smaller.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(17, 17), 32, 32);
+  // Exact match size.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(16, 16), 16, 16);
+  // Smaller than any image.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(3, 3), 16, 16);
+  // Larger than any image.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(512, 512), 64, 64);
+  // 1:4 aspect ratio.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(16, 64), 12, 48);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(2, 8), 3, 12);
+  // 4:1 aspect ratio.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(64, 16), 256, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(260, 65), 512, 128);
+
+  // Wider than widest image.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(255, 51), 256, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(260, 52), 512, 128);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(654, 129), 512, 128);
+}
+
+// Test adding and looking up images with 0 width and height.
+TEST_F(ImageFamilyTest, ZeroWidthAndHeight) {
+  // An empty Image. Should be considered to have 0 width and height.
+  image_family_.Add(gfx::Image());
+  // Images with 0 width OR height should be treated the same as an image with 0
+  // width AND height (in fact, the ImageSkias should be indistinguishable).
+  image_family_.Add(gt::CreateImageSkia(32, 0));
+  image_family_.Add(gt::CreateImageSkia(0, 32));
+
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(0, 0), 0, 0);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(1, 1), 16, 16);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(32, 32), 32, 32);
+
+  // Get(0, N) or Get(N, 0) should be treated the same as Get(0, 0).
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(0, 1), 0, 0);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(0, 32), 0, 0);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(1, 0), 0, 0);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(32, 0), 0, 0);
+
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(1, 32), 12, 48);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.Get(32, 1), 256, 64);
+}
+
+}  // namespace