net/disk_cache/block_files_unittest.cc

   1 // Copyright (c) 2012 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 "base/file_util.h"
   6 #include "base/files/file_enumerator.h"
   7 #include "net/disk_cache/block_files.h"
   8 #include "net/disk_cache/disk_cache.h"
   9 #include "net/disk_cache/disk_cache_test_base.h"
  10 #include "net/disk_cache/disk_cache_test_util.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 using base::Time;
  14
  15 namespace {
  16
  17 // Returns the number of files in this folder.
  18 int NumberOfFiles(const base::FilePath& path) {
  19   base::FileEnumerator iter(path, false, base::FileEnumerator::FILES);
  20   int count = 0;
  21   for (base::FilePath file = iter.Next(); !file.value().empty();
  22        file = iter.Next()) {
  23     count++;
  24   }
  25   return count;
  26 }
  27
  28 }  // namespace;
  29
  30 namespace disk_cache {
  31
  32 TEST_F(DiskCacheTest, BlockFiles_Grow) {
  33   ASSERT_TRUE(CleanupCacheDir());
  34   ASSERT_TRUE(file_util::CreateDirectory(cache_path_));
  35
  36   BlockFiles files(cache_path_);
  37   ASSERT_TRUE(files.Init(true));
  38
  39   const int kMaxSize = 35000;
  40   Addr address[kMaxSize];
  41
  42   // Fill up the 32-byte block file (use three files).
  43   for (int i = 0; i < kMaxSize; i++) {
  44     EXPECT_TRUE(files.CreateBlock(RANKINGS, 4, &address[i]));
  45   }
  46   EXPECT_EQ(6, NumberOfFiles(cache_path_));
  47
  48   // Make sure we don't keep adding files.
  49   for (int i = 0; i < kMaxSize * 4; i += 2) {
  50     int target = i % kMaxSize;
  51     files.DeleteBlock(address[target], false);
  52     EXPECT_TRUE(files.CreateBlock(RANKINGS, 4, &address[target]));
  53   }
  54   EXPECT_EQ(6, NumberOfFiles(cache_path_));
  55 }
  56
  57 // We should be able to delete empty block files.
  58 TEST_F(DiskCacheTest, BlockFiles_Shrink) {
  59   ASSERT_TRUE(CleanupCacheDir());
  60   ASSERT_TRUE(file_util::CreateDirectory(cache_path_));
  61
  62   BlockFiles files(cache_path_);
  63   ASSERT_TRUE(files.Init(true));
  64
  65   const int kMaxSize = 35000;
  66   Addr address[kMaxSize];
  67
  68   // Fill up the 32-byte block file (use three files).
  69   for (int i = 0; i < kMaxSize; i++) {
  70     EXPECT_TRUE(files.CreateBlock(RANKINGS, 4, &address[i]));
  71   }
  72
  73   // Now delete all the blocks, so that we can delete the two extra files.
  74   for (int i = 0; i < kMaxSize; i++) {
  75     files.DeleteBlock(address[i], false);
  76   }
  77   EXPECT_EQ(4, NumberOfFiles(cache_path_));
  78 }
  79
  80 // Handling of block files not properly closed.
  81 TEST_F(DiskCacheTest, BlockFiles_Recover) {
  82   ASSERT_TRUE(CleanupCacheDir());
  83   ASSERT_TRUE(file_util::CreateDirectory(cache_path_));
  84
  85   BlockFiles files(cache_path_);
  86   ASSERT_TRUE(files.Init(true));
  87
  88   const int kNumEntries = 2000;
  89   CacheAddr entries[kNumEntries];
  90
  91   int seed = static_cast<int>(Time::Now().ToInternalValue());
  92   srand(seed);
  93   for (int i = 0; i < kNumEntries; i++) {
  94     Addr address(0);
  95     int size = (rand() % 4) + 1;
  96     EXPECT_TRUE(files.CreateBlock(RANKINGS, size, &address));
  97     entries[i] = address.value();
  98   }
  99
 100   for (int i = 0; i < kNumEntries; i++) {
 101     int source1 = rand() % kNumEntries;
 102     int source2 = rand() % kNumEntries;
 103     CacheAddr temp = entries[source1];
 104     entries[source1] = entries[source2];
 105     entries[source2] = temp;
 106   }
 107
 108   for (int i = 0; i < kNumEntries / 2; i++) {
 109     Addr address(entries[i]);
 110     files.DeleteBlock(address, false);
 111   }
 112
 113   // At this point, there are kNumEntries / 2 entries on the file, randomly
 114   // distributed both on location and size.
 115
 116   Addr address(entries[kNumEntries / 2]);
 117   MappedFile* file = files.GetFile(address);
 118   ASSERT_TRUE(NULL != file);
 119
 120   BlockFileHeader* header =
 121       reinterpret_cast<BlockFileHeader*>(file->buffer());
 122   ASSERT_TRUE(NULL != header);
 123
 124   ASSERT_EQ(0, header->updating);
 125
 126   int max_entries = header->max_entries;
 127   int empty_1 = header->empty[0];
 128   int empty_2 = header->empty[1];
 129   int empty_3 = header->empty[2];
 130   int empty_4 = header->empty[3];
 131
 132   // Corrupt the file.
 133   header->max_entries = header->empty[0] = 0;
 134   header->empty[1] = header->empty[2] = header->empty[3] = 0;
 135   header->updating = -1;
 136
 137   files.CloseFiles();
 138
 139   ASSERT_TRUE(files.Init(false));
 140
 141   // The file must have been fixed.
 142   file = files.GetFile(address);
 143   ASSERT_TRUE(NULL != file);
 144
 145   header = reinterpret_cast<BlockFileHeader*>(file->buffer());
 146   ASSERT_TRUE(NULL != header);
 147
 148   ASSERT_EQ(0, header->updating);
 149
 150   EXPECT_EQ(max_entries, header->max_entries);
 151   EXPECT_EQ(empty_1, header->empty[0]);
 152   EXPECT_EQ(empty_2, header->empty[1]);
 153   EXPECT_EQ(empty_3, header->empty[2]);
 154   EXPECT_EQ(empty_4, header->empty[3]);
 155 }
 156
 157 // Handling of truncated files.
 158 TEST_F(DiskCacheTest, BlockFiles_ZeroSizeFile) {
 159   ASSERT_TRUE(CleanupCacheDir());
 160   ASSERT_TRUE(file_util::CreateDirectory(cache_path_));
 161
 162   BlockFiles files(cache_path_);
 163   ASSERT_TRUE(files.Init(true));
 164
 165   base::FilePath filename = files.Name(0);
 166   files.CloseFiles();
 167   // Truncate one of the files.
 168   {
 169     scoped_refptr<File> file(new File);
 170     ASSERT_TRUE(file->Init(filename));
 171     EXPECT_TRUE(file->SetLength(0));
 172   }
 173
 174   // Initializing should fail, not crash.
 175   ASSERT_FALSE(files.Init(false));
 176 }
 177
 178 // Handling of truncated files (non empty).
 179 TEST_F(DiskCacheTest, BlockFiles_TruncatedFile) {
 180   ASSERT_TRUE(CleanupCacheDir());
 181   ASSERT_TRUE(file_util::CreateDirectory(cache_path_));
 182
 183   BlockFiles files(cache_path_);
 184   ASSERT_TRUE(files.Init(true));
 185   Addr address;
 186   EXPECT_TRUE(files.CreateBlock(RANKINGS, 2, &address));
 187
 188   base::FilePath filename = files.Name(0);
 189   files.CloseFiles();
 190   // Truncate one of the files.
 191   {
 192     scoped_refptr<File> file(new File);
 193     ASSERT_TRUE(file->Init(filename));
 194     EXPECT_TRUE(file->SetLength(15000));
 195   }
 196
 197   // Initializing should fail, not crash.
 198   ASSERT_FALSE(files.Init(false));
 199 }
 200
 201 // Tests detection of out of sync counters.
 202 TEST_F(DiskCacheTest, BlockFiles_Counters) {
 203   ASSERT_TRUE(CleanupCacheDir());
 204   ASSERT_TRUE(file_util::CreateDirectory(cache_path_));
 205
 206   BlockFiles files(cache_path_);
 207   ASSERT_TRUE(files.Init(true));
 208
 209   // Create a block of size 2.
 210   Addr address(0);
 211   EXPECT_TRUE(files.CreateBlock(RANKINGS, 2, &address));
 212
 213   MappedFile* file = files.GetFile(address);
 214   ASSERT_TRUE(NULL != file);
 215
 216   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
 217   ASSERT_TRUE(NULL != header);
 218   ASSERT_EQ(0, header->updating);
 219
 220   // Alter the counters so that the free space doesn't add up.
 221   header->empty[2] = 50;  // 50 free blocks of size 3.
 222   files.CloseFiles();
 223
 224   ASSERT_TRUE(files.Init(false));
 225   file = files.GetFile(address);
 226   ASSERT_TRUE(NULL != file);
 227   header = reinterpret_cast<BlockFileHeader*>(file->buffer());
 228   ASSERT_TRUE(NULL != header);
 229
 230   // The file must have been fixed.
 231   ASSERT_EQ(0, header->empty[2]);
 232
 233   // Change the number of entries.
 234   header->num_entries = 3;
 235   header->updating = 1;
 236   files.CloseFiles();
 237
 238   ASSERT_TRUE(files.Init(false));
 239   file = files.GetFile(address);
 240   ASSERT_TRUE(NULL != file);
 241   header = reinterpret_cast<BlockFileHeader*>(file->buffer());
 242   ASSERT_TRUE(NULL != header);
 243
 244   // The file must have been "fixed".
 245   ASSERT_EQ(2, header->num_entries);
 246
 247   // Change the number of entries.
 248   header->num_entries = -1;
 249   header->updating = 1;
 250   files.CloseFiles();
 251
 252   // Detect the error.
 253   ASSERT_FALSE(files.Init(false));
 254 }
 255
 256 // An invalid file can be detected after init.
 257 TEST_F(DiskCacheTest, BlockFiles_InvalidFile) {
 258   ASSERT_TRUE(CleanupCacheDir());
 259   ASSERT_TRUE(file_util::CreateDirectory(cache_path_));
 260
 261   BlockFiles files(cache_path_);
 262   ASSERT_TRUE(files.Init(true));
 263
 264   // Let's access block 10 of file 5. (There is no file).
 265   Addr addr(BLOCK_256, 1, 5, 10);
 266   EXPECT_TRUE(NULL == files.GetFile(addr));
 267
 268   // Let's create an invalid file.
 269   base::FilePath filename(files.Name(5));
 270   char header[kBlockHeaderSize];
 271   memset(header, 'a', kBlockHeaderSize);
 272   EXPECT_EQ(kBlockHeaderSize,
 273             file_util::WriteFile(filename, header, kBlockHeaderSize));
 274
 275   EXPECT_TRUE(NULL == files.GetFile(addr));
 276
 277   // The file should not have been changed (it is still invalid).
 278   EXPECT_TRUE(NULL == files.GetFile(addr));
 279 }
 280
 281 // Tests that we generate the correct file stats.
 282 TEST_F(DiskCacheTest, BlockFiles_Stats) {
 283   ASSERT_TRUE(CopyTestCache("remove_load1"));
 284
 285   BlockFiles files(cache_path_);
 286   ASSERT_TRUE(files.Init(false));
 287   int used, load;
 288
 289   files.GetFileStats(0, &used, &load);
 290   EXPECT_EQ(101, used);
 291   EXPECT_EQ(9, load);
 292
 293   files.GetFileStats(1, &used, &load);
 294   EXPECT_EQ(203, used);
 295   EXPECT_EQ(19, load);
 296
 297   files.GetFileStats(2, &used, &load);
 298   EXPECT_EQ(0, used);
 299   EXPECT_EQ(0, load);
 300 }
 301
 302 // Tests that we add and remove blocks correctly.
 303 TEST_F(DiskCacheTest, AllocationMap) {
 304   ASSERT_TRUE(CleanupCacheDir());
 305   ASSERT_TRUE(file_util::CreateDirectory(cache_path_));
 306
 307   BlockFiles files(cache_path_);
 308   ASSERT_TRUE(files.Init(true));
 309
 310   // Create a bunch of entries.
 311   const int kSize = 100;
 312   Addr address[kSize];
 313   for (int i = 0; i < kSize; i++) {
 314     SCOPED_TRACE(i);
 315     int block_size = i % 4 + 1;
 316     EXPECT_TRUE(files.CreateBlock(BLOCK_1K, block_size, &address[i]));
 317     EXPECT_EQ(BLOCK_1K, address[i].file_type());
 318     EXPECT_EQ(block_size, address[i].num_blocks());
 319     int start = address[i].start_block();
 320     EXPECT_EQ(start / 4, (start + block_size - 1) / 4);
 321   }
 322
 323   for (int i = 0; i < kSize; i++) {
 324     SCOPED_TRACE(i);
 325     EXPECT_TRUE(files.IsValid(address[i]));
 326   }
 327
 328   // The first part of the allocation map should be completely filled. We used
 329   // 10 bits per each four entries, so 250 bits total.
 330   BlockFileHeader* header =
 331       reinterpret_cast<BlockFileHeader*>(files.GetFile(address[0])->buffer());
 332   uint8* buffer = reinterpret_cast<uint8*>(&header->allocation_map);
 333   for (int i =0; i < 29; i++) {
 334     SCOPED_TRACE(i);
 335     EXPECT_EQ(0xff, buffer[i]);
 336   }
 337
 338   for (int i = 0; i < kSize; i++) {
 339     SCOPED_TRACE(i);
 340     files.DeleteBlock(address[i], false);
 341   }
 342
 343   // The allocation map should be empty.
 344   for (int i =0; i < 50; i++) {
 345     SCOPED_TRACE(i);
 346     EXPECT_EQ(0, buffer[i]);
 347   }
 348 }
 349
 350 }  // namespace disk_cache