net/dns/host_resolver_impl_unittest.cc - Issue 2109503009: Refactor net tests to use GMock matchers for checking net::Error results

Unified Diff: net/dns/host_resolver_impl_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

Index: net/dns/host_resolver_impl_unittest.cc

diff --git a/net/dns/host_resolver_impl_unittest.cc b/net/dns/host_resolver_impl_unittest.cc

index b89db66b4ff6b02f66e35c1b686f9b34bd1ef232..58065c6bb3d4ae0a42168b6d8d3204c331656273 100644

--- a/net/dns/host_resolver_impl_unittest.cc

+++ b/net/dns/host_resolver_impl_unittest.cc

@@ -33,8 +33,13 @@

#include "net/dns/dns_test_util.h"

#include "net/dns/mock_host_resolver.h"

#include "net/log/test_net_log.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;

namespace net {

namespace {

@@ -234,7 +239,7 @@ class Request {

&handle_,

BoundNetLog());

if (!list_.empty())

- EXPECT_EQ(OK, result_);

+ EXPECT_THAT(result_, IsOk());

return result_;

}

@@ -307,12 +312,12 @@ class Request {

private:

void OnComplete(int rv) {

EXPECT_TRUE(pending());

- EXPECT_EQ(ERR_IO_PENDING, result_);

+ EXPECT_THAT(result_, IsError(ERR_IO_PENDING));

EXPECT_NE(ERR_IO_PENDING, rv);

result_ = rv;

handle_ = NULL;

if (!list_.empty()) {

- EXPECT_EQ(OK, result_);

+ EXPECT_THAT(result_, IsOk());

EXPECT_EQ(info_.port(), list_.front().port());

}

if (handler_)

@@ -631,8 +636,8 @@ TEST_F(HostResolverImplTest, AsynchronousLookup) {

proc_->SignalMultiple(1u);

Request* req = CreateRequest("just.testing", 80);

- EXPECT_EQ(ERR_IO_PENDING, req->Resolve());

- EXPECT_EQ(OK, req->WaitForResult());

+ EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(req->WaitForResult(), IsOk());

EXPECT_TRUE(req->HasOneAddress("192.168.1.42", 80));

@@ -648,41 +653,41 @@ TEST_F(HostResolverImplTest, LocalhostLookup) {

proc_->AddRuleForAllFamilies("localhost.", "192.168.1.42");

Request* req0 = CreateRequest("foo.localhost", 80);

- EXPECT_EQ(OK, req0->Resolve());

+ EXPECT_THAT(req0->Resolve(), IsOk());

EXPECT_TRUE(req0->HasAddress("127.0.0.1", 80));

EXPECT_TRUE(req0->HasAddress("::1", 80));

Request* req1 = CreateRequest("localhost", 80);

- EXPECT_EQ(OK, req1->Resolve());

+ EXPECT_THAT(req1->Resolve(), IsOk());

EXPECT_TRUE(req1->HasAddress("127.0.0.1", 80));

EXPECT_TRUE(req1->HasAddress("::1", 80));

Request* req2 = CreateRequest("localhost.", 80);

- EXPECT_EQ(OK, req2->Resolve());

+ EXPECT_THAT(req2->Resolve(), IsOk());

EXPECT_TRUE(req2->HasAddress("127.0.0.1", 80));

EXPECT_TRUE(req2->HasAddress("::1", 80));

}

TEST_F(HostResolverImplTest, LocalhostIPV4IPV6Lookup) {

Request* req1 = CreateRequest("localhost6", 80, MEDIUM, ADDRESS_FAMILY_IPV4);

- EXPECT_EQ(OK, req1->Resolve());

+ EXPECT_THAT(req1->Resolve(), IsOk());

EXPECT_EQ(0u, req1->NumberOfAddresses());

Request* req2 = CreateRequest("localhost6", 80, MEDIUM, ADDRESS_FAMILY_IPV6);

- EXPECT_EQ(OK, req2->Resolve());

+ EXPECT_THAT(req2->Resolve(), IsOk());

EXPECT_TRUE(req2->HasOneAddress("::1", 80));

Request* req3 =

CreateRequest("localhost6", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);

- EXPECT_EQ(OK, req3->Resolve());

+ EXPECT_THAT(req3->Resolve(), IsOk());

EXPECT_TRUE(req3->HasOneAddress("::1", 80));

Request* req4 = CreateRequest("localhost", 80, MEDIUM, ADDRESS_FAMILY_IPV4);

- EXPECT_EQ(OK, req4->Resolve());

+ EXPECT_THAT(req4->Resolve(), IsOk());

EXPECT_TRUE(req4->HasOneAddress("127.0.0.1", 80));

Request* req5 = CreateRequest("localhost", 80, MEDIUM, ADDRESS_FAMILY_IPV6);

- EXPECT_EQ(OK, req5->Resolve());

+ EXPECT_THAT(req5->Resolve(), IsOk());

EXPECT_TRUE(req5->HasOneAddress("::1", 80));

}

@@ -697,7 +702,7 @@ TEST_F(HostResolverImplTest, ResolveIPLiteralWithHostResolverSystemOnly) {

info_bypass.set_host_resolver_flags(HOST_RESOLVER_SYSTEM_ONLY);

Request* req = CreateRequest(info_bypass, MEDIUM);

- EXPECT_EQ(OK, req->Resolve());

+ EXPECT_THAT(req->Resolve(), IsOk());

EXPECT_TRUE(req->HasAddress(kIpLiteral, 80));

}

@@ -707,8 +712,8 @@ TEST_F(HostResolverImplTest, EmptyListMeansNameNotResolved) {

proc_->SignalMultiple(1u);

Request* req = CreateRequest("just.testing", 80);

- EXPECT_EQ(ERR_IO_PENDING, req->Resolve());

- EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());

+ EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(req->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));

EXPECT_EQ(0u, req->NumberOfAddresses());

EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);

}

@@ -719,18 +724,18 @@ TEST_F(HostResolverImplTest, FailedAsynchronousLookup) {

proc_->SignalMultiple(1u);

Request* req = CreateRequest("just.testing", 80);

- EXPECT_EQ(ERR_IO_PENDING, req->Resolve());

- EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());

+ EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(req->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));

EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);

// Also test that the error is not cached.

- EXPECT_EQ(ERR_DNS_CACHE_MISS, req->ResolveFromCache());

+ EXPECT_THAT(req->ResolveFromCache(), IsError(ERR_DNS_CACHE_MISS));

}

TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) {

Request* req0 = CreateRequest("just.testing", 80);

- EXPECT_EQ(ERR_IO_PENDING, req0->Resolve());

+ EXPECT_THAT(req0->Resolve(), IsError(ERR_IO_PENDING));

EXPECT_TRUE(proc_->WaitFor(1u));

@@ -742,11 +747,11 @@ TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) {

// To ensure there was no spurious callback, complete with a new resolver.

CreateResolver();

Request* req1 = CreateRequest("just.testing", 80);

- EXPECT_EQ(ERR_IO_PENDING, req1->Resolve());

+ EXPECT_THAT(req1->Resolve(), IsError(ERR_IO_PENDING));

proc_->SignalMultiple(2u);

- EXPECT_EQ(OK, req1->WaitForResult());

+ EXPECT_THAT(req1->WaitForResult(), IsOk());

// This request was canceled.

EXPECT_FALSE(req0->completed());

@@ -761,7 +766,7 @@ TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) {

TEST_F(HostResolverImplTest, MAYBE_NumericIPv4Address) {

// Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.

Request* req = CreateRequest("127.1.2.3", 5555);

- EXPECT_EQ(OK, req->Resolve());

+ EXPECT_THAT(req->Resolve(), IsOk());

EXPECT_TRUE(req->HasOneAddress("127.1.2.3", 5555));

}

@@ -776,7 +781,7 @@ TEST_F(HostResolverImplTest, MAYBE_NumericIPv6Address) {

// Resolve a plain IPv6 address. Don't worry about [brackets], because

// the caller should have removed them.

Request* req = CreateRequest("2001:db8::1", 5555);

- EXPECT_EQ(OK, req->Resolve());

+ EXPECT_THAT(req->Resolve(), IsOk());

EXPECT_TRUE(req->HasOneAddress("2001:db8::1", 5555));

}

@@ -789,7 +794,7 @@ TEST_F(HostResolverImplTest, MAYBE_NumericIPv6Address) {

#endif

TEST_F(HostResolverImplTest, MAYBE_EmptyHost) {

Request* req = CreateRequest(std::string(), 5555);

- EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());

+ EXPECT_THAT(req->Resolve(), IsError(ERR_NAME_NOT_RESOLVED));

}

#if defined(THREAD_SANITIZER)

@@ -804,7 +809,7 @@ TEST_F(HostResolverImplTest, MAYBE_EmptyHost) {

TEST_F(HostResolverImplTest, MAYBE_EmptyDotsHost) {

for (int i = 0; i < 16; ++i) {

Request* req = CreateRequest(std::string(i, '.'), 5555);

- EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());

+ EXPECT_THAT(req->Resolve(), IsError(ERR_NAME_NOT_RESOLVED));

}

@@ -818,17 +823,17 @@ TEST_F(HostResolverImplTest, MAYBE_EmptyDotsHost) {

#endif

TEST_F(HostResolverImplTest, MAYBE_LongHost) {

Request* req = CreateRequest(std::string(4097, 'a'), 5555);

- EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());

+ EXPECT_THAT(req->Resolve(), IsError(ERR_NAME_NOT_RESOLVED));

}

TEST_F(HostResolverImplTest, DeDupeRequests) {

// Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is

// blocked, these should all pile up until we signal it.

- EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());

- EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 80)->Resolve());

- EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 81)->Resolve());

- EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 82)->Resolve());

- EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());

+ EXPECT_THAT(CreateRequest("a", 80)->Resolve(), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(CreateRequest("b", 80)->Resolve(), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(CreateRequest("b", 81)->Resolve(), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(CreateRequest("a", 82)->Resolve(), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(CreateRequest("b", 83)->Resolve(), IsError(ERR_IO_PENDING));

proc_->SignalMultiple(2u); // One for "a", one for "b".

@@ -838,11 +843,11 @@ TEST_F(HostResolverImplTest, DeDupeRequests) {

}

TEST_F(HostResolverImplTest, CancelMultipleRequests) {