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

- Use EXPECT_.*() where possible instead of ASSERT_.*()
- Use the argument order of EXPECT_EQ(expected, actual)
- Remove unnecessary casts
- Replace EXPECT_EQ/NE(nullptr) with EXPECT_FALSE/TRUE()
- Replace EXPECT_STREQ() with EXPECT_EQ() using WTF::String comparison

BUG=none

Review-Url: https://codereview.chromium.org/2324103002
Cr-Commit-Position: refs/heads/master@{#417550}

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

@@ -198,10 +198,10 @@ TEST(ImageResourceTest, MultipartImage)
     ResourceResponse multipartResponse(KURL(), "multipart/x-mixed-replace", 0, nullAtom, String());
     multipartResponse.setMultipartBoundary("boundary", strlen("boundary"));
     cachedImage->loader()->didReceiveResponse(nullptr, WrappedResourceResponse(multipartResponse), nullptr);
-    ASSERT_FALSE(cachedImage->resourceBuffer());
-    ASSERT_FALSE(cachedImage->hasImage());
-    ASSERT_EQ(client->imageChangedCount(), 0);
-    ASSERT_FALSE(client->notifyFinishedCalled());
+    EXPECT_FALSE(cachedImage->resourceBuffer());
+    EXPECT_FALSE(cachedImage->hasImage());
+    EXPECT_EQ(0, client->imageChangedCount());
+    EXPECT_FALSE(client->notifyFinishedCalled());
     EXPECT_EQ("multipart/x-mixed-replace", cachedImage->response().mimeType());
 
     const char firstPart[] =
@@ -209,43 +209,43 @@ TEST(ImageResourceTest, MultipartImage)
         "Content-Type: image/svg+xml\n\n";
     cachedImage->appendData(firstPart, strlen(firstPart));
     // Send the response for the first real part. No image or data buffer is created.
-    ASSERT_FALSE(cachedImage->resourceBuffer());
-    ASSERT_FALSE(cachedImage->hasImage());
-    ASSERT_EQ(client->imageChangedCount(), 0);
-    ASSERT_FALSE(client->notifyFinishedCalled());
+    EXPECT_FALSE(cachedImage->resourceBuffer());
+    EXPECT_FALSE(cachedImage->hasImage());
+    EXPECT_EQ(0, client->imageChangedCount());
+    EXPECT_FALSE(client->notifyFinishedCalled());
     EXPECT_EQ("image/svg+xml", cachedImage->response().mimeType());
 
     const char secondPart[] = "<svg xmlns='http://www.w3.org/2000/svg' width='1' height='1'><rect width='1' height='1' fill='green'/></svg>\n";
     // The first bytes arrive. The data buffer is created, but no image is created.
     cachedImage->appendData(secondPart, strlen(secondPart));
-    ASSERT_TRUE(cachedImage->resourceBuffer());
-    ASSERT_FALSE(cachedImage->hasImage());
-    ASSERT_EQ(client->imageChangedCount(), 0);
-    ASSERT_FALSE(client->notifyFinishedCalled());
+    EXPECT_TRUE(cachedImage->resourceBuffer());
+    EXPECT_FALSE(cachedImage->hasImage());
+    EXPECT_EQ(0, client->imageChangedCount());
+    EXPECT_FALSE(client->notifyFinishedCalled());
 
     // Add a client to check an assertion error doesn't happen
     // (crbug.com/630983).
     Persistent<MockImageResourceClient> client2 = new MockImageResourceClient(cachedImage);
-    ASSERT_EQ(client2->imageChangedCount(), 0);
-    ASSERT_FALSE(client2->notifyFinishedCalled());
+    EXPECT_EQ(0, client2->imageChangedCount());
+    EXPECT_FALSE(client2->notifyFinishedCalled());
 
     const char thirdPart[] = "--boundary";
     cachedImage->appendData(thirdPart, strlen(thirdPart));
     ASSERT_TRUE(cachedImage->resourceBuffer());
-    ASSERT_EQ(cachedImage->resourceBuffer()->size(), strlen(secondPart) - 1);
+    EXPECT_EQ(strlen(secondPart) - 1, cachedImage->resourceBuffer()->size());
 
     // This part finishes. The image is created, callbacks are sent, and the data buffer is cleared.
     cachedImage->loader()->didFinishLoading(nullptr, 0.0, 0);
-    ASSERT_TRUE(cachedImage->resourceBuffer());
-    ASSERT_FALSE(cachedImage->errorOccurred());
+    EXPECT_TRUE(cachedImage->resourceBuffer());
+    EXPECT_FALSE(cachedImage->errorOccurred());
     ASSERT_TRUE(cachedImage->hasImage());
-    ASSERT_FALSE(cachedImage->getImage()->isNull());
-    ASSERT_EQ(cachedImage->getImage()->width(), 1);
-    ASSERT_EQ(cachedImage->getImage()->height(), 1);
-    ASSERT_EQ(client->imageChangedCount(), 1);
-    ASSERT_TRUE(client->notifyFinishedCalled());
-    ASSERT_EQ(client2->imageChangedCount(), 1);
-    ASSERT_TRUE(client2->notifyFinishedCalled());
+    EXPECT_FALSE(cachedImage->getImage()->isNull());
+    EXPECT_EQ(1, cachedImage->getImage()->width());
+    EXPECT_EQ(1, cachedImage->getImage()->height());
+    EXPECT_EQ(1, client->imageChangedCount());
+    EXPECT_TRUE(client->notifyFinishedCalled());
+    EXPECT_EQ(1, client2->imageChangedCount());
+    EXPECT_TRUE(client2->notifyFinishedCalled());
 }
 
 TEST(ImageResourceTest, CancelOnDetach)
