Cleanup EXPECT/ASSERTs in unit tests in core/fetch and core/loader

third_party/WebKit/Source/core/fetch/MemoryCacheTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 90 matching lines @@
 };
 
 // Verifies that setters and getters for cache capacities work correcty.
 TEST_F(MemoryCacheTest, CapacityAccounting)
 {
     const size_t sizeMax = ~static_cast<size_t>(0);
     const size_t totalCapacity = sizeMax / 4;
     const size_t minDeadCapacity = sizeMax / 16;
     const size_t maxDeadCapacity = sizeMax / 8;
     memoryCache()->setCapacities(minDeadCapacity, maxDeadCapacity, totalCapacity);
-    ASSERT_EQ(totalCapacity, memoryCache()->capacity());
-    ASSERT_EQ(minDeadCapacity, memoryCache()->minDeadCapacity());
-    ASSERT_EQ(maxDeadCapacity, memoryCache()->maxDeadCapacity());
+    EXPECT_EQ(totalCapacity, memoryCache()->capacity());
+    EXPECT_EQ(minDeadCapacity, memoryCache()->minDeadCapacity());
+    EXPECT_EQ(maxDeadCapacity, memoryCache()->maxDeadCapacity());
 }
 
 TEST_F(MemoryCacheTest, VeryLargeResourceAccounting)
 {
     const size_t sizeMax = ~static_cast<size_t>(0);
     const size_t totalCapacity = sizeMax / 4;
     const size_t minDeadCapacity = sizeMax / 16;
     const size_t maxDeadCapacity = sizeMax / 8;
     const size_t resourceSize1 = sizeMax / 16;
     const size_t resourceSize2 = sizeMax / 20;
     memoryCache()->setCapacities(minDeadCapacity, maxDeadCapacity, totalCapacity);
     FakeResource* cachedResource =
         FakeResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
     cachedResource->fakeEncodedSize(resourceSize1);
 
-    ASSERT_EQ(0u, memoryCache()->deadSize());
-    ASSERT_EQ(0u, memoryCache()->liveSize());
+    EXPECT_EQ(0u, memoryCache()->deadSize());
+    EXPECT_EQ(0u, memoryCache()->liveSize());
     memoryCache()->add(cachedResource);
-    ASSERT_EQ(cachedResource->size(), memoryCache()->deadSize());
-    ASSERT_EQ(0u, memoryCache()->liveSize());
+    EXPECT_EQ(cachedResource->size(), memoryCache()->deadSize());
+    EXPECT_EQ(0u, memoryCache()->liveSize());
 
     Persistent<MockResourceClient> client = new MockResourceClient(cachedResource);
-    ASSERT_EQ(0u, memoryCache()->deadSize());
-    ASSERT_EQ(cachedResource->size(), memoryCache()->liveSize());
+    EXPECT_EQ(0u, memoryCache()->deadSize());
+    EXPECT_EQ(cachedResource->size(), memoryCache()->liveSize());
 
     cachedResource->fakeEncodedSize(resourceSize2);
-    ASSERT_EQ(0u, memoryCache()->deadSize());
-    ASSERT_EQ(cachedResource->size(), memoryCache()->liveSize());
+    EXPECT_EQ(0u, memoryCache()->deadSize());
+    EXPECT_EQ(cachedResource->size(), memoryCache()->liveSize());
 }
 
 // Verifies that dead resources that exceed dead resource capacity are evicted
 // from cache when pruning.
 static void TestDeadResourceEviction(Resource* resource1, Resource* resource2)
 {
     memoryCache()->setDelayBeforeLiveDecodedPrune(0);
     memoryCache()->setMaxPruneDeferralDelay(0);
     const unsigned totalCapacity = 1000000;
     const unsigned minDeadCapacity = 0;
     const unsigned maxDeadCapacity = 0;
     memoryCache()->setCapacities(minDeadCapacity, maxDeadCapacity, totalCapacity);
 
     const char data[5] = "abcd";
     resource1->appendData(data, 3u);
     resource2->appendData(data, 2u);
 
     // The resource size has to be nonzero for this test to be meaningful, but
     // we do not rely on it having any particular value.
-    ASSERT_GT(resource1->size(), 0u);
-    ASSERT_GT(resource2->size(), 0u);
+    EXPECT_GT(resource1->size(), 0u);
+    EXPECT_GT(resource2->size(), 0u);
 
-    ASSERT_EQ(0u, memoryCache()->deadSize());
-    ASSERT_EQ(0u, memoryCache()->liveSize());
+    EXPECT_EQ(0u, memoryCache()->deadSize());
+    EXPECT_EQ(0u, memoryCache()->liveSize());
 
     memoryCache()->add(resource1);
-    ASSERT_EQ(resource1->size(), memoryCache()->deadSize());
-    ASSERT_EQ(0u, memoryCache()->liveSize());
+    EXPECT_EQ(resource1->size(), memoryCache()->deadSize());
+    EXPECT_EQ(0u, memoryCache()->liveSize());
 
     memoryCache()->add(resource2);
-    ASSERT_EQ(resource1->size() + resource2->size(), memoryCache()->deadSize());
-    ASSERT_EQ(0u, memoryCache()->liveSize());
+    EXPECT_EQ(resource1->size() + resource2->size(), memoryCache()->deadSize());
+    EXPECT_EQ(0u, memoryCache()->liveSize());
 
     memoryCache()->prune();
-    ASSERT_EQ(0u, memoryCache()->deadSize());
-    ASSERT_EQ(0u, memoryCache()->liveSize());
+    EXPECT_EQ(0u, memoryCache()->deadSize());
+    EXPECT_EQ(0u, memoryCache()->liveSize());
 }
 
 TEST_F(MemoryCacheTest, DeadResourceEviction_Basic)
 {
     Resource* resource1 =
         Resource::create(ResourceRequest("http://test/resource1"), Resource::Raw);
     Resource* resource2 =
         Resource::create(ResourceRequest("http://test/resource2"), Resource::Raw);
     TestDeadResourceEviction(resource1, resource2);
 }
 
 TEST_F(MemoryCacheTest, DeadResourceEviction_MultipleResourceMaps)
 {
     Resource* resource1 =
         Resource::create(ResourceRequest("http://test/resource1"), Resource::Raw);
     Resource* resource2 =
         Resource::create(ResourceRequest("http://test/resource2"), Resource::Raw);
     resource2->setCacheIdentifier("foo");
     TestDeadResourceEviction(resource1, resource2);
 }
 
 static void runTask1(Resource* live, Resource* dead)
 {
     // The resource size has to be nonzero for this test to be meaningful, but
     // we do not rely on it having any particular value.
-    ASSERT_GT(live->size(), 0u);
-    ASSERT_GT(dead->size(), 0u);
+    EXPECT_GT(live->size(), 0u);
+    EXPECT_GT(dead->size(), 0u);
 
-    ASSERT_EQ(0u, memoryCache()->deadSize());
-    ASSERT_EQ(0u, memoryCache()->liveSize());
+    EXPECT_EQ(0u, memoryCache()->deadSize());
+    EXPECT_EQ(0u, memoryCache()->liveSize());
 
     memoryCache()->add(dead);
     memoryCache()->add(live);
     memoryCache()->updateDecodedResource(live, UpdateForPropertyChange);
-    ASSERT_EQ(dead->size(), memoryCache()->deadSize());
-    ASSERT_EQ(live->size(), memoryCache()->liveSize());
-    ASSERT_GT(live->decodedSize(), 0u);
+    EXPECT_EQ(dead->size(), memoryCache()->deadSize());
+    EXPECT_EQ(live->size(), memoryCache()->liveSize());
+    EXPECT_GT(live->decodedSize(), 0u);
 
     memoryCache()->prune(); // Dead resources are pruned immediately
-    ASSERT_EQ(dead->size(), memoryCache()->deadSize());
-    ASSERT_EQ(live->size(), memoryCache()->liveSize());
-    ASSERT_GT(live->decodedSize(), 0u);
+    EXPECT_EQ(dead->size(), memoryCache()->deadSize());
+    EXPECT_EQ(live->size(), memoryCache()->liveSize());
+    EXPECT_GT(live->decodedSize(), 0u);
 }
 
 static void runTask2(unsigned liveSizeWithoutDecode)
 {
     // Next task: now, the live resource was evicted.
-    ASSERT_EQ(0u, memoryCache()->deadSize());
-    ASSERT_EQ(liveSizeWithoutDecode, memoryCache()->liveSize());
+    EXPECT_EQ(0u, memoryCache()->deadSize());
+    EXPECT_EQ(liveSizeWithoutDecode, memoryCache()->liveSize());
 }
 
 static void TestLiveResourceEvictionAtEndOfTask(Resource* cachedDeadResource, Resource* cachedLiveResource)
 {
     memoryCache()->setDelayBeforeLiveDecodedPrune(0);
     const unsigned totalCapacity = 1;
     const unsigned minDeadCapacity = 0;
     const unsigned maxDeadCapacity = 0;
     memoryCache()->setCapacities(minDeadCapacity, maxDeadCapacity, totalCapacity);
     const char data[6] = "abcde";
@@ skipping 63 matching lines @@
 
     const unsigned minDeadCapacity = 0;
     const unsigned maxDeadCapacity = ((resource1->size() + resource2->size()) / 2) - 1;
     const unsigned totalCapacity = maxDeadCapacity;
     memoryCache()->setCapacities(minDeadCapacity, maxDeadCapacity, totalCapacity);
     memoryCache()->add(resource1);
     memoryCache()->add(resource2);
     // Call prune. There is nothing to prune, but this will initialize
     // the prune timestamp, allowing future prunes to be deferred.
     memoryCache()->prune();
-    ASSERT_GT(resource1->decodedSize(), 0u);
-    ASSERT_GT(resource2->decodedSize(), 0u);
-    ASSERT_EQ(memoryCache()->deadSize(), 0u);
-    ASSERT_EQ(memoryCache()->liveSize(), resource1->size() + resource2->size());
+    EXPECT_GT(resource1->decodedSize(), 0u);
+    EXPECT_GT(resource2->decodedSize(), 0u);
+    EXPECT_EQ(0u, memoryCache()->deadSize());
+    EXPECT_EQ(resource1->size() + resource2->size(), memoryCache()->liveSize());
 
     // Removing the client from resource1 should result in all resources
     // remaining in cache since the prune is deferred.
     client1->removeAsClient();
-    ASSERT_GT(resource1->decodedSize(), 0u);
-    ASSERT_GT(resource2->decodedSize(), 0u);
-    ASSERT_EQ(memoryCache()->deadSize(), resource1->size());
-    ASSERT_EQ(memoryCache()->liveSize(), resource2->size());
-    ASSERT_TRUE(memoryCache()->contains(resource1));
-    ASSERT_TRUE(memoryCache()->contains(resource2));
+    EXPECT_GT(resource1->decodedSize(), 0u);
+    EXPECT_GT(resource2->decodedSize(), 0u);
+    EXPECT_EQ(resource1->size(), memoryCache()->deadSize());
+    EXPECT_EQ(resource2->size(), memoryCache()->liveSize());
+    EXPECT_TRUE(memoryCache()->contains(resource1));
+    EXPECT_TRUE(memoryCache()->contains(resource2));
 
     // Removing the client from resource2 should result in immediate
     // eviction of resource2 because we are over the prune deferral limit.
     client2->removeAsClient();
-    ASSERT_GT(resource1->decodedSize(), 0u);
-    ASSERT_GT(resource2->decodedSize(), 0u);
-    ASSERT_EQ(memoryCache()->deadSize(), resource1->size());
-    ASSERT_EQ(memoryCache()->liveSize(), 0u);
-    ASSERT_TRUE(memoryCache()->contains(resource1));
-    ASSERT_FALSE(memoryCache()->contains(resource2));
+    EXPECT_GT(resource1->decodedSize(), 0u);
+    EXPECT_GT(resource2->decodedSize(), 0u);
+    EXPECT_EQ(resource1->size(), memoryCache()->deadSize());
+    EXPECT_EQ(0u, memoryCache()->liveSize());
+    EXPECT_TRUE(memoryCache()->contains(resource1));
+    EXPECT_FALSE(memoryCache()->contains(resource2));
 }
 
 TEST_F(MemoryCacheTest, ClientRemoval_Basic)
 {
     Resource* resource1 =
         FakeDecodedResource::create(ResourceRequest("http://foo.com"), Resource::Raw);
     Resource* resource2 =
         FakeDecodedResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
     TestClientRemoval(resource1, resource2);
 }
