src/components/enhanced_bookmarks/image_store_ios_unittest.mm

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/enhanced_bookmarks/image_store.h"
   6
   7 #import <UIKit/UIKit.h>
   8
   9 #include "base/files/scoped_temp_dir.h"
  10 #include "base/mac/scoped_cftyperef.h"
  11 #include "components/enhanced_bookmarks/image_store_util.h"
  12 #include "components/enhanced_bookmarks/persistent_image_store.h"
  13 #include "components/enhanced_bookmarks/test_image_store.h"
  14 #include "testing/platform_test.h"
  15 #include "ui/gfx/geometry/size.h"
  16 #include "ui/gfx/image/image.h"
  17 #include "url/gurl.h"
  18
  19 namespace {
  20
  21 // Generates a gfx::Image with a random UIImage representation. Uses off-center
  22 // circle gradient to make all pixels slightly different in order to detect
  23 // small image alterations.
  24 gfx::Image GenerateRandomUIImage(gfx::Size& size, float scale) {
  25   UIGraphicsBeginImageContextWithOptions(CGSizeMake(size.width(),
  26                                                     size.height()),
  27                                          YES,  // opaque.
  28                                          scale);
  29   // Create the gradient's colors.
  30   CGFloat locations[] = { 0.0, 1.0 };
  31   CGFloat components[] = { rand()/CGFloat(RAND_MAX),  // Start color r
  32                            rand()/CGFloat(RAND_MAX),  // g
  33                            rand()/CGFloat(RAND_MAX),  // b
  34                            1.0,                       // Alpha
  35                            rand()/CGFloat(RAND_MAX),  // End color r
  36                            rand()/CGFloat(RAND_MAX),  // g
  37                            rand()/CGFloat(RAND_MAX),  // b
  38                            1.0 };                     // Alpha
  39   CGPoint center = CGPointMake(size.width() / 3, size.height() / 3);
  40   CGFloat radius = MAX(size.width(), size.height());
  41
  42   base::ScopedCFTypeRef<CGColorSpaceRef>
  43       colorspace(CGColorSpaceCreateDeviceRGB());
  44   base::ScopedCFTypeRef<CGGradientRef>
  45       gradient(CGGradientCreateWithColorComponents(colorspace,
  46                                                    components,
  47                                                    locations,
  48                                                    arraysize(locations)));
  49   CGContextDrawRadialGradient(UIGraphicsGetCurrentContext(),
  50                               gradient,
  51                               center,
  52                               0,
  53                               center,
  54                               radius,
  55                               kCGGradientDrawsAfterEndLocation);
  56   UIImage* image = UIGraphicsGetImageFromCurrentImageContext();
  57   UIGraphicsEndImageContext();
  58   return gfx::Image([image retain]);
  59 }
  60
  61 // Returns true if the two images are identical.
  62 bool CompareImages(const gfx::Image& image_1, const gfx::Image& image_2) {
  63   if (image_1.IsEmpty() && image_2.IsEmpty())
  64     return true;
  65   if (image_1.IsEmpty() || image_2.IsEmpty())
  66     return false;
  67
  68   scoped_refptr<base::RefCountedMemory> image_1_bytes =
  69       enhanced_bookmarks::BytesForImage(image_1);
  70   scoped_refptr<base::RefCountedMemory> image_2_bytes =
  71       enhanced_bookmarks::BytesForImage(image_2);
  72
  73   if (image_1_bytes->size() != image_2_bytes->size())
  74     return false;
  75
  76   return !memcmp(image_1_bytes->front(),
  77                  image_2_bytes->front(),
  78                  image_1_bytes->size());
  79 }
  80
  81 // Factory functions for creating instances of the implementations.
  82 template <class T>
  83 ImageStore* CreateStore(base::ScopedTempDir& folder);
  84
  85 template <>
  86 ImageStore* CreateStore<TestImageStore>(
  87     base::ScopedTempDir& folder) {
  88   return new TestImageStore();
  89 }
  90
  91 template <>
  92 ImageStore* CreateStore<PersistentImageStore>(
  93     base::ScopedTempDir& folder) {
  94   return new PersistentImageStore(folder.path());
  95 }
  96
  97 // Methods to check if persistence is on or not.
  98 template <class T> bool ShouldPersist();
  99 template <> bool ShouldPersist<TestImageStore>() { return false; }
 100 template <> bool ShouldPersist<PersistentImageStore>() { return true; }
 101
 102 // Test fixture class template for the abstract API.
 103 template <class T>
 104 class ImageStoreUnitTestIOS : public PlatformTest {
 105  protected:
 106   ImageStoreUnitTestIOS() {}
 107   virtual ~ImageStoreUnitTestIOS() {}
 108
 109   virtual void SetUp() override {
 110     bool success = temp_dir_.CreateUniqueTempDir();
 111     ASSERT_TRUE(success);
 112     store_.reset(CreateStore<T>(temp_dir_));
 113   }
 114
 115   virtual void TearDown() override {
 116     if (store_ && use_persistent_store())
 117       store_->ClearAll();
 118   }
 119
 120   bool use_persistent_store() const { return ShouldPersist<T>(); }
 121   void ResetStore() { store_.reset(CreateStore<T>(temp_dir_)); }
 122
 123   // The directory the database is saved into.
 124   base::ScopedTempDir temp_dir_;
 125   // The object the fixture is testing, via its base interface.
 126   scoped_ptr<ImageStore> store_;
 127
 128  private:
 129   DISALLOW_COPY_AND_ASSIGN(ImageStoreUnitTestIOS);
 130 };
 131
 132 // The list of implementations of the abstract API that are going to be tested.
 133 typedef testing::Types<TestImageStore,
 134                        PersistentImageStore> Implementations;
 135
 136 TYPED_TEST_CASE(ImageStoreUnitTestIOS, Implementations);
 137
 138 TYPED_TEST(ImageStoreUnitTestIOS, StoringImagesPreservesScale) {
 139   CGFloat scales[] = { 0.0, 1.0, 2.0 };
 140   gfx::Size image_size(42, 24);
 141   for (unsigned long i = 0; i < arraysize(scales); i++) {
 142     gfx::Image src_image(GenerateRandomUIImage(image_size, scales[i]));
 143     const GURL url("foo://bar");
 144     const GURL image_url("a.jpg");
 145     this->store_->Insert(url, image_url, src_image);
 146     std::pair<gfx::Image, GURL> image_info = this->store_->Get(url);
 147
 148     EXPECT_EQ(image_url, image_info.second);
 149     EXPECT_TRUE(CompareImages(src_image, image_info.first));
 150   }
 151 }
 152
 153 }  // namespace