@@ -268,12 +268,12 @@ TEST(ImageResourceTest, CancelOnDetach)
     // The load should still be alive, but a timer should be started to cancel the load inside removeClient().
     client->removeAsClient();
     EXPECT_EQ(Resource::Pending, cachedImage->getStatus());
-    EXPECT_NE(reinterpret_cast<Resource*>(0), memoryCache()->resourceForURL(testURL));
+    EXPECT_TRUE(memoryCache()->resourceForURL(testURL));
 
     // Trigger the cancel timer, ensure the load was cancelled and the resource was evicted from the cache.
     blink::testing::runPendingTasks();
     EXPECT_EQ(Resource::LoadError, cachedImage->getStatus());
-    EXPECT_EQ(reinterpret_cast<Resource*>(0), memoryCache()->resourceForURL(testURL));
+    EXPECT_FALSE(memoryCache()->resourceForURL(testURL));
 
     Platform::current()->getURLLoaderMockFactory()->unregisterURL(testURL);
 }
@@ -292,23 +292,23 @@ TEST(ImageResourceTest, DecodedDataRemainsWhileHasClients)
     cachedImage->responseReceived(ResourceResponse(KURL(), "image/jpeg", jpeg.size(), nullAtom, String()), nullptr);
     cachedImage->appendData(reinterpret_cast<const char*>(jpeg.data()), jpeg.size());
     cachedImage->finish();
-    ASSERT_FALSE(cachedImage->errorOccurred());
+    EXPECT_FALSE(cachedImage->errorOccurred());
     ASSERT_TRUE(cachedImage->hasImage());
-    ASSERT_FALSE(cachedImage->getImage()->isNull());
-    ASSERT_TRUE(client->notifyFinishedCalled());
+    EXPECT_FALSE(cachedImage->getImage()->isNull());
+    EXPECT_TRUE(client->notifyFinishedCalled());
 
     // The prune comes when the ImageResource still has clients. The image should not be deleted.
     cachedImage->prune();
