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 1661 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1672 start = end; | 1672 start = end; |
1673 end = base::Time::Now(); | 1673 end = base::Time::Now(); |
1674 DoomEntriesBetween(start, end); | 1674 DoomEntriesBetween(start, end); |
1675 EXPECT_EQ(3, cache_->GetEntryCount()); | 1675 EXPECT_EQ(3, cache_->GetEntryCount()); |
1676 } | 1676 } |
1677 | 1677 |
1678 void DiskCacheBackendTest::BackendCalculateSizeOfAllEntries() { | 1678 void DiskCacheBackendTest::BackendCalculateSizeOfAllEntries() { |
1679 InitCache(); | 1679 InitCache(); |
1680 | 1680 |
1681 // The cache is initially empty. | 1681 // The cache is initially empty. |
1682 if (memory_only_ || simple_cache_mode_) { | 1682 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 | 1683 |
1689 // Generate random entries and populate them with data of respective | 1684 // Generate random entries and populate them with data of respective |
1690 // sizes 0, 1, ..., count - 1 bytes. | 1685 // sizes 0, 1, ..., count - 1 bytes. |
1691 std::set<std::string> key_pool; | 1686 std::set<std::string> key_pool; |
1692 CreateSetOfRandomEntries(&key_pool); | 1687 CreateSetOfRandomEntries(&key_pool); |
1693 | 1688 |
1694 int count = 0; | 1689 int count = 0; |
1695 for (std::string key : key_pool) { | 1690 for (std::string key : key_pool) { |
1696 std::string data(count, ' '); | 1691 std::string data(count, ' '); |
1697 scoped_refptr<net::StringIOBuffer> buffer = new net::StringIOBuffer(data); | 1692 scoped_refptr<net::StringIOBuffer> buffer = new net::StringIOBuffer(data); |
1698 | 1693 |
1699 // Alternate between writing to the first and second stream to test that | 1694 // Alternate between writing to the first and second stream to test that |
1700 // we are not taking just the first stream into account. | 1695 // we are not taking just the first stream into account. For convenience, |
1696 // the last written stream should be 0. This is because writing to | |
1697 // the stream 1 in simple cache triggers a write to the stream 0 as well. | |
pasko
2015/10/09 15:52:03
This is subtle. Will the stream 0 contain the chec
msramek
2015/10/13 09:45:06
So, I observed that writing to stream 1 triggers t
| |
1698 // This will happen asynchronously and possibly later than our call to | |
1699 // |CalculateSizeOfAllEntries|. | |
1701 disk_cache::Entry* entry; | 1700 disk_cache::Entry* entry; |
1702 ASSERT_EQ(net::OK, OpenEntry(key, &entry)); | 1701 ASSERT_EQ(net::OK, OpenEntry(key, &entry)); |
1703 ASSERT_EQ(count, WriteData(entry, count % 2, 0, buffer.get(), count, true)); | 1702 ASSERT_EQ(count, |
1703 WriteData(entry, (count + 1) % 2, 0, buffer.get(), count, true)); | |
1704 entry->Close(); | 1704 entry->Close(); |
1705 | 1705 |
1706 ++count; | 1706 ++count; |
1707 } | 1707 } |
1708 | 1708 |
1709 // The resulting size should be (0 + 1 + ... + count - 1) plus keys. | 1709 // The resulting size should be (0 + 1 + ... + count - 1) plus keys. |
1710 int result = CalculateSizeOfAllEntries(); | 1710 int result = CalculateSizeOfAllEntries(); |
1711 if (memory_only_ || simple_cache_mode_) { | 1711 int total_key_size = 0; |
1712 // TODO(msramek): Implement. | 1712 for (std::string key : key_pool) { |
1713 EXPECT_EQ(net::ERR_NOT_IMPLEMENTED, result); | 1713 if (!simple_cache_mode_) { |
1714 } else { | |
1715 int total_key_size = 0; | |
1716 for (std::string key : key_pool) | |
1717 total_key_size += key.size(); | 1714 total_key_size += key.size(); |
1718 | 1715 } else { |
1719 EXPECT_EQ((count - 1) * count / 2 + total_key_size, result); | 1716 // In the case of simple cache, we must count the key size together with |
1717 // the file headers, and that for each of the streams. | |
1718 total_key_size += disk_cache::kSimpleEntryStreamCount * ( | |
1719 sizeof(disk_cache::SimpleFileHeader) + | |
1720 sizeof(disk_cache::SimpleFileEOF) + | |
1721 key.size()); | |
1722 } | |
1720 } | 1723 } |
1724 EXPECT_EQ((count - 1) * count / 2 + total_key_size, result); | |
1721 | 1725 |
1722 // Add another entry and test if the size is updated. Then remove it and test | 1726 // Add another entry and test if the size is updated. Then remove it and test |
1723 // if the size is back to original value. | 1727 // if the size is back to original value. |
1724 { | 1728 { |
1725 const int last_entry_size = 47; | 1729 const int last_entry_size = 47; |
1726 std::string data(last_entry_size, ' '); | 1730 std::string data(last_entry_size, ' '); |
1727 scoped_refptr<net::StringIOBuffer> buffer = new net::StringIOBuffer(data); | 1731 scoped_refptr<net::StringIOBuffer> buffer = new net::StringIOBuffer(data); |
1728 | 1732 |
1729 disk_cache::Entry* entry; | 1733 disk_cache::Entry* entry; |
1730 std::string key = GenerateKey(true); | 1734 std::string key = GenerateKey(true); |
1731 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); | 1735 ASSERT_EQ(net::OK, CreateEntry(key, &entry)); |
1732 ASSERT_EQ(last_entry_size, | 1736 ASSERT_EQ(last_entry_size, |
1733 WriteData(entry, 0, 0, buffer.get(), last_entry_size, true)); | 1737 WriteData(entry, 0, 0, buffer.get(), last_entry_size, true)); |
1734 entry->Close(); | 1738 entry->Close(); |
1735 | 1739 |
1736 int new_result = CalculateSizeOfAllEntries(); | 1740 int new_result = CalculateSizeOfAllEntries(); |
1737 if (memory_only_ || simple_cache_mode_) { | 1741 if (simple_cache_mode_) { |
1738 // TODO(msramek): Implement. | 1742 EXPECT_EQ( |
1739 EXPECT_EQ(net::ERR_NOT_IMPLEMENTED, new_result); | 1743 result + |
1744 last_entry_size + | |
1745 static_cast<int>(disk_cache::kSimpleEntryStreamCount * ( | |
1746 sizeof(disk_cache::SimpleFileHeader) + | |
1747 sizeof(disk_cache::SimpleFileEOF) + | |
1748 key.size())), | |
1749 new_result); | |
1740 } else { | 1750 } else { |
1741 EXPECT_EQ(result + last_entry_size + static_cast<int>(key.size()), | 1751 EXPECT_EQ(result + last_entry_size + static_cast<int>(key.size()), |
1742 new_result); | 1752 new_result); |
1743 } | 1753 } |
1744 | 1754 |
1745 DoomEntry(key); | 1755 DoomEntry(key); |
1746 new_result = CalculateSizeOfAllEntries(); | 1756 new_result = CalculateSizeOfAllEntries(); |
1747 if (memory_only_ || simple_cache_mode_) { | 1757 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 } | 1758 } |
1754 | 1759 |
1755 // After dooming the entries, the size should be back to zero. | 1760 // After dooming the entries, the size should be back to zero. |
1756 ASSERT_EQ(net::OK, DoomAllEntries()); | 1761 ASSERT_EQ(net::OK, DoomAllEntries()); |
1757 if (memory_only_ || simple_cache_mode_) { | 1762 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 } | 1763 } |
1764 | 1764 |
1765 TEST_F(DiskCacheBackendTest, CalculateSizeOfAllEntries) { | 1765 TEST_F(DiskCacheBackendTest, CalculateSizeOfAllEntries) { |
1766 BackendCalculateSizeOfAllEntries(); | 1766 BackendCalculateSizeOfAllEntries(); |
1767 } | 1767 } |
1768 | 1768 |
1769 TEST_F(DiskCacheBackendTest, MemoryOnlyCalculateSizeOfAllEntries) { | 1769 TEST_F(DiskCacheBackendTest, MemoryOnlyCalculateSizeOfAllEntries) { |
1770 SetMemoryOnlyMode(); | 1770 SetMemoryOnlyMode(); |
1771 BackendCalculateSizeOfAllEntries(); | 1771 BackendCalculateSizeOfAllEntries(); |
1772 } | 1772 } |
(...skipping 1852 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3625 // after closing. | 3625 // after closing. |
3626 // NOTE: IF THIS TEST IS FLAKY THEN IT IS FAILING. See https://crbug.com/416940 | 3626 // NOTE: IF THIS TEST IS FLAKY THEN IT IS FAILING. See https://crbug.com/416940 |
3627 TEST_F(DiskCacheBackendTest, SimpleCacheDeleteQuickly) { | 3627 TEST_F(DiskCacheBackendTest, SimpleCacheDeleteQuickly) { |
3628 SetSimpleCacheMode(); | 3628 SetSimpleCacheMode(); |
3629 for (int i = 0; i < 100; ++i) { | 3629 for (int i = 0; i < 100; ++i) { |
3630 InitCache(); | 3630 InitCache(); |
3631 cache_.reset(); | 3631 cache_.reset(); |
3632 EXPECT_TRUE(CleanupCacheDir()); | 3632 EXPECT_TRUE(CleanupCacheDir()); |
3633 } | 3633 } |
3634 } | 3634 } |
OLD | NEW |