| OLD | NEW |
| (Empty) |
| 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/memory/scoped_ptr.h" | |
| 6 #include "net/disk_cache/disk_cache_test_util.h" | |
| 7 #include "net/disk_cache/flash/segment.h" | |
| 8 #include "net/disk_cache/flash/storage.h" | |
| 9 #include "net/disk_cache/flash/flash_cache_test_base.h" | |
| 10 #include "net/disk_cache/flash/format.h" | |
| 11 #include "testing/gtest/include/gtest/gtest.h" | |
| 12 | |
| 13 namespace { | |
| 14 | |
| 15 template<int SIZE> | |
| 16 struct Entry { | |
| 17 enum { size = SIZE }; | |
| 18 | |
| 19 Entry() { CacheTestFillBuffer(data, size, false); } | |
| 20 | |
| 21 bool operator==(const Entry& rhs) const { | |
| 22 return std::equal(data, data + size, rhs.data); | |
| 23 } | |
| 24 | |
| 25 char data[size]; | |
| 26 }; | |
| 27 | |
| 28 const int32 kSmallEntrySize = 100; | |
| 29 const int32 kLargeEntrySize = disk_cache::kFlashSegmentSize / 4; | |
| 30 | |
| 31 typedef Entry<kSmallEntrySize> SmallEntry; | |
| 32 typedef Entry<kLargeEntrySize> LargeEntry; | |
| 33 | |
| 34 const int32 kSegmentFreeSpace = disk_cache::kFlashSegmentSize - | |
| 35 disk_cache::kFlashSummarySize; | |
| 36 | |
| 37 } // namespace | |
| 38 | |
| 39 TEST_F(FlashCacheTest, SegmentUserTracking) { | |
| 40 disk_cache::Storage storage(path_, kStorageSize); | |
| 41 ASSERT_TRUE(storage.Init()); | |
| 42 | |
| 43 scoped_ptr<disk_cache::Segment> segment( | |
| 44 new disk_cache::Segment(0, false, &storage)); | |
| 45 EXPECT_TRUE(segment->Init()); | |
| 46 | |
| 47 EXPECT_TRUE(segment->HasNoUsers()); | |
| 48 segment->AddUser(); | |
| 49 segment->AddUser(); | |
| 50 EXPECT_FALSE(segment->HasNoUsers()); | |
| 51 | |
| 52 segment->ReleaseUser(); | |
| 53 EXPECT_FALSE(segment->HasNoUsers()); | |
| 54 segment->ReleaseUser(); | |
| 55 EXPECT_TRUE(segment->HasNoUsers()); | |
| 56 | |
| 57 EXPECT_TRUE(segment->Close()); | |
| 58 } | |
| 59 | |
| 60 TEST_F(FlashCacheTest, SegmentCreateDestroy) { | |
| 61 disk_cache::Storage storage(path_, kStorageSize); | |
| 62 ASSERT_TRUE(storage.Init()); | |
| 63 | |
| 64 int32 index = 0; | |
| 65 scoped_ptr<disk_cache::Segment> segment( | |
| 66 new disk_cache::Segment(index, false, &storage)); | |
| 67 EXPECT_TRUE(segment->Init()); | |
| 68 EXPECT_TRUE(segment->Close()); | |
| 69 | |
| 70 index = kNumTestSegments - 1; | |
| 71 segment.reset(new disk_cache::Segment(index, false, &storage)); | |
| 72 EXPECT_TRUE(segment->Init()); | |
| 73 EXPECT_TRUE(segment->Close()); | |
| 74 | |
| 75 int32 invalid_index = kNumTestSegments; | |
| 76 segment.reset(new disk_cache::Segment(invalid_index, false, &storage)); | |
| 77 EXPECT_FALSE(segment->Init()); | |
| 78 | |
| 79 invalid_index = -1; | |
| 80 segment.reset(new disk_cache::Segment(invalid_index, false, &storage)); | |
| 81 EXPECT_FALSE(segment->Init()); | |
| 82 } | |
| 83 | |
| 84 TEST_F(FlashCacheTest, SegmentWriteDataReadData) { | |
| 85 disk_cache::Storage storage(path_, kStorageSize); | |
| 86 ASSERT_TRUE(storage.Init()); | |
| 87 | |
| 88 int32 index = rand() % kNumTestSegments; | |
| 89 scoped_ptr<disk_cache::Segment> segment( | |
| 90 new disk_cache::Segment(index, false, &storage)); | |
| 91 | |
| 92 EXPECT_TRUE(segment->Init()); | |
| 93 SmallEntry entry1; | |
| 94 EXPECT_TRUE(segment->CanHold(entry1.size)); | |
| 95 int32 offset = segment->write_offset(); | |
| 96 EXPECT_TRUE(segment->WriteData(entry1.data, entry1.size)); | |
| 97 segment->StoreOffset(offset); | |
| 98 EXPECT_TRUE(segment->Close()); | |
| 99 | |
| 100 segment.reset(new disk_cache::Segment(index, true, &storage)); | |
| 101 EXPECT_TRUE(segment->Init()); | |
| 102 SmallEntry entry2; | |
| 103 EXPECT_TRUE(segment->ReadData(entry2.data, entry2.size, offset)); | |
| 104 EXPECT_EQ(entry1, entry2); | |
| 105 EXPECT_TRUE(segment->Close()); | |
| 106 } | |
| 107 | |
| 108 TEST_F(FlashCacheTest, SegmentFillWithSmallEntries) { | |
| 109 disk_cache::Storage storage(path_, kStorageSize); | |
| 110 ASSERT_TRUE(storage.Init()); | |
| 111 | |
| 112 int32 index = rand() % kNumTestSegments; | |
| 113 scoped_ptr<disk_cache::Segment> segment( | |
| 114 new disk_cache::Segment(index, false, &storage)); | |
| 115 | |
| 116 EXPECT_TRUE(segment->Init()); | |
| 117 SmallEntry entry; | |
| 118 int32 num_bytes_written = 0; | |
| 119 while (segment->CanHold(entry.size)) { | |
| 120 int32 offset = segment->write_offset(); | |
| 121 EXPECT_TRUE(segment->WriteData(entry.data, entry.size)); | |
| 122 segment->StoreOffset(offset); | |
| 123 num_bytes_written += entry.size; | |
| 124 } | |
| 125 int32 space_left = kSegmentFreeSpace - num_bytes_written; | |
| 126 EXPECT_GE(space_left, entry.size); | |
| 127 EXPECT_EQ(segment->GetOffsets().size(), disk_cache::kFlashMaxEntryCount); | |
| 128 EXPECT_TRUE(segment->Close()); | |
| 129 } | |
| 130 | |
| 131 TEST_F(FlashCacheTest, SegmentFillWithLargeEntries) { | |
| 132 disk_cache::Storage storage(path_, kStorageSize); | |
| 133 ASSERT_TRUE(storage.Init()); | |
| 134 | |
| 135 int32 index = rand() % kNumTestSegments; | |
| 136 scoped_ptr<disk_cache::Segment> segment( | |
| 137 new disk_cache::Segment(index, false, &storage)); | |
| 138 | |
| 139 EXPECT_TRUE(segment->Init()); | |
| 140 scoped_ptr<LargeEntry> entry(new LargeEntry); | |
| 141 int32 num_bytes_written = 0; | |
| 142 while (segment->CanHold(entry->size)) { | |
| 143 int32 offset = segment->write_offset(); | |
| 144 EXPECT_TRUE(segment->WriteData(entry->data, entry->size)); | |
| 145 segment->StoreOffset(offset); | |
| 146 num_bytes_written += entry->size; | |
| 147 } | |
| 148 int32 space_left = kSegmentFreeSpace - num_bytes_written; | |
| 149 EXPECT_LT(space_left, entry->size); | |
| 150 EXPECT_LT(segment->GetOffsets().size(), disk_cache::kFlashMaxEntryCount); | |
| 151 EXPECT_TRUE(segment->Close()); | |
| 152 } | |
| OLD | NEW |