-    ASSERT_TRUE(cachedImage->isAlive());
+    EXPECT_TRUE(cachedImage->isAlive());
     ASSERT_TRUE(cachedImage->hasImage());
-    ASSERT_FALSE(cachedImage->getImage()->isNull());
+    EXPECT_FALSE(cachedImage->getImage()->isNull());
 
     // The ImageResource no longer has clients. The decoded image data should be
     // deleted by prune.
     client->removeAsClient();
     cachedImage->prune();
-    ASSERT_FALSE(cachedImage->isAlive());
-    ASSERT_TRUE(cachedImage->hasImage());
+    EXPECT_FALSE(cachedImage->isAlive());
+    EXPECT_TRUE(cachedImage->hasImage());
     // TODO(hajimehoshi): Should check cachedImage doesn't have decoded image
     // data.
 }
@@ -325,12 +325,12 @@ TEST(ImageResourceTest, UpdateBitmapImages)
     cachedImage->responseReceived(ResourceResponse(KURL(), "image/jpeg", jpeg.size(), nullAtom, String()), nullptr);
     cachedImage->appendData(reinterpret_cast<const char*>(jpeg.data()), jpeg.size());
     cachedImage->finish();
-    ASSERT_FALSE(cachedImage->errorOccurred());
+    EXPECT_FALSE(cachedImage->errorOccurred());
     ASSERT_TRUE(cachedImage->hasImage());
-    ASSERT_FALSE(cachedImage->getImage()->isNull());
-    ASSERT_EQ(client->imageChangedCount(), 2);
-    ASSERT_TRUE(client->notifyFinishedCalled());
-    ASSERT_TRUE(cachedImage->getImage()->isBitmapImage());
+    EXPECT_FALSE(cachedImage->getImage()->isNull());
+    EXPECT_EQ(2, client->imageChangedCount());
+    EXPECT_TRUE(client->notifyFinishedCalled());
+    EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, ReloadIfLoFi)
@@ -353,30 +353,30 @@ TEST(ImageResourceTest, ReloadIfLoFi)
     cachedImage->responseReceived(resourceResponse, nullptr);
     cachedImage->appendData(reinterpret_cast<const char*>(jpeg.data()), jpeg.size());
     cachedImage->finish();
-    ASSERT_FALSE(cachedImage->errorOccurred());
+    EXPECT_FALSE(cachedImage->errorOccurred());
     ASSERT_TRUE(cachedImage->hasImage());
-    ASSERT_FALSE(cachedImage->getImage()->isNull());
-    ASSERT_EQ(client->imageChangedCount(), 2);
-    ASSERT_TRUE(client->notifyFinishedCalled());
-    ASSERT_TRUE(cachedImage->getImage()->isBitmapImage());
+    EXPECT_FALSE(cachedImage->getImage()->isNull());
+    EXPECT_EQ(2, client->imageChangedCount());
+    EXPECT_TRUE(client->notifyFinishedCalled());
+    EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
     EXPECT_EQ(1, cachedImage->getImage()->width());
     EXPECT_EQ(1, cachedImage->getImage()->height());
 
     cachedImage->reloadIfLoFi(fetcher);
-    ASSERT_FALSE(cachedImage->errorOccurred());
-    ASSERT_FALSE(cachedImage->resourceBuffer());
-    ASSERT_FALSE(cachedImage->hasImage());
-    ASSERT_EQ(client->imageChangedCount(), 3);
+    EXPECT_FALSE(cachedImage->errorOccurred());
+    EXPECT_FALSE(cachedImage->resourceBuffer());
+    EXPECT_FALSE(cachedImage->hasImage());
+    EXPECT_EQ(3, client->imageChangedCount());
 
     Vector<unsigned char> jpeg2 = jpegImage2();
     cachedImage->loader()->didReceiveResponse(nullptr, WrappedResourceResponse(resourceResponse), nullptr);
     cachedImage->loader()->didReceiveData(nullptr, reinterpret_cast<const char*>(jpeg2.data()), jpeg2.size(), jpeg2.size(), jpeg2.size());
     cachedImage->loader()->didFinishLoading(nullptr, 0.0, jpeg2.size());
