OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <stdint.h> | 5 #include <stdint.h> |
6 | 6 |
7 #include "base/basictypes.h" | 7 #include "base/basictypes.h" |
8 #include "base/files/file_util.h" | 8 #include "base/files/file_util.h" |
9 #include "base/metrics/field_trial.h" | 9 #include "base/metrics/field_trial.h" |
10 #include "base/run_loop.h" | 10 #include "base/run_loop.h" |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
82 // will be filled with times, used by DoomEntriesSince and DoomEntriesBetween. | 82 // will be filled with times, used by DoomEntriesSince and DoomEntriesBetween. |
83 // There are 4 entries after doomed_start and 2 after doomed_end. | 83 // There are 4 entries after doomed_start and 2 after doomed_end. |
84 void InitSparseCache(base::Time* doomed_start, base::Time* doomed_end); | 84 void InitSparseCache(base::Time* doomed_start, base::Time* doomed_end); |
85 | 85 |
86 bool CreateSetOfRandomEntries(std::set<std::string>* key_pool); | 86 bool CreateSetOfRandomEntries(std::set<std::string>* key_pool); |
87 bool EnumerateAndMatchKeys(int max_to_open, | 87 bool EnumerateAndMatchKeys(int max_to_open, |
88 TestIterator* iter, | 88 TestIterator* iter, |
89 std::set<std::string>* keys_to_match, | 89 std::set<std::string>* keys_to_match, |
90 size_t* count); | 90 size_t* count); |
91 | 91 |
92 // Computes the expected size of entry metadata, i.e. the total size without | |
93 // the actual data stored. This depends only on the entry's |key| size. | |
94 int GetEntryMetadataSize(std::string key); | |
95 | |
92 // Actual tests: | 96 // Actual tests: |
93 void BackendBasics(); | 97 void BackendBasics(); |
94 void BackendKeying(); | 98 void BackendKeying(); |
95 void BackendShutdownWithPendingFileIO(bool fast); | 99 void BackendShutdownWithPendingFileIO(bool fast); |
96 void BackendShutdownWithPendingIO(bool fast); | 100 void BackendShutdownWithPendingIO(bool fast); |
97 void BackendShutdownWithPendingCreate(bool fast); | 101 void BackendShutdownWithPendingCreate(bool fast); |
98 void BackendSetSize(); | 102 void BackendSetSize(); |
99 void BackendLoad(); | 103 void BackendLoad(); |
100 void BackendChain(); | 104 void BackendChain(); |
101 void BackendValidEntry(); | 105 void BackendValidEntry(); |
(...skipping 173 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
275 EXPECT_EQ(1U, keys_to_match->erase(entry->GetKey())); | 279 EXPECT_EQ(1U, keys_to_match->erase(entry->GetKey())); |
276 entry->Close(); | 280 entry->Close(); |
277 ++(*count); | 281 ++(*count); |
278 if (max_to_open >= 0 && static_cast<int>(*count) >= max_to_open) | 282 if (max_to_open >= 0 && static_cast<int>(*count) >= max_to_open) |
279 break; | 283 break; |
280 }; | 284 }; |
281 | 285 |
282 return true; | 286 return true; |
283 } | 287 } |
284 | 288 |
289 int DiskCacheBackendTest::GetEntryMetadataSize(std::string key) { | |
290 // For blockfile and memory backends, it is just the key size. | |
291 if (!simple_cache_mode_) | |
292 return key.size(); | |
293 | |
294 // For the simple cache, we must add the file header and EOF, and that for | |
295 // every stream. | |
gavinp
2015/10/13 15:50:12
Is this right? We now store stream 0 and stream 1
msramek
2015/10/13 17:25:50
In DiskCacheBackendTest::BackendCalculateSizeOfAll
| |
296 return disk_cache::kSimpleEntryStreamCount * ( | |
297 sizeof(disk_cache::SimpleFileHeader) + | |
298 sizeof(disk_cache::SimpleFileEOF) + | |
299 key.size()); | |
300 } | |
301 | |
285 void DiskCacheBackendTest::BackendBasics() { | 302 void DiskCacheBackendTest::BackendBasics() { |
286 InitCache(); | 303 InitCache(); |
287 disk_cache::Entry *entry1 = NULL, *entry2 = NULL; | 304 disk_cache::Entry *entry1 = NULL, *entry2 = NULL; |
288 EXPECT_NE(net::OK, OpenEntry("the first key", &entry1)); | 305 EXPECT_NE(net::OK, OpenEntry("the first key", &entry1)); |
289 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1)); | 306 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1)); |
290 ASSERT_TRUE(NULL != entry1); | 307 ASSERT_TRUE(NULL != entry1); |
291 entry1->Close(); | 308 entry1->Close(); |
292 entry1 = NULL; | 309 entry1 = NULL; |
293 | 310 |
294 ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1)); | 311 ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1)); |
(...skipping 1377 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1672 start = end; | 1689 start = end; |
1673 end = base::Time::Now(); | 1690 end = base::Time::Now(); |
1674 DoomEntriesBetween(start, end); | 1691 DoomEntriesBetween(start, end); |
1675 EXPECT_EQ(3, cache_->GetEntryCount()); | 1692 EXPECT_EQ(3, cache_->GetEntryCount()); |
1676 } | 1693 } |
1677 | 1694 |
1678 void DiskCacheBackendTest::BackendCalculateSizeOfAllEntries() { | 1695 void DiskCacheBackendTest::BackendCalculateSizeOfAllEntries() { |
1679 InitCache(); | 1696 InitCache(); |
1680 | 1697 |
1681 // The cache is initially empty. | 1698 // The cache is initially empty. |
1682 if (memory_only_ || simple_cache_mode_) { | 1699 EXPECT_EQ(0, CalculateSizeOfAllEntries()); |
1683 // TODO(msramek): Implement. | |
1684 EXPECT_EQ(net::ERR_NOT_IMPLEMENTED, CalculateSizeOfAllEntries()); | |
1685 } else { | |
1686 EXPECT_EQ(0, CalculateSizeOfAllEntries()); | |
1687 } | |
1688 | 1700 |
1689 // Generate random entries and populate them with data of respective | 1701 // Generate random entries and populate them with data of respective |
1690 // sizes 0, 1, ..., count - 1 bytes. | 1702 // sizes 0, 1, ..., count - 1 bytes. |
1691 std::set<std::string> key_pool; | 1703 std::set<std::string> key_pool; |
1692 CreateSetOfRandomEntries(&key_pool); | 1704 CreateSetOfRandomEntries(&key_pool); |
1693 | 1705 |
1694 int count = 0; | 1706 int count = 0; |
1695 for (std::string key : key_pool) { | 1707 for (std::string key : key_pool) { |
1696 std::string data(count, ' '); | 1708 std::string data(count, ' '); |
1697 scoped_refptr<net::StringIOBuffer> buffer = new net::StringIOBuffer(data); | 1709 scoped_refptr<net::StringIOBuffer> buffer = new net::StringIOBuffer(data); |
1698 | 1710 |
1699 // Alternate between writing to the first and second stream to test that | 1711 // Alternate between writing to the first and second stream to test that |
1700 // we are not taking just the first stream into account. | 1712 // we are not taking just the first stream into account. For convenience, |
1713 // the last written stream should be 0. This is because writing to | |
1714 // the stream 1 in simple cache triggers a write to the stream 0 as well. | |
1715 // This will happen asynchronously and possibly later than our call to | |
1716 // |CalculateSizeOfAllEntries|. | |
1701 disk_cache::Entry* entry; | 1717 disk_cache::Entry* entry; |
1702 ASSERT_EQ(net::OK, OpenEntry(key, &entry)); | 1718 ASSERT_EQ(net::OK, OpenEntry(key, &entry)); |
1703 ASSERT_EQ(count, WriteData(entry, count % 2, 0, buffer.get(), count, true)); | 1719 ASSERT_EQ(count, |
1720 WriteData(entry, (count + 1) % 2, 0, buffer.get(), count, true)); | |
1704 entry->Close(); | 1721 entry->Close(); |
1705 | 1722 |
1706 ++count; | 1723 ++count; |
1707 } | 1724 } |
1708 | 1725 |
1709 // The resulting size should be (0 + 1 + ... + count - 1) plus keys. | 1726 // The resulting size should be (0 + 1 + ... + count - 1) plus keys. |
1710 int result = CalculateSizeOfAllEntries(); | 1727 int result = CalculateSizeOfAllEntries(); |
1711 if (memory_only_ || simple_cache_mode_) { | 1728 int total_metadata_size = 0; |
1712 // TODO(msramek): Implement. | 1729 for (std::string key : key_pool) |
1713 EXPECT_EQ(net::ERR_NOT_IMPLEMENTED, result); | 1730 total_metadata_size += GetEntryMetadataSize(key); |
1714 } else { | 1731 EXPECT_EQ((count - 1) * count / 2 + total_metadata_size, result); |
1715 int total_key_size = 0; | |
1716 for (std::string key : key_pool) | |
1717 total_key_size += key.size(); | |
1718 | |
1719 EXPECT_EQ((count - 1) * count / 2 + total_key_size, result); | |
1720 } | |
1721 | 1732 |
1722 // Add another entry and test if the size is updated. Then remove it and test | 1733 // Add another entry and test if the size is updated. Then remove it and test |
1723 // if the size is back to original value. | 1734 // if the size is back to original value. |
1724 { | 1735 { |
1725 const int last_entry_size = 47; | 1736 const int last_entry_size = 47; |
1726 std::string data(last_entry_size, ' '); | 1737 std::string data(last_entry_size, ' '); |
1727 scoped_refptr<net::StringIOBuffer> buffer = new net::StringIOBuffer(data); | 1738 scoped_refptr<net::StringIOBuffer> buffer = new net::StringIOBuffer(data); |
1728 | 1739 |
1729 disk_cache::Entry* entry; | 1740 disk_cache::Entry* entry; |
1730 std::string key = GenerateKey(true); | 1741 std::string key = GenerateKey(true); |
1731 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); | 1742 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
1732 ASSERT_EQ(last_entry_size, | 1743 ASSERT_EQ(last_entry_size, |
1733 WriteData(entry, 0, 0, buffer.get(), last_entry_size, true)); | 1744 WriteData(entry, 0, 0, buffer.get(), last_entry_size, true)); |
1734 entry->Close(); | 1745 entry->Close(); |
1735 | 1746 |
1736 int new_result = CalculateSizeOfAllEntries(); | 1747 int new_result = CalculateSizeOfAllEntries(); |
1737 if (memory_only_ || simple_cache_mode_) { | 1748 EXPECT_EQ(result + last_entry_size + GetEntryMetadataSize(key), |
1738 // TODO(msramek): Implement. | 1749 new_result); |
1739 EXPECT_EQ(net::ERR_NOT_IMPLEMENTED, new_result); | |
1740 } else { | |
1741 EXPECT_EQ(result + last_entry_size + static_cast<int>(key.size()), | |
1742 new_result); | |
1743 } | |
1744 | 1750 |
1745 DoomEntry(key); | 1751 DoomEntry(key); |
1746 new_result = CalculateSizeOfAllEntries(); | 1752 new_result = CalculateSizeOfAllEntries(); |
1747 if (memory_only_ || simple_cache_mode_) { | 1753 EXPECT_EQ(result, new_result); |
1748 // TODO(msramek): Implement. | |
1749 EXPECT_EQ(net::ERR_NOT_IMPLEMENTED, new_result); | |
1750 } else { | |
1751 EXPECT_EQ(result, new_result); | |
1752 } | |
1753 } | 1754 } |
1754 | 1755 |
1755 // After dooming the entries, the size should be back to zero. | 1756 // After dooming the entries, the size should be back to zero. |
1756 ASSERT_EQ(net::OK, DoomAllEntries()); | 1757 ASSERT_EQ(net::OK, DoomAllEntries()); |
1757 if (memory_only_ || simple_cache_mode_) { | 1758 EXPECT_EQ(0, CalculateSizeOfAllEntries()); |
1758 // TODO(msramek): Implement. | |
1759 EXPECT_EQ(net::ERR_NOT_IMPLEMENTED, CalculateSizeOfAllEntries()); | |
1760 } else { | |
1761 EXPECT_EQ(0, CalculateSizeOfAllEntries()); | |
1762 } | |
1763 } | 1759 } |
1764 | 1760 |
1765 TEST_F(DiskCacheBackendTest, CalculateSizeOfAllEntries) { | 1761 TEST_F(DiskCacheBackendTest, CalculateSizeOfAllEntries) { |
1766 BackendCalculateSizeOfAllEntries(); | 1762 BackendCalculateSizeOfAllEntries(); |
1767 } | 1763 } |
1768 | 1764 |
1769 TEST_F(DiskCacheBackendTest, MemoryOnlyCalculateSizeOfAllEntries) { | 1765 TEST_F(DiskCacheBackendTest, MemoryOnlyCalculateSizeOfAllEntries) { |
1770 SetMemoryOnlyMode(); | 1766 SetMemoryOnlyMode(); |
1771 BackendCalculateSizeOfAllEntries(); | 1767 BackendCalculateSizeOfAllEntries(); |
1772 } | 1768 } |
(...skipping 1852 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3625 // after closing. | 3621 // after closing. |
3626 // NOTE: IF THIS TEST IS FLAKY THEN IT IS FAILING. See https://crbug.com/416940 | 3622 // NOTE: IF THIS TEST IS FLAKY THEN IT IS FAILING. See https://crbug.com/416940 |
3627 TEST_F(DiskCacheBackendTest, SimpleCacheDeleteQuickly) { | 3623 TEST_F(DiskCacheBackendTest, SimpleCacheDeleteQuickly) { |
3628 SetSimpleCacheMode(); | 3624 SetSimpleCacheMode(); |
3629 for (int i = 0; i < 100; ++i) { | 3625 for (int i = 0; i < 100; ++i) { |
3630 InitCache(); | 3626 InitCache(); |
3631 cache_.reset(); | 3627 cache_.reset(); |
3632 EXPECT_TRUE(CleanupCacheDir()); | 3628 EXPECT_TRUE(CleanupCacheDir()); |
3633 } | 3629 } |
3634 } | 3630 } |
OLD | NEW |