@@ skipping 79 matching lines @@
     memoryCache()->evictResources();
     EXPECT_FALSE(memoryCache()->contains(resource1));
     EXPECT_FALSE(memoryCache()->contains(resource3));
 }
 
 TEST_F(MemoryCacheTest, FragmentIdentifier)
 {
     const KURL url1 = KURL(ParsedURLString, "http://test/resource#foo");
     FakeResource* resource = FakeResource::create(ResourceRequest(url1), Resource::Raw);
     memoryCache()->add(resource);
-    ASSERT_TRUE(memoryCache()->contains(resource));
+    EXPECT_TRUE(memoryCache()->contains(resource));
 
     EXPECT_EQ(resource, memoryCache()->resourceForURL(url1));
 
     const KURL url2 = MemoryCache::removeFragmentIdentifierIfNeeded(url1);
     EXPECT_EQ(resource, memoryCache()->resourceForURL(url2));
 }
 
 TEST_F(MemoryCacheTest, MakeLiveAndDead)
 {
     FakeResource* resource = FakeResource::create(ResourceRequest("http://test/resource"), Resource::Raw);
     const char data[6] = "abcde";
     resource->appendData(data, 5u);
     memoryCache()->add(resource);
 
     const size_t deadSize = memoryCache()->deadSize();
     const size_t liveSize = memoryCache()->liveSize();
 
     memoryCache()->makeLive(resource);
-    ASSERT_EQ(deadSize, memoryCache()->deadSize() + resource->size());
-    ASSERT_EQ(liveSize, memoryCache()->liveSize() - resource->size());
+    EXPECT_EQ(deadSize, memoryCache()->deadSize() + resource->size());
+    EXPECT_EQ(liveSize, memoryCache()->liveSize() - resource->size());
 
     memoryCache()->makeDead(resource);
-    ASSERT_EQ(deadSize, memoryCache()->deadSize());
-    ASSERT_EQ(liveSize, memoryCache()->liveSize());
+    EXPECT_EQ(deadSize, memoryCache()->deadSize());
+    EXPECT_EQ(liveSize, memoryCache()->liveSize());
 }
 
 TEST_F(MemoryCacheTest, RemoveURLFromCache)
 {
     const KURL url1 = KURL(ParsedURLString, "http://test/resource1");
     FakeResource* resource1 = FakeResource::create(ResourceRequest(url1), Resource::Raw);
     memoryCache()->add(resource1);
-    ASSERT_TRUE(memoryCache()->contains(resource1));
+    EXPECT_TRUE(memoryCache()->contains(resource1));
 
     memoryCache()->removeURLFromCache(url1);
     EXPECT_FALSE(memoryCache()->contains(resource1));
 
     const KURL url2 = KURL(ParsedURLString, "http://test/resource2#foo");
     FakeResource* resource2 = FakeResource::create(ResourceRequest(url2), Resource::Raw);
     memoryCache()->add(resource2);
-    ASSERT_TRUE(memoryCache()->contains(resource2));
+    EXPECT_TRUE(memoryCache()->contains(resource2));
 
     memoryCache()->removeURLFromCache(url2);
     EXPECT_FALSE(memoryCache()->contains(resource2));
 }
 
 } // namespace blink