-    ASSERT_FALSE(cachedImage->errorOccurred());
+    EXPECT_FALSE(cachedImage->errorOccurred());
     ASSERT_TRUE(cachedImage->hasImage());
-    ASSERT_FALSE(cachedImage->getImage()->isNull());
-    ASSERT_TRUE(client->notifyFinishedCalled());
-    ASSERT_TRUE(cachedImage->getImage()->isBitmapImage());
+    EXPECT_FALSE(cachedImage->getImage()->isNull());
+    EXPECT_TRUE(client->notifyFinishedCalled());
+    EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
     EXPECT_EQ(50, cachedImage->getImage()->width());
     EXPECT_EQ(50, cachedImage->getImage()->height());
 }

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

@@ -108,9 +108,9 @@ TEST_F(MemoryCacheTest, CapacityAccounting)
     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)
@@ -126,19 +126,19 @@ TEST_F(MemoryCacheTest, VeryLargeResourceAccounting)
         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
@@ -158,23 +158,23 @@ static void TestDeadResourceEviction(Resource* resource1, Resource* resource2)
 
     // 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)
@@ -200,30 +200,30 @@ 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)
@@ -307,30 +307,30 @@ static void TestClientRemoval(Resource* resource1, Resource* 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)
@@ -430,7 +430,7 @@ 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));
 
@@ -449,12 +449,12 @@ TEST_F(MemoryCacheTest, MakeLiveAndDead)
     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)
@@ -462,7 +462,7 @@ 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));
@@ -470,7 +470,7 @@ TEST_F(MemoryCacheTest, RemoveURLFromCache)
     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));

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

@@ -54,7 +54,7 @@ TEST(RawResourceTest, DontIgnoreAcceptForCacheReuse)
     ResourceRequest pngRequest;
     pngRequest.setHTTPAccept("image/png");
 
