Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(191)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/disk_cache/backend_unittest.cc

Issue 2109503009: Refactor net tests to use GMock matchers for checking net::Error results (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Revert changes to contents.txt files Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/cert_net/nss_ocsp_unittest.cc ('k') | net/disk_cache/disk_cache_test_base.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/disk_cache/backend_unittest.cc
diff --git a/net/disk_cache/backend_unittest.cc b/net/disk_cache/backend_unittest.cc
index d9e6c2dc5dcd3efcb7edfb671fa6786ebfebb134..fcbc85c2fa3dbfac16593b9a2b4ab0c98a5df0cb 100644
--- a/net/disk_cache/backend_unittest.cc
+++ b/net/disk_cache/backend_unittest.cc
@@ -36,8 +36,13 @@
#include "net/disk_cache/simple/simple_synchronous_entry.h"
#include "net/disk_cache/simple/simple_test_util.h"
#include "net/disk_cache/simple/simple_util.h"
+#include "net/test/gtest_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
+using net::test::IsError;
+using net::test::IsOk;
+
#if defined(OS_WIN)
#include "base/win/scoped_handle.h"
#endif
@@ -201,7 +206,7 @@ void DiskCacheBackendTest::InitSparseCache(base::Time* doomed_start,
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
- ASSERT_EQ(net::OK, CreateEntry("zeroth", &entry0));
+ ASSERT_THAT(CreateEntry("zeroth", &entry0), IsOk());
ASSERT_EQ(kSize, WriteSparseData(entry0, 0, buffer.get(), kSize));
ASSERT_EQ(kSize,
WriteSparseData(entry0, kOffset + kSize, buffer.get(), kSize));
@@ -214,13 +219,13 @@ void DiskCacheBackendTest::InitSparseCache(base::Time* doomed_start,
// Order in rankings list:
// first_part1, first_part2, second_part1, second_part2
- ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
+ ASSERT_THAT(CreateEntry("first", &entry1), IsOk());
ASSERT_EQ(kSize, WriteSparseData(entry1, 0, buffer.get(), kSize));
ASSERT_EQ(kSize,
WriteSparseData(entry1, kOffset + kSize, buffer.get(), kSize));
entry1->Close();
- ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
+ ASSERT_THAT(CreateEntry("second", &entry2), IsOk());
ASSERT_EQ(kSize, WriteSparseData(entry2, 0, buffer.get(), kSize));
ASSERT_EQ(kSize,
WriteSparseData(entry2, kOffset + kSize, buffer.get(), kSize));
@@ -235,9 +240,9 @@ void DiskCacheBackendTest::InitSparseCache(base::Time* doomed_start,
// third_part1, fourth_part1, third_part2, fourth_part2
disk_cache::Entry* entry3 = NULL;
disk_cache::Entry* entry4 = NULL;
- ASSERT_EQ(net::OK, CreateEntry("third", &entry3));
+ ASSERT_THAT(CreateEntry("third", &entry3), IsOk());
ASSERT_EQ(kSize, WriteSparseData(entry3, 0, buffer.get(), kSize));
- ASSERT_EQ(net::OK, CreateEntry("fourth", &entry4));
+ ASSERT_THAT(CreateEntry("fourth", &entry4), IsOk());
ASSERT_EQ(kSize, WriteSparseData(entry4, 0, buffer.get(), kSize));
ASSERT_EQ(kSize,
WriteSparseData(entry3, kOffset + kSize, buffer.get(), kSize));
@@ -311,44 +316,44 @@ void DiskCacheBackendTest::BackendBasics() {
InitCache();
disk_cache::Entry *entry1 = NULL, *entry2 = NULL;
EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
- ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
+ ASSERT_THAT(CreateEntry("the first key", &entry1), IsOk());
ASSERT_TRUE(NULL != entry1);
entry1->Close();
entry1 = NULL;
- ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
+ ASSERT_THAT(OpenEntry("the first key", &entry1), IsOk());
ASSERT_TRUE(NULL != entry1);
entry1->Close();
entry1 = NULL;
EXPECT_NE(net::OK, CreateEntry("the first key", &entry1));
- ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
+ ASSERT_THAT(OpenEntry("the first key", &entry1), IsOk());
EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
- ASSERT_EQ(net::OK, CreateEntry("some other key", &entry2));
+ ASSERT_THAT(CreateEntry("some other key", &entry2), IsOk());
ASSERT_TRUE(NULL != entry1);
ASSERT_TRUE(NULL != entry2);
EXPECT_EQ(2, cache_->GetEntryCount());
disk_cache::Entry* entry3 = NULL;
- ASSERT_EQ(net::OK, OpenEntry("some other key", &entry3));
+ ASSERT_THAT(OpenEntry("some other key", &entry3), IsOk());
ASSERT_TRUE(NULL != entry3);
EXPECT_TRUE(entry2 == entry3);
EXPECT_EQ(2, cache_->GetEntryCount());
- EXPECT_EQ(net::OK, DoomEntry("some other key"));
+ EXPECT_THAT(DoomEntry("some other key"), IsOk());
EXPECT_EQ(1, cache_->GetEntryCount());
entry1->Close();
entry2->Close();
entry3->Close();
- EXPECT_EQ(net::OK, DoomEntry("the first key"));
+ EXPECT_THAT(DoomEntry("the first key"), IsOk());
EXPECT_EQ(0, cache_->GetEntryCount());
- ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
- ASSERT_EQ(net::OK, CreateEntry("some other key", &entry2));
+ ASSERT_THAT(CreateEntry("the first key", &entry1), IsOk());
+ ASSERT_THAT(CreateEntry("some other key", &entry2), IsOk());
entry1->Doom();
entry1->Close();
- EXPECT_EQ(net::OK, DoomEntry("some other key"));
+ EXPECT_THAT(DoomEntry("some other key"), IsOk());
EXPECT_EQ(0, cache_->GetEntryCount());
entry2->Close();
}
@@ -382,25 +387,25 @@ void DiskCacheBackendTest::BackendKeying() {
const char kName1[] = "the first key";
const char kName2[] = "the first Key";
disk_cache::Entry *entry1, *entry2;
- ASSERT_EQ(net::OK, CreateEntry(kName1, &entry1));
+ ASSERT_THAT(CreateEntry(kName1, &entry1), IsOk());
- ASSERT_EQ(net::OK, CreateEntry(kName2, &entry2));
+ ASSERT_THAT(CreateEntry(kName2, &entry2), IsOk());
EXPECT_TRUE(entry1 != entry2) << "Case sensitive";
entry2->Close();
char buffer[30];
base::strlcpy(buffer, kName1, arraysize(buffer));
- ASSERT_EQ(net::OK, OpenEntry(buffer, &entry2));
+ ASSERT_THAT(OpenEntry(buffer, &entry2), IsOk());
EXPECT_TRUE(entry1 == entry2);
entry2->Close();
base::strlcpy(buffer + 1, kName1, arraysize(buffer) - 1);
- ASSERT_EQ(net::OK, OpenEntry(buffer + 1, &entry2));
+ ASSERT_THAT(OpenEntry(buffer + 1, &entry2), IsOk());
EXPECT_TRUE(entry1 == entry2);
entry2->Close();
base::strlcpy(buffer + 3, kName1, arraysize(buffer) - 3);
- ASSERT_EQ(net::OK, OpenEntry(buffer + 3, &entry2));
+ ASSERT_THAT(OpenEntry(buffer + 3, &entry2), IsOk());
EXPECT_TRUE(entry1 == entry2);
entry2->Close();
@@ -467,7 +472,7 @@ TEST_F(DiskCacheTest, CreateBackend) {
NULL,
&cache,
cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(cache.get());
cache.reset();
@@ -476,7 +481,7 @@ TEST_F(DiskCacheTest, CreateBackend) {
base::FilePath(), 0,
false, NULL, NULL, &cache,
cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(cache.get());
cache.reset();
}
@@ -498,7 +503,7 @@ TEST_F(DiskCacheBackendTest, CreateBackend_MissingFile) {
std::unique_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
cache_path_, cache_thread.task_runner(), NULL));
int rv = cache->Init(cb.callback());
- EXPECT_EQ(net::ERR_FAILED, cb.GetResult(rv));
+ EXPECT_THAT(cb.GetResult(rv), IsError(net::ERR_FAILED));
base::ThreadRestrictions::SetIOAllowed(prev);
cache.reset();
@@ -517,7 +522,7 @@ TEST_F(DiskCacheBackendTest, ExternalFiles) {
// Now let's create a file with the cache.
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry("key", &entry));
+ ASSERT_THAT(CreateEntry("key", &entry), IsOk());
ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1.get(), 0, false));
entry->Close();
@@ -598,7 +603,7 @@ TEST_F(DiskCacheBackendTest, MultipleInstancesWithPendingFileIO) {
NULL,
&extra_cache,
cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(extra_cache.get() != NULL);
ASSERT_TRUE(CleanupCacheDir());
@@ -640,7 +645,7 @@ void DiskCacheBackendTest::BackendShutdownWithPendingIO(bool fast) {
disk_cache::Entry* entry;
int rv = cache_->CreateEntry("some key", &entry, cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
entry->Close();
@@ -682,7 +687,7 @@ void DiskCacheBackendTest::BackendShutdownWithPendingCreate(bool fast) {
disk_cache::Entry* entry;
int rv = cache_->CreateEntry("some key", &entry, cb.callback());
- ASSERT_EQ(net::ERR_IO_PENDING, rv);
+ ASSERT_THAT(rv, IsError(net::ERR_IO_PENDING));
cache_.reset();
EXPECT_FALSE(cb.have_result());
@@ -719,12 +724,12 @@ void DiskCacheBackendTest::BackendShutdownWithPendingDoom() {
disk_cache::Entry* entry;
int rv = cache_->CreateEntry("some key", &entry, cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
entry->Close();
entry = nullptr;
rv = cache_->DoomEntry("some key", cb.callback());
- ASSERT_EQ(net::ERR_IO_PENDING, rv);
+ ASSERT_THAT(rv, IsError(net::ERR_IO_PENDING));
cache_.reset();
EXPECT_FALSE(cb.have_result());
@@ -775,7 +780,7 @@ void DiskCacheBackendTest::BackendSetSize() {
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(first, &entry));
+ ASSERT_THAT(CreateEntry(first, &entry), IsOk());
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(cache_size));
memset(buffer->data(), 0, cache_size);
@@ -803,12 +808,12 @@ void DiskCacheBackendTest::BackendSetSize() {
// The cache is 95% full.
- ASSERT_EQ(net::OK, CreateEntry(second, &entry));
+ ASSERT_THAT(CreateEntry(second, &entry), IsOk());
EXPECT_EQ(cache_size / 10,
WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false));
disk_cache::Entry* entry2;
- ASSERT_EQ(net::OK, CreateEntry("an extra key", &entry2));
+ ASSERT_THAT(CreateEntry("an extra key", &entry2), IsOk());
EXPECT_EQ(cache_size / 10,
WriteData(entry2, 0, 0, buffer.get(), cache_size / 10, false));
entry2->Close(); // This will trigger the cache trim.
@@ -819,7 +824,7 @@ void DiskCacheBackendTest::BackendSetSize() {
FlushQueueForTest(); // We may have posted two tasks to evict stuff.
entry->Close();
- ASSERT_EQ(net::OK, OpenEntry(second, &entry));
+ ASSERT_THAT(OpenEntry(second, &entry), IsOk());
EXPECT_EQ(cache_size / 10, entry->GetDataSize(0));
entry->Close();
}
@@ -846,7 +851,7 @@ void DiskCacheBackendTest::BackendLoad() {
disk_cache::Entry* entries[100];
for (int i = 0; i < 100; i++) {
std::string key = GenerateKey(true);
- ASSERT_EQ(net::OK, CreateEntry(key, &entries[i]));
+ ASSERT_THAT(CreateEntry(key, &entries[i]), IsOk());
}
EXPECT_EQ(100, cache_->GetEntryCount());
@@ -860,7 +865,7 @@ void DiskCacheBackendTest::BackendLoad() {
for (int i = 0; i < 100; i++) {
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, OpenEntry(entries[i]->GetKey(), &entry));
+ ASSERT_THAT(OpenEntry(entries[i]->GetKey(), &entry), IsOk());
EXPECT_TRUE(entry == entries[i]);
entry->Close();
entries[i]->Doom();
@@ -914,9 +919,9 @@ void DiskCacheBackendTest::BackendChain() {
InitCache();
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry("The first key", &entry));
+ ASSERT_THAT(CreateEntry("The first key", &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry("The Second key", &entry));
+ ASSERT_THAT(CreateEntry("The Second key", &entry), IsOk());
entry->Close();
}
@@ -946,11 +951,11 @@ TEST_F(DiskCacheBackendTest, NewEvictionTrim) {
disk_cache::Entry* entry;
for (int i = 0; i < 100; i++) {
std::string name(base::StringPrintf("Key %d", i));
- ASSERT_EQ(net::OK, CreateEntry(name, &entry));
+ ASSERT_THAT(CreateEntry(name, &entry), IsOk());
entry->Close();
if (i < 90) {
// Entries 0 to 89 are in list 1; 90 to 99 are in list 0.
- ASSERT_EQ(net::OK, OpenEntry(name, &entry));
+ ASSERT_THAT(OpenEntry(name, &entry), IsOk());
entry->Close();
}
}
@@ -963,9 +968,9 @@ TEST_F(DiskCacheBackendTest, NewEvictionTrim) {
EXPECT_NE(net::OK, OpenEntry("Key 90", &entry));
// Double check that we still have the list tails.
- ASSERT_EQ(net::OK, OpenEntry("Key 1", &entry));
+ ASSERT_THAT(OpenEntry("Key 1", &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, OpenEntry("Key 91", &entry));
+ ASSERT_THAT(OpenEntry("Key 91", &entry), IsOk());
entry->Close();
}
@@ -975,7 +980,7 @@ void DiskCacheBackendTest::BackendValidEntry() {
std::string key("Some key");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
@@ -985,7 +990,7 @@ void DiskCacheBackendTest::BackendValidEntry() {
entry->Close();
SimulateCrash();
- ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ ASSERT_THAT(OpenEntry(key, &entry), IsOk());
scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
memset(buffer2->data(), 0, kSize);
@@ -1011,7 +1016,7 @@ void DiskCacheBackendTest::BackendInvalidEntry() {
std::string key("Some key");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
@@ -1055,7 +1060,7 @@ void DiskCacheBackendTest::BackendInvalidEntryRead() {
std::string key("Some key");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
@@ -1063,14 +1068,14 @@ void DiskCacheBackendTest::BackendInvalidEntryRead() {
base::strlcpy(buffer->data(), "And the data to save", kSize);
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
entry->Close();
- ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ ASSERT_THAT(OpenEntry(key, &entry), IsOk());
EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer.get(), kSize));
SimulateCrash();
if (type_ == net::APP_CACHE) {
// Reading an entry and crashing should not make it dirty.
- ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ ASSERT_THAT(OpenEntry(key, &entry), IsOk());
EXPECT_EQ(1, cache_->GetEntryCount());
entry->Close();
} else {
@@ -1116,7 +1121,7 @@ void DiskCacheBackendTest::BackendInvalidEntryWithLoad() {
disk_cache::Entry* entries[kNumEntries];
for (int i = 0; i < kNumEntries; i++) {
std::string key = GenerateKey(true);
- ASSERT_EQ(net::OK, CreateEntry(key, &entries[i]));
+ ASSERT_THAT(CreateEntry(key, &entries[i]), IsOk());
}
EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
@@ -1144,7 +1149,7 @@ void DiskCacheBackendTest::BackendInvalidEntryWithLoad() {
for (int i = 0; i < kNumEntries / 2; i++) {
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, OpenEntry(keys[i], &entry));
+ ASSERT_THAT(OpenEntry(keys[i], &entry), IsOk());
entry->Close();
}
@@ -1183,7 +1188,7 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry() {
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(first, &entry));
+ ASSERT_THAT(CreateEntry(first, &entry), IsOk());
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
memset(buffer->data(), 0, kSize);
@@ -1192,7 +1197,7 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry() {
// Simulate a crash.
SimulateCrash();
- ASSERT_EQ(net::OK, CreateEntry(second, &entry));
+ ASSERT_THAT(CreateEntry(second, &entry), IsOk());
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
EXPECT_EQ(2, cache_->GetEntryCount());
@@ -1241,17 +1246,17 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry2() {
// Writing 32 entries to this cache chains most of them.
for (int i = 0; i < 32; i++) {
std::string key(base::StringPrintf("some key %d", i));
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
entry->Close();
- ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ ASSERT_THAT(OpenEntry(key, &entry), IsOk());
// Note that we are not closing the entries.
}
// Simulate a crash.
SimulateCrash();
- ASSERT_EQ(net::OK, CreateEntry("Something else", &entry));
+ ASSERT_THAT(CreateEntry("Something else", &entry), IsOk());
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
FlushQueueForTest();
@@ -1261,7 +1266,7 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry2() {
// For the new eviction code, all corrupt entries are on the second list so
// they are not going away that easy.
if (new_eviction_) {
- EXPECT_EQ(net::OK, DoomAllEntries());
+ EXPECT_THAT(DoomAllEntries(), IsOk());
}
entry->Close(); // Trim the cache.
@@ -1297,7 +1302,7 @@ void DiskCacheBackendTest::BackendEnumerations() {
for (int i = 0; i < kNumEntries; i++) {
std::string key = GenerateKey(true);
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
entry->Close();
}
EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
@@ -1367,17 +1372,17 @@ void DiskCacheBackendTest::BackendEnumerations2() {
const std::string first("first");
const std::string second("second");
disk_cache::Entry *entry1, *entry2;
- ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
+ ASSERT_THAT(CreateEntry(first, &entry1), IsOk());
entry1->Close();
- ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
+ ASSERT_THAT(CreateEntry(second, &entry2), IsOk());
entry2->Close();
FlushQueueForTest();
// Make sure that the timestamp is not the same.
AddDelay();
- ASSERT_EQ(net::OK, OpenEntry(second, &entry1));
+ ASSERT_THAT(OpenEntry(second, &entry1), IsOk());
std::unique_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
+ ASSERT_THAT(iter->OpenNextEntry(&entry2), IsOk());
EXPECT_EQ(entry2->GetKey(), second);
// Two entries and the iterator pointing at "first".
@@ -1385,15 +1390,15 @@ void DiskCacheBackendTest::BackendEnumerations2() {
entry2->Close();
// The iterator should still be valid, so we should not crash.
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
+ ASSERT_THAT(iter->OpenNextEntry(&entry2), IsOk());
EXPECT_EQ(entry2->GetKey(), first);
entry2->Close();
iter = CreateIterator();
// Modify the oldest entry and get the newest element.
- ASSERT_EQ(net::OK, OpenEntry(first, &entry1));
+ ASSERT_THAT(OpenEntry(first, &entry1), IsOk());
EXPECT_EQ(0, WriteData(entry1, 0, 200, NULL, 0, false));
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
+ ASSERT_THAT(iter->OpenNextEntry(&entry2), IsOk());
if (type_ == net::APP_CACHE) {
// The list is not updated.
EXPECT_EQ(entry2->GetKey(), second);
@@ -1440,12 +1445,12 @@ TEST_F(DiskCacheBackendTest, ShaderCacheEnumerationReadData) {
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
- ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
+ ASSERT_THAT(CreateEntry(first, &entry1), IsOk());
memset(buffer1->data(), 0, kSize);
base::strlcpy(buffer1->data(), "And the data to save", kSize);
EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
- ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
+ ASSERT_THAT(CreateEntry(second, &entry2), IsOk());
entry2->Close();
FlushQueueForTest();
@@ -1458,7 +1463,7 @@ TEST_F(DiskCacheBackendTest, ShaderCacheEnumerationReadData) {
entry1->Close();
std::unique_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
+ ASSERT_THAT(iter->OpenNextEntry(&entry2), IsOk());
EXPECT_EQ(entry2->GetKey(), second);
entry2->Close();
}
@@ -1471,7 +1476,7 @@ void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
std::string key("Some key");
disk_cache::Entry *entry, *entry1, *entry2;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
+ ASSERT_THAT(CreateEntry(key, &entry1), IsOk());
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
@@ -1479,11 +1484,11 @@ void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
base::strlcpy(buffer1->data(), "And the data to save", kSize);
EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
entry1->Close();
- ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
+ ASSERT_THAT(OpenEntry(key, &entry1), IsOk());
EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
std::string key2("Another key");
- ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
+ ASSERT_THAT(CreateEntry(key2, &entry2), IsOk());
entry2->Close();
ASSERT_EQ(2, cache_->GetEntryCount());
@@ -1525,7 +1530,7 @@ void DiskCacheBackendTest::BackendFixEnumerators() {
for (int i = 0; i < kNumEntries; i++) {
std::string key = GenerateKey(true);
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
entry->Close();
}
EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
@@ -1533,7 +1538,7 @@ void DiskCacheBackendTest::BackendFixEnumerators() {
disk_cache::Entry *entry1, *entry2;
std::unique_ptr<TestIterator> iter1 = CreateIterator(),
iter2 = CreateIterator();
- ASSERT_EQ(net::OK, iter1->OpenNextEntry(&entry1));
+ ASSERT_THAT(iter1->OpenNextEntry(&entry1), IsOk());
ASSERT_TRUE(NULL != entry1);
entry1->Close();
entry1 = NULL;
@@ -1542,17 +1547,17 @@ void DiskCacheBackendTest::BackendFixEnumerators() {
for (int i = 0; i < kNumEntries / 2; i++) {
if (entry1)
entry1->Close();
- ASSERT_EQ(net::OK, iter1->OpenNextEntry(&entry1));
+ ASSERT_THAT(iter1->OpenNextEntry(&entry1), IsOk());
ASSERT_TRUE(NULL != entry1);
- ASSERT_EQ(net::OK, iter2->OpenNextEntry(&entry2));
+ ASSERT_THAT(iter2->OpenNextEntry(&entry2), IsOk());
ASSERT_TRUE(NULL != entry2);
entry2->Close();
}
// Messing up with entry1 will modify entry2->next.
entry1->Doom();
- ASSERT_EQ(net::OK, iter2->OpenNextEntry(&entry2));
+ ASSERT_THAT(iter2->OpenNextEntry(&entry2), IsOk());
ASSERT_TRUE(NULL != entry2);
// The link entry2->entry1 should be broken.
@@ -1561,7 +1566,7 @@ void DiskCacheBackendTest::BackendFixEnumerators() {
entry2->Close();
// And the second iterator should keep working.
- ASSERT_EQ(net::OK, iter2->OpenNextEntry(&entry2));
+ ASSERT_THAT(iter2->OpenNextEntry(&entry2), IsOk());
ASSERT_TRUE(NULL != entry2);
entry2->Close();
}
@@ -1579,18 +1584,18 @@ void DiskCacheBackendTest::BackendDoomRecent() {
InitCache();
disk_cache::Entry *entry;
- ASSERT_EQ(net::OK, CreateEntry("first", &entry));
+ ASSERT_THAT(CreateEntry("first", &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry("second", &entry));
+ ASSERT_THAT(CreateEntry("second", &entry), IsOk());
entry->Close();
FlushQueueForTest();
AddDelay();
Time middle = Time::Now();
- ASSERT_EQ(net::OK, CreateEntry("third", &entry));
+ ASSERT_THAT(CreateEntry("third", &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry("fourth", &entry));
+ ASSERT_THAT(CreateEntry("fourth", &entry), IsOk());
entry->Close();
FlushQueueForTest();
@@ -1598,13 +1603,13 @@ void DiskCacheBackendTest::BackendDoomRecent() {
Time final = Time::Now();
ASSERT_EQ(4, cache_->GetEntryCount());
- EXPECT_EQ(net::OK, DoomEntriesSince(final));
+ EXPECT_THAT(DoomEntriesSince(final), IsOk());
ASSERT_EQ(4, cache_->GetEntryCount());
- EXPECT_EQ(net::OK, DoomEntriesSince(middle));
+ EXPECT_THAT(DoomEntriesSince(middle), IsOk());
ASSERT_EQ(2, cache_->GetEntryCount());
- ASSERT_EQ(net::OK, OpenEntry("second", &entry));
+ ASSERT_THAT(OpenEntry("second", &entry), IsOk());
entry->Close();
}
@@ -1643,13 +1648,13 @@ TEST_F(DiskCacheBackendTest, DoomEntriesSinceSparse) {
TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAllSparse) {
SetMemoryOnlyMode();
InitSparseCache(NULL, NULL);
- EXPECT_EQ(net::OK, DoomAllEntries());
+ EXPECT_THAT(DoomAllEntries(), IsOk());
EXPECT_EQ(0, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, DoomAllSparse) {
InitSparseCache(NULL, NULL);
- EXPECT_EQ(net::OK, DoomAllEntries());
+ EXPECT_THAT(DoomAllEntries(), IsOk());
EXPECT_EQ(0, cache_->GetEntryCount());
}
@@ -1657,25 +1662,25 @@ void DiskCacheBackendTest::BackendDoomBetween() {
InitCache();
disk_cache::Entry *entry;
- ASSERT_EQ(net::OK, CreateEntry("first", &entry));
+ ASSERT_THAT(CreateEntry("first", &entry), IsOk());
entry->Close();
FlushQueueForTest();
AddDelay();
Time middle_start = Time::Now();
- ASSERT_EQ(net::OK, CreateEntry("second", &entry));
+ ASSERT_THAT(CreateEntry("second", &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry("third", &entry));
+ ASSERT_THAT(CreateEntry("third", &entry), IsOk());
entry->Close();
FlushQueueForTest();
AddDelay();
Time middle_end = Time::Now();
- ASSERT_EQ(net::OK, CreateEntry("fourth", &entry));
+ ASSERT_THAT(CreateEntry("fourth", &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, OpenEntry("fourth", &entry));
+ ASSERT_THAT(OpenEntry("fourth", &entry), IsOk());
entry->Close();
FlushQueueForTest();
@@ -1683,16 +1688,16 @@ void DiskCacheBackendTest::BackendDoomBetween() {
Time final = Time::Now();
ASSERT_EQ(4, cache_->GetEntryCount());
- EXPECT_EQ(net::OK, DoomEntriesBetween(middle_start, middle_end));
+ EXPECT_THAT(DoomEntriesBetween(middle_start, middle_end), IsOk());
ASSERT_EQ(2, cache_->GetEntryCount());
- ASSERT_EQ(net::OK, OpenEntry("fourth", &entry));
+ ASSERT_THAT(OpenEntry("fourth", &entry), IsOk());
entry->Close();
- EXPECT_EQ(net::OK, DoomEntriesBetween(middle_start, final));
+ EXPECT_THAT(DoomEntriesBetween(middle_start, final), IsOk());
ASSERT_EQ(1, cache_->GetEntryCount());
- ASSERT_EQ(net::OK, OpenEntry("first", &entry));
+ ASSERT_THAT(OpenEntry("first", &entry), IsOk());
entry->Close();
}
@@ -1754,7 +1759,7 @@ void DiskCacheBackendTest::BackendCalculateSizeOfAllEntries() {
// Alternate between writing to first two streams to test that we do not
// take only one stream into account.
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ ASSERT_THAT(OpenEntry(key, &entry), IsOk());
ASSERT_EQ(count, WriteData(entry, count % 2, 0, buffer.get(), count, true));
entry->Close();
@@ -1777,7 +1782,7 @@ void DiskCacheBackendTest::BackendCalculateSizeOfAllEntries() {
disk_cache::Entry* entry;
std::string key = GenerateKey(true);
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
ASSERT_EQ(last_entry_size,
WriteData(entry, 0, 0, buffer.get(), last_entry_size, true));
entry->Close();
@@ -1791,7 +1796,7 @@ void DiskCacheBackendTest::BackendCalculateSizeOfAllEntries() {
}
// After dooming the entries, the size should be back to zero.
- ASSERT_EQ(net::OK, DoomAllEntries());
+ ASSERT_THAT(DoomAllEntries(), IsOk());
EXPECT_EQ(0, CalculateSizeOfAllEntries());
}
@@ -1978,7 +1983,7 @@ TEST_F(DiskCacheTest, WrongVersion) {
std::unique_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
cache_path_, cache_thread.task_runner(), NULL));
int rv = cache->Init(cb.callback());
- ASSERT_EQ(net::ERR_FAILED, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsError(net::ERR_FAILED));
}
// Tests that the disk cache successfully joins the control group, dropping the
@@ -2012,7 +2017,7 @@ TEST_F(DiskCacheTest, SimpleCacheControlJoin) {
NULL,
&base_cache,
cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
EXPECT_EQ(0, base_cache->GetEntryCount());
}
#endif
@@ -2041,12 +2046,12 @@ TEST_F(DiskCacheTest, SimpleCacheControlRestart) {
cache.reset(new disk_cache::BackendImpl(cache_path_,
cache_thread.task_runner(), NULL));
int rv = cache->Init(cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
EXPECT_EQ(1, cache->GetEntryCount());
disk_cache::Entry* entry = NULL;
rv = cache->OpenEntry(kExistingEntryKey, &entry, cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
EXPECT_NE(nullptr, entry);
entry->Close();
}
@@ -2082,12 +2087,12 @@ TEST_F(DiskCacheTest, SimpleCacheControlLeave) {
std::unique_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
cache_path_, cache_thread.task_runner(), NULL));
int rv = cache->Init(cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
EXPECT_EQ(1, cache->GetEntryCount());
disk_cache::Entry* entry = NULL;
rv = cache->OpenEntry(kExistingEntryKey, &entry, cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
EXPECT_NE(nullptr, entry);
entry->Close();
}
@@ -2117,7 +2122,7 @@ TEST_F(DiskCacheBackendTest, DeleteOld) {
&cache_,
cb.callback());
path.clear(); // Make sure path was captured by the previous call.
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
base::ThreadRestrictions::SetIOAllowed(prev);
cache_.reset();
EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask_));
@@ -2131,7 +2136,7 @@ void DiskCacheBackendTest::BackendInvalidEntry2() {
InitCache();
disk_cache::Entry *entry1, *entry2;
- ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
+ ASSERT_THAT(OpenEntry("the first key", &entry1), IsOk());
EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
entry1->Close();
@@ -2227,12 +2232,12 @@ TEST_F(DiskCacheBackendTest, BadNextEntry1) {
// though the index, but it is at the head of the LRU.
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry("The first key", &entry));
+ ASSERT_THAT(CreateEntry("The first key", &entry), IsOk());
entry->Close();
TrimForTest(false);
TrimForTest(false);
- ASSERT_EQ(net::OK, OpenEntry("The first key", &entry));
+ ASSERT_THAT(OpenEntry("The first key", &entry), IsOk());
entry->Close();
EXPECT_EQ(1, cache_->GetEntryCount());
}
@@ -2261,14 +2266,14 @@ TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry6) {
// The second entry is dirty, but removing it should not corrupt the list.
disk_cache::Entry* entry;
ASSERT_NE(net::OK, OpenEntry("the second key", &entry));
- ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
+ ASSERT_THAT(OpenEntry("the first key", &entry), IsOk());
// This should not delete the cache.
entry->Doom();
FlushQueueForTest();
entry->Close();
- ASSERT_EQ(net::OK, OpenEntry("some other key", &entry));
+ ASSERT_THAT(OpenEntry("some other key", &entry), IsOk());
entry->Close();
}
@@ -2282,9 +2287,9 @@ void DiskCacheBackendTest::BackendInvalidEntry7() {
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(first, &entry));
+ ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry(second, &entry));
+ ASSERT_THAT(CreateEntry(second, &entry), IsOk());
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
@@ -2326,9 +2331,9 @@ void DiskCacheBackendTest::BackendInvalidEntry8() {
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(first, &entry));
+ ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry(second, &entry));
+ ASSERT_THAT(CreateEntry(second, &entry), IsOk());
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
@@ -2346,7 +2351,7 @@ void DiskCacheBackendTest::BackendInvalidEntry8() {
// We should not delete the cache.
std::unique_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
EXPECT_EQ(1, cache_->GetEntryCount());
@@ -2373,9 +2378,9 @@ void DiskCacheBackendTest::BackendInvalidEntry9(bool eviction) {
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(first, &entry));
+ ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry(second, &entry));
+ ASSERT_THAT(CreateEntry(second, &entry), IsOk());
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
@@ -2399,7 +2404,7 @@ void DiskCacheBackendTest::BackendInvalidEntry9(bool eviction) {
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
// Now a full iteration will work, and return one entry.
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
@@ -2438,12 +2443,12 @@ void DiskCacheBackendTest::BackendInvalidEntry10(bool eviction) {
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(first, &entry));
+ ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, OpenEntry(first, &entry));
+ ASSERT_THAT(OpenEntry(first, &entry), IsOk());
EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry(second, &entry));
+ ASSERT_THAT(CreateEntry(second, &entry), IsOk());
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
@@ -2452,7 +2457,7 @@ void DiskCacheBackendTest::BackendInvalidEntry10(bool eviction) {
entry_impl->entry()->Data()->state = 0xbad;
entry_impl->entry()->Store();
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry("third", &entry));
+ ASSERT_THAT(CreateEntry("third", &entry), IsOk());
entry->Close();
EXPECT_EQ(3, cache_->GetEntryCount());
@@ -2473,9 +2478,9 @@ void DiskCacheBackendTest::BackendInvalidEntry10(bool eviction) {
// We should detect the problem through the list, but we should not delete
// the entry.
std::unique_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
EXPECT_EQ(first, entry->GetKey());
entry->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
@@ -2501,14 +2506,14 @@ void DiskCacheBackendTest::BackendInvalidEntry11(bool eviction) {
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(first, &entry));
+ ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, OpenEntry(first, &entry));
+ ASSERT_THAT(OpenEntry(first, &entry), IsOk());
EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry(second, &entry));
+ ASSERT_THAT(CreateEntry(second, &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, OpenEntry(second, &entry));
+ ASSERT_THAT(OpenEntry(second, &entry), IsOk());
EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
// Corrupt this entry.
@@ -2518,7 +2523,7 @@ void DiskCacheBackendTest::BackendInvalidEntry11(bool eviction) {
entry_impl->entry()->Data()->state = 0xbad;
entry_impl->entry()->Store();
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry("third", &entry));
+ ASSERT_THAT(CreateEntry("third", &entry), IsOk());
entry->Close();
FlushQueueForTest();
EXPECT_EQ(3, cache_->GetEntryCount());
@@ -2540,14 +2545,14 @@ void DiskCacheBackendTest::BackendInvalidEntry11(bool eviction) {
// We should detect the problem through the list, but we should not delete
// the entry, just fail the iteration.
std::unique_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
// Now a full iteration will work, and return two entries.
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
}
@@ -2571,9 +2576,9 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry12() {
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(first, &entry));
+ ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry(second, &entry));
+ ASSERT_THAT(CreateEntry(second, &entry), IsOk());
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
@@ -2582,9 +2587,9 @@ void DiskCacheBackendTest::BackendTrimInvalidEntry12() {
entry_impl->entry()->Data()->state = 0xbad;
entry_impl->entry()->Store();
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry("third", &entry));
+ ASSERT_THAT(CreateEntry("third", &entry), IsOk());
entry->Close();
- ASSERT_EQ(net::OK, CreateEntry("fourth", &entry));
+ ASSERT_THAT(CreateEntry("fourth", &entry), IsOk());
TrimForTest(true);
EXPECT_EQ(1, cache_->GetEntryCount());
entry->Close();
@@ -2608,7 +2613,7 @@ void DiskCacheBackendTest::BackendInvalidRankings2() {
disk_cache::Entry *entry1, *entry2;
EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
- ASSERT_EQ(net::OK, OpenEntry("some other key", &entry2));
+ ASSERT_THAT(OpenEntry("some other key", &entry2), IsOk());
entry2->Close();
// CheckCacheIntegrity will fail at this point.
@@ -2628,7 +2633,7 @@ TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankings2) {
void DiskCacheBackendTest::BackendInvalidRankings() {
disk_cache::Entry* entry;
std::unique_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
EXPECT_EQ(2, cache_->GetEntryCount());
@@ -2673,7 +2678,7 @@ TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankingsFailure) {
void DiskCacheBackendTest::BackendDisable() {
disk_cache::Entry *entry1, *entry2;
std::unique_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry1));
+ ASSERT_THAT(iter->OpenNextEntry(&entry1), IsOk());
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
EXPECT_EQ(0, cache_->GetEntryCount());
@@ -2773,13 +2778,13 @@ void DiskCacheBackendTest::BackendDisable3() {
disk_cache::Entry *entry1, *entry2;
std::unique_ptr<TestIterator> iter = CreateIterator();
EXPECT_EQ(2, cache_->GetEntryCount());
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry1));
+ ASSERT_THAT(iter->OpenNextEntry(&entry1), IsOk());
entry1->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
FlushQueueForTest();
- ASSERT_EQ(net::OK, CreateEntry("Something new", &entry2));
+ ASSERT_THAT(CreateEntry("Something new", &entry2), IsOk());
entry2->Close();
EXPECT_EQ(1, cache_->GetEntryCount());
@@ -2806,7 +2811,7 @@ TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess3) {
void DiskCacheBackendTest::BackendDisable4() {
disk_cache::Entry *entry1, *entry2, *entry3, *entry4;
std::unique_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry1));
+ ASSERT_THAT(iter->OpenNextEntry(&entry1), IsOk());
char key2[2000];
char key3[20000];
@@ -2814,8 +2819,8 @@ void DiskCacheBackendTest::BackendDisable4() {
CacheTestFillBuffer(key3, sizeof(key3), true);
key2[sizeof(key2) - 1] = '\0';
key3[sizeof(key3) - 1] = '\0';
- ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
- ASSERT_EQ(net::OK, CreateEntry(key3, &entry3));
+ ASSERT_THAT(CreateEntry(key2, &entry2), IsOk());
+ ASSERT_THAT(CreateEntry(key3, &entry3), IsOk());
const int kBufSize = 20000;
scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kBufSize));
@@ -2873,7 +2878,7 @@ void DiskCacheBackendTest::BackendDisabledAPI() {
disk_cache::Entry* entry1, *entry2;
std::unique_ptr<TestIterator> iter = CreateIterator();
EXPECT_EQ(2, cache_->GetEntryCount());
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry1));
+ ASSERT_THAT(iter->OpenNextEntry(&entry1), IsOk());
entry1->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
FlushQueueForTest();
@@ -2932,7 +2937,7 @@ void DiskCacheBackendTest::BackendEviction() {
for (int i = 0; i < kWriteEntryCount; ++i) {
AddDelay();
disk_cache::Entry* entry = NULL;
- ASSERT_EQ(net::OK, CreateEntry(key_prefix + base::IntToString(i), &entry));
+ ASSERT_THAT(CreateEntry(key_prefix + base::IntToString(i), &entry), IsOk());
disk_cache::ScopedEntryPtr entry_closer(entry);
EXPECT_EQ(kWriteSize,
WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
@@ -2971,7 +2976,7 @@ TEST_F(DiskCacheBackendTest, MemoryOnlyUseAfterFree) {
// Create an entry to be our sparse entry that gets written later.
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry("first parent", &entry));
+ ASSERT_THAT(CreateEntry("first parent", &entry), IsOk());
disk_cache::ScopedEntryPtr first_parent(entry);
// Create a ton of entries, and keep them open, to put the cache well above
@@ -2980,7 +2985,7 @@ TEST_F(DiskCacheBackendTest, MemoryOnlyUseAfterFree) {
std::list<disk_cache::ScopedEntryPtr> open_entries;
std::string key_prefix("prefix");
for (int i = 0; i < kTooManyEntriesCount; ++i) {
- ASSERT_EQ(net::OK, CreateEntry(key_prefix + base::IntToString(i), &entry));
+ ASSERT_THAT(CreateEntry(key_prefix + base::IntToString(i), &entry), IsOk());
EXPECT_EQ(kWriteSize,
WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
open_entries.push_back(disk_cache::ScopedEntryPtr(entry));
@@ -3001,7 +3006,7 @@ TEST_F(DiskCacheTest, Backend_UsageStatsTimer) {
cache_path_, base::ThreadTaskRunnerHandle::Get(), NULL));
ASSERT_TRUE(NULL != cache.get());
cache->SetUnitTestMode();
- ASSERT_EQ(net::OK, cache->SyncInit());
+ ASSERT_THAT(cache->SyncInit(), IsOk());
// Wait for a callback that never comes... about 2 secs :). The message loop
// has to run to allow invocation of the usage timer.
@@ -3026,7 +3031,7 @@ TEST_F(DiskCacheBackendTest, TimerNotCreated) {
TEST_F(DiskCacheBackendTest, Backend_UsageStats) {
InitCache();
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry("key", &entry));
+ ASSERT_THAT(CreateEntry("key", &entry), IsOk());
entry->Close();
FlushQueueForTest();
@@ -3055,16 +3060,16 @@ void DiskCacheBackendTest::BackendDoomAll() {
InitCache();
disk_cache::Entry *entry1, *entry2;
- ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
- ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
+ ASSERT_THAT(CreateEntry("first", &entry1), IsOk());
+ ASSERT_THAT(CreateEntry("second", &entry2), IsOk());
entry1->Close();
entry2->Close();
- ASSERT_EQ(net::OK, CreateEntry("third", &entry1));
- ASSERT_EQ(net::OK, CreateEntry("fourth", &entry2));
+ ASSERT_THAT(CreateEntry("third", &entry1), IsOk());
+ ASSERT_THAT(CreateEntry("fourth", &entry2), IsOk());
ASSERT_EQ(4, cache_->GetEntryCount());
- EXPECT_EQ(net::OK, DoomAllEntries());
+ EXPECT_THAT(DoomAllEntries(), IsOk());
ASSERT_EQ(0, cache_->GetEntryCount());
// We should stop posting tasks at some point (if we post any).
@@ -3072,10 +3077,10 @@ void DiskCacheBackendTest::BackendDoomAll() {
disk_cache::Entry *entry3, *entry4;
EXPECT_NE(net::OK, OpenEntry("third", &entry3));
- ASSERT_EQ(net::OK, CreateEntry("third", &entry3));
- ASSERT_EQ(net::OK, CreateEntry("fourth", &entry4));
+ ASSERT_THAT(CreateEntry("third", &entry3), IsOk());
+ ASSERT_THAT(CreateEntry("fourth", &entry4), IsOk());
- EXPECT_EQ(net::OK, DoomAllEntries());
+ EXPECT_THAT(DoomAllEntries(), IsOk());
ASSERT_EQ(0, cache_->GetEntryCount());
entry1->Close();
@@ -3085,16 +3090,16 @@ void DiskCacheBackendTest::BackendDoomAll() {
entry4->Close();
// Now try with all references released.
- ASSERT_EQ(net::OK, CreateEntry("third", &entry1));
- ASSERT_EQ(net::OK, CreateEntry("fourth", &entry2));
+ ASSERT_THAT(CreateEntry("third", &entry1), IsOk());
+ ASSERT_THAT(CreateEntry("fourth", &entry2), IsOk());
entry1->Close();
entry2->Close();
ASSERT_EQ(2, cache_->GetEntryCount());
- EXPECT_EQ(net::OK, DoomAllEntries());
+ EXPECT_THAT(DoomAllEntries(), IsOk());
ASSERT_EQ(0, cache_->GetEntryCount());
- EXPECT_EQ(net::OK, DoomAllEntries());
+ EXPECT_THAT(DoomAllEntries(), IsOk());
}
TEST_F(DiskCacheBackendTest, DoomAll) {
@@ -3124,10 +3129,10 @@ TEST_F(DiskCacheBackendTest, ShaderCacheOnlyDoomAll) {
// If the index size changes when we doom the cache, we should not crash.
void DiskCacheBackendTest::BackendDoomAll2() {
EXPECT_EQ(2, cache_->GetEntryCount());
- EXPECT_EQ(net::OK, DoomAllEntries());
+ EXPECT_THAT(DoomAllEntries(), IsOk());
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry("Something new", &entry));
+ ASSERT_THAT(CreateEntry("Something new", &entry), IsOk());
entry->Close();
EXPECT_EQ(1, cache_->GetEntryCount());
@@ -3174,7 +3179,7 @@ TEST_F(DiskCacheTest, MultipleInstances) {
NULL,
&cache[0],
cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
rv = disk_cache::CreateCacheBackend(net::MEDIA_CACHE,
net::CACHE_BACKEND_DEFAULT,
store2.path(),
@@ -3184,7 +3189,7 @@ TEST_F(DiskCacheTest, MultipleInstances) {
NULL,
&cache[1],
cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(cache[0].get() != NULL && cache[1].get() != NULL);
@@ -3192,7 +3197,7 @@ TEST_F(DiskCacheTest, MultipleInstances) {
disk_cache::Entry* entry;
for (int i = 0; i < kNumberOfCaches; i++) {
rv = cache[i]->CreateEntry(key, &entry, cb.callback());
- ASSERT_EQ(net::OK, cb.GetResult(rv));
+ ASSERT_THAT(cb.GetResult(rv), IsOk());
entry->Close();
}
}
@@ -3263,7 +3268,7 @@ TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {
InitCache();
std::string key("the first key");
disk_cache::Entry* entry;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
const int kSize = 200;
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
@@ -3285,7 +3290,7 @@ TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {
// Delete the second buffer, writing 10 bytes to disk.
entry->Close();
- ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ ASSERT_THAT(OpenEntry(key, &entry), IsOk());
}
entry->Close();
@@ -3365,7 +3370,7 @@ TEST_F(DiskCacheBackendTest, UpdateRankForExternalCacheHit) {
for (int i = 0; i < 2; ++i) {
std::string key = base::StringPrintf("key%d", i);
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
entry->Close();
}
@@ -3376,7 +3381,7 @@ TEST_F(DiskCacheBackendTest, UpdateRankForExternalCacheHit) {
// Make sure the older key remains.
EXPECT_EQ(1, cache_->GetEntryCount());
- ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
+ ASSERT_THAT(OpenEntry("key0", &entry), IsOk());
entry->Close();
}
@@ -3388,7 +3393,7 @@ TEST_F(DiskCacheBackendTest, ShaderCacheUpdateRankForExternalCacheHit) {
for (int i = 0; i < 2; ++i) {
std::string key = base::StringPrintf("key%d", i);
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
entry->Close();
}
@@ -3399,7 +3404,7 @@ TEST_F(DiskCacheBackendTest, ShaderCacheUpdateRankForExternalCacheHit) {
// Make sure the older key remains.
EXPECT_EQ(1, cache_->GetEntryCount());
- ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
+ ASSERT_THAT(OpenEntry("key0", &entry), IsOk());
entry->Close();
}
@@ -3493,14 +3498,14 @@ TEST_F(DiskCacheBackendTest, SimpleCacheOpenMissingFile) {
const char key[] = "the first key";
disk_cache::Entry* entry = NULL;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
ASSERT_TRUE(entry != NULL);
entry->Close();
entry = NULL;
// To make sure the file creation completed we need to call open again so that
// we block until it actually created the files.
- ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ ASSERT_THAT(OpenEntry(key, &entry), IsOk());
ASSERT_TRUE(entry != NULL);
entry->Close();
entry = NULL;
@@ -3512,7 +3517,7 @@ TEST_F(DiskCacheBackendTest, SimpleCacheOpenMissingFile) {
EXPECT_TRUE(disk_cache::DeleteCacheFile(to_delete_file));
// Failing to open the entry should delete the rest of these files.
- ASSERT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
+ ASSERT_THAT(OpenEntry(key, &entry), IsError(net::ERR_FAILED));
// Confirm the rest of the files are gone.
for (int i = 1; i < disk_cache::kSimpleEntryFileCount; ++i) {
@@ -3529,7 +3534,7 @@ TEST_F(DiskCacheBackendTest, SimpleCacheOpenBadFile) {
const char key[] = "the first key";
disk_cache::Entry* entry = NULL;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+ ASSERT_THAT(CreateEntry(key, &entry), IsOk());
disk_cache::Entry* null = NULL;
ASSERT_NE(null, entry);
entry->Close();
@@ -3537,7 +3542,7 @@ TEST_F(DiskCacheBackendTest, SimpleCacheOpenBadFile) {
// To make sure the file creation completed we need to call open again so that
// we block until it actually created the files.
- ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ ASSERT_THAT(OpenEntry(key, &entry), IsOk());
ASSERT_NE(null, entry);
entry->Close();
entry = NULL;
@@ -3555,7 +3560,7 @@ TEST_F(DiskCacheBackendTest, SimpleCacheOpenBadFile) {
EXPECT_EQ(static_cast<int>(sizeof(header)),
base::WriteFile(entry_file1_path, reinterpret_cast<char*>(&header),
sizeof(header)));
- ASSERT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
+ ASSERT_THAT(OpenEntry(key, &entry), IsError(net::ERR_FAILED));
}
// Tests that the Simple Cache Backend fails to initialize with non-matching
@@ -3567,7 +3572,7 @@ TEST_F(DiskCacheBackendTest, SimpleCacheOverBlockfileCache) {
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
- ASSERT_EQ(net::OK, CreateEntry("key", &entry));
+ ASSERT_THAT(CreateEntry("key", &entry), IsOk());
ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
entry->Close();
cache_.reset();
@@ -3596,7 +3601,7 @@ TEST_F(DiskCacheBackendTest, BlockfileCacheOverSimpleCache) {
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
- ASSERT_EQ(net::OK, CreateEntry("key", &entry));
+ ASSERT_THAT(CreateEntry("key", &entry), IsOk());
ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
entry->Close();
cache_.reset();
@@ -3642,7 +3647,7 @@ TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationBasics) {
iter = CreateIterator();
count = 0;
disk_cache::Entry* entry_opened_before;
- ASSERT_EQ(net::OK, OpenEntry(*(key_pool.begin()), &entry_opened_before));
+ ASSERT_THAT(OpenEntry(*(key_pool.begin()), &entry_opened_before), IsOk());
ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size()/2,
iter.get(),
&keys_to_match,
@@ -3698,7 +3703,7 @@ TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationCorruption) {
const std::string key = "the key";
disk_cache::Entry* corrupted_entry;
- ASSERT_EQ(net::OK, CreateEntry(key, &corrupted_entry));
+ ASSERT_THAT(CreateEntry(key, &corrupted_entry), IsOk());
ASSERT_TRUE(corrupted_entry);
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
@@ -3736,7 +3741,7 @@ TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationDestruction) {
std::unique_ptr<TestIterator> iter = CreateIterator();
disk_cache::Entry* entry = NULL;
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
EXPECT_TRUE(entry);
disk_cache::ScopedEntryPtr entry_closer(entry);
@@ -3756,7 +3761,7 @@ TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationLongKeys) {
std::string long_key(long_key_length, 'X');
key_pool.insert(long_key);
disk_cache::Entry* entry = NULL;
- ASSERT_EQ(net::OK, CreateEntry(long_key.c_str(), &entry));
+ ASSERT_THAT(CreateEntry(long_key.c_str(), &entry), IsOk());
entry->Close();
std::unique_ptr<TestIterator> iter = CreateIterator();
@@ -3782,8 +3787,8 @@ TEST_F(DiskCacheBackendTest, SimpleCacheLateDoom) {
InitCache();
disk_cache::Entry *entry1, *entry2;
- ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
- ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
+ ASSERT_THAT(CreateEntry("first", &entry1), IsOk());
+ ASSERT_THAT(CreateEntry("second", &entry2), IsOk());
entry1->Close();
// Ensure that the directory mtime is flushed to disk before serializing the
« no previous file with comments | « net/cert_net/nss_ocsp_unittest.cc ('k') | net/disk_cache/disk_cache_test_base.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698