-    ASSERT_FALSE(jpegResource->canReuse(pngRequest));
+    EXPECT_FALSE(jpegResource->canReuse(pngRequest));
 }
 
 class DummyClient final : public GarbageCollectedFinalized<DummyClient>, public RawResourceClient {
@@ -156,7 +156,7 @@ TEST(RawResourceTest, RevalidationSucceeded)
     EXPECT_FALSE(resource->isCacheValidator());
     EXPECT_EQ(200, resource->response().httpStatusCode());
     EXPECT_EQ(4u, resource->resourceBuffer()->size());
-    EXPECT_EQ(memoryCache()->resourceForURL(KURL(ParsedURLString, "data:text/html,")), resource);
+    EXPECT_EQ(resource, memoryCache()->resourceForURL(KURL(ParsedURLString, "data:text/html,")));
     memoryCache()->remove(resource);
 
     resource->removeClient(client);
@@ -185,8 +185,8 @@ TEST(RawResourceTest, RevalidationSucceededForResourceWithoutBody)
     resource->responseReceived(revalidatingResponse, nullptr);
     EXPECT_FALSE(resource->isCacheValidator());
     EXPECT_EQ(200, resource->response().httpStatusCode());
-    EXPECT_EQ(nullptr, resource->resourceBuffer());
-    EXPECT_EQ(memoryCache()->resourceForURL(KURL(ParsedURLString, "data:text/html,")), resource);
+    EXPECT_FALSE(resource->resourceBuffer());
+    EXPECT_EQ(resource, memoryCache()->resourceForURL(KURL(ParsedURLString, "data:text/html,")));
     memoryCache()->remove(resource);
 
     resource->removeClient(client);
@@ -308,7 +308,7 @@ TEST(RawResourceTest, RedirectDuringRevalidation)
     EXPECT_FALSE(resource->isCacheValidator());
     EXPECT_EQ(200, resource->response().httpStatusCode());
     EXPECT_EQ(3u, resource->resourceBuffer()->size());
-    EXPECT_EQ(memoryCache()->resourceForURL(KURL(ParsedURLString, "https://example.com/1")), resource);
+    EXPECT_EQ(resource, memoryCache()->resourceForURL(KURL(ParsedURLString, "https://example.com/1")));
 
     EXPECT_TRUE(client->called());
     EXPECT_EQ(1, client->numberOfRedirectsReceived());

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

@@ -121,8 +121,8 @@ TEST_F(ResourceFetcherTest, StartLoadAfterFrameDetach)
     ResourceFetcher* fetcher = ResourceFetcher::create(nullptr);
     FetchRequest fetchRequest = FetchRequest(ResourceRequest(secureURL), FetchInitiatorInfo());
     Resource* resource = fetcher->requestResource(fetchRequest, TestResourceFactory());
-    EXPECT_EQ(resource, static_cast<Resource*>(nullptr));
-    EXPECT_EQ(memoryCache()->resourceForURL(secureURL), static_cast<Resource*>(nullptr));
+    EXPECT_FALSE(resource);
+    EXPECT_FALSE(memoryCache()->resourceForURL(secureURL));
 
     // Start by calling startLoad() directly, rather than via requestResource().
     // This shouldn't crash.
@@ -237,7 +237,7 @@ public:
 
     void notifyFinished(Resource* resource) override
     {
-        ASSERT_EQ(m_resource, resource);
+        EXPECT_EQ(m_resource, resource);
         ResourceFetcherTestMockFetchContext* context = ResourceFetcherTestMockFetchContext::create();
         context->setCachePolicy(CachePolicyRevalidate);
         ResourceFetcher* fetcher2 = ResourceFetcher::create(context);

third_party/WebKit/Source/core/loader/FrameFetchContextTest.cpp

@@ -186,7 +186,7 @@ protected:
 
         fetchContext->upgradeInsecureRequest(fetchRequest.mutableResourceRequest());
 
-        EXPECT_STREQ(expectedURL.getString().utf8().data(), fetchRequest.resourceRequest().url().getString().utf8().data());
+        EXPECT_EQ(expectedURL.getString(), fetchRequest.resourceRequest().url().getString());
         EXPECT_EQ(expectedURL.protocol(), fetchRequest.resourceRequest().url().protocol());
         EXPECT_EQ(expectedURL.host(), fetchRequest.resourceRequest().url().host());
         EXPECT_EQ(expectedURL.port(), fetchRequest.resourceRequest().url().port());
@@ -204,13 +204,13 @@ protected:
 
         fetchContext->upgradeInsecureRequest(fetchRequest.mutableResourceRequest());
 
-        EXPECT_STREQ(shouldPrefer ? "1" : "",
-            fetchRequest.resourceRequest().httpHeaderField(HTTPNames::Upgrade_Insecure_Requests).utf8().data());
+        EXPECT_EQ(shouldPrefer ? String("1") : String(),
+            fetchRequest.resourceRequest().httpHeaderField(HTTPNames::Upgrade_Insecure_Requests));
 
         // Calling upgradeInsecureRequest more than once shouldn't affect the header.
         if (shouldPrefer) {
             fetchContext->upgradeInsecureRequest(fetchRequest.mutableResourceRequest());
-            EXPECT_STREQ("1", fetchRequest.resourceRequest().httpHeaderField(HTTPNames::Upgrade_Insecure_Requests).utf8().data());
+            EXPECT_EQ("1", fetchRequest.resourceRequest().httpHeaderField(HTTPNames::Upgrade_Insecure_Requests));
         }
     }
 
@@ -337,8 +337,8 @@ protected:
         }
         fetchContext->addClientHintsIfNecessary(fetchRequest);
 
-        EXPECT_STREQ(isPresent ? headerValue : "",
-            fetchRequest.resourceRequest().httpHeaderField(headerName).utf8().data());
+        EXPECT_EQ(isPresent ? String(headerValue) : String(),
+            fetchRequest.resourceRequest().httpHeaderField(headerName));
     }
 };
 
@@ -492,7 +492,7 @@ TEST_F(FrameFetchContextTest, PopulateRequestData)
         // Compare the populated |requestorOrigin| against |test.serializedOrigin|
         fetchContext->populateRequestData(request);
         if (strlen(test.serializedOrigin) == 0)
-            EXPECT_EQ(nullptr, request.requestorOrigin().get());
+            EXPECT_FALSE(request.requestorOrigin().get());
         else
             EXPECT_EQ(String(test.serializedOrigin), request.requestorOrigin()->toString());
 
@@ -523,19 +523,19 @@ TEST_F(FrameFetchContextTest, EnableDataSaver)
     settings->setDataSaverEnabled(true);
     ResourceRequest resourceRequest("http://www.example.com");
     fetchContext->addAdditionalRequestHeaders(resourceRequest, FetchMainResource);
-    EXPECT_STREQ("on", resourceRequest.httpHeaderField("Save-Data").utf8().data());
+    EXPECT_EQ("on", resourceRequest.httpHeaderField("Save-Data"));
 
     // Subsequent call to addAdditionalRequestHeaders should not append to the
     // save-data header.
     fetchContext->addAdditionalRequestHeaders(resourceRequest, FetchMainResource);
-    EXPECT_STREQ("on", resourceRequest.httpHeaderField("Save-Data").utf8().data());
+    EXPECT_EQ("on", resourceRequest.httpHeaderField("Save-Data"));
 }
 
 TEST_F(FrameFetchContextTest, DisabledDataSaver)
 {
     ResourceRequest resourceRequest("http://www.example.com");
     fetchContext->addAdditionalRequestHeaders(resourceRequest, FetchMainResource);
-    EXPECT_STREQ("", resourceRequest.httpHeaderField("Save-Data").utf8().data());
+    EXPECT_EQ(String(), resourceRequest.httpHeaderField("Save-Data"));
 }
 
 // Tests that when a resource with certificate errors is loaded from the
@@ -590,11 +590,11 @@ TEST_F(FrameFetchContextTest, SetIsExternalRequestForPublicDocument)
         SCOPED_TRACE(test.url);
         ResourceRequest mainRequest(test.url);
         fetchContext->addAdditionalRequestHeaders(mainRequest, FetchMainResource);
-        EXPECT_EQ(mainRequest.isExternalRequest(), test.isExternalExpectation);
+        EXPECT_EQ(test.isExternalExpectation, mainRequest.isExternalRequest());
 
         ResourceRequest subRequest(test.url);
         fetchContext->addAdditionalRequestHeaders(subRequest, FetchSubresource);
-        EXPECT_EQ(subRequest.isExternalRequest(), test.isExternalExpectation);
+        EXPECT_EQ(test.isExternalExpectation, subRequest.isExternalRequest());
     }
 }
 
@@ -638,11 +638,11 @@ TEST_F(FrameFetchContextTest, SetIsExternalRequestForPrivateDocument)
         SCOPED_TRACE(test.url);
         ResourceRequest mainRequest(test.url);
         fetchContext->addAdditionalRequestHeaders(mainRequest, FetchMainResource);
-        EXPECT_EQ(mainRequest.isExternalRequest(), test.isExternalExpectation);
+        EXPECT_EQ(test.isExternalExpectation, mainRequest.isExternalRequest());
 
         ResourceRequest subRequest(test.url);
         fetchContext->addAdditionalRequestHeaders(subRequest, FetchSubresource);
-        EXPECT_EQ(subRequest.isExternalRequest(), test.isExternalExpectation);
+        EXPECT_EQ(test.isExternalExpectation, subRequest.isExternalRequest());
     }
 }
 
@@ -685,11 +685,11 @@ TEST_F(FrameFetchContextTest, SetIsExternalRequestForLocalDocument)
     for (const auto& test : cases) {
         ResourceRequest mainRequest(test.url);
         fetchContext->addAdditionalRequestHeaders(mainRequest, FetchMainResource);
-        EXPECT_EQ(mainRequest.isExternalRequest(), test.isExternalExpectation);
+        EXPECT_EQ(test.isExternalExpectation, mainRequest.isExternalRequest());
 
         ResourceRequest subRequest(test.url);
         fetchContext->addAdditionalRequestHeaders(subRequest, FetchSubresource);
-        EXPECT_EQ(subRequest.isExternalRequest(), test.isExternalExpectation);
+        EXPECT_EQ(test.isExternalExpectation, subRequest.isExternalRequest());
     }
 }
 

third_party/WebKit/Source/core/loader/LinkLoaderTest.cpp

@@ -150,24 +150,24 @@ TEST(LinkLoaderTest, Preload)
             hrefURL,
             dummyPageHolder->document(),
             NetworkHintsMock());
-        ASSERT(dummyPageHolder->document().fetcher());
+        ASSERT_TRUE(dummyPageHolder->document().fetcher());
         HeapListHashSet<Member<Resource>>* preloads = dummyPageHolder->document().fetcher()->preloads();
         if (testCase.expectingLoad) {
             if (!preloads)
                 fprintf(stderr, "Unexpected result %s %s %s\n", testCase.href, testCase.as, testCase.type);
-            ASSERT_NE(nullptr, preloads);
+            EXPECT_TRUE(preloads);
         } else {
-            ASSERT_EQ(nullptr, preloads);
+            EXPECT_FALSE(preloads);
         }
         if (preloads) {
             if (testCase.priority == ResourceLoadPriorityUnresolved) {
-                ASSERT_EQ((unsigned)0, preloads->size());
+                EXPECT_EQ(0u, preloads->size());
             } else {
-                ASSERT_EQ((unsigned)1, preloads->size());
+                EXPECT_EQ(1u, preloads->size());
                 if (preloads->size() > 0) {
                     Resource* resource = preloads->begin().get()->get();
-                    ASSERT_EQ(testCase.priority, resource->resourceRequest().priority());
-                    ASSERT_EQ(testCase.context, resource->resourceRequest().requestContext());
+                    EXPECT_EQ(testCase.priority, resource->resourceRequest().priority());
+                    EXPECT_EQ(testCase.context, resource->resourceRequest().requestContext());
                 }
             }
             dummyPageHolder->document().fetcher()->clearPreloads();
@@ -206,8 +206,8 @@ TEST(LinkLoaderTest, DNSPrefetch)
             hrefURL,
             dummyPageHolder->document(),
             networkHints);
-        ASSERT_FALSE(networkHints.didPreconnect());
-        ASSERT_EQ(testCase.shouldLoad, networkHints.didDnsPrefetch());
+        EXPECT_FALSE(networkHints.didPreconnect());
+        EXPECT_EQ(testCase.shouldLoad, networkHints.didDnsPrefetch());
     }
 }
 
@@ -241,9 +241,9 @@ TEST(LinkLoaderTest, Preconnect)
             hrefURL,
             dummyPageHolder->document(),
             networkHints);
-        ASSERT_EQ(testCase.shouldLoad, networkHints.didPreconnect());
-        ASSERT_EQ(testCase.isHTTPS, networkHints.isHTTPS());
-        ASSERT_EQ(testCase.isCrossOrigin, networkHints.isCrossOrigin());
+        EXPECT_EQ(testCase.shouldLoad, networkHints.didPreconnect());
+        EXPECT_EQ(testCase.isHTTPS, networkHints.isHTTPS());
+        EXPECT_EQ(testCase.isCrossOrigin, networkHints.isCrossOrigin());
     }
 }