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

Side by Side Diff: net/dns/host_resolver_mojo_unittest.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 3 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 unified diff | Download patch
OLDNEW
1 // Copyright 2015 The Chromium Authors. All rights reserved. 1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/dns/host_resolver_mojo.h" 5 #include "net/dns/host_resolver_mojo.h"
6 6
7 #include <string> 7 #include <string>
8 #include <utility> 8 #include <utility>
9 9
10 #include "base/memory/ptr_util.h" 10 #include "base/memory/ptr_util.h"
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after
160 void SetUp() override { 160 void SetUp() override {
161 mock_resolver_.reset(new MockMojoHostResolver( 161 mock_resolver_.reset(new MockMojoHostResolver(
162 base::Bind(&Waiter::NotifyEvent, base::Unretained(&waiter_), 162 base::Bind(&Waiter::NotifyEvent, base::Unretained(&waiter_),
163 ConnectionErrorSource::REQUEST))); 163 ConnectionErrorSource::REQUEST)));
164 resolver_.reset(new HostResolverMojo(mock_resolver_.get())); 164 resolver_.reset(new HostResolverMojo(mock_resolver_.get()));
165 } 165 }
166 166
167 int Resolve(const HostResolver::RequestInfo& request_info, 167 int Resolve(const HostResolver::RequestInfo& request_info,
168 AddressList* result) { 168 AddressList* result) {
169 TestCompletionCallback callback; 169 TestCompletionCallback callback;
170 return callback.GetResult(resolver_->Resolve(request_info, DEFAULT_PRIORITY, 170 return callback.GetResult(
171 result, callback.callback(), 171 resolver_->Resolve(request_info, DEFAULT_PRIORITY, result,
172 &request_, BoundNetLog())); 172 callback.callback(), &request_, NetLogWithSource()));
173 } 173 }
174 174
175 std::unique_ptr<MockMojoHostResolver> mock_resolver_; 175 std::unique_ptr<MockMojoHostResolver> mock_resolver_;
176 176
177 std::unique_ptr<HostResolverMojo> resolver_; 177 std::unique_ptr<HostResolverMojo> resolver_;
178 178
179 std::unique_ptr<HostResolver::Request> request_; 179 std::unique_ptr<HostResolver::Request> request_;
180 180
181 Waiter waiter_; 181 Waiter waiter_;
182 }; 182 };
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after
252 request_info1.set_is_my_ip_address(true); 252 request_info1.set_is_my_ip_address(true);
253 HostResolver::RequestInfo request_info2( 253 HostResolver::RequestInfo request_info2(
254 HostPortPair::FromString("example.org:80")); 254 HostPortPair::FromString("example.org:80"));
255 request_info2.set_address_family(ADDRESS_FAMILY_IPV6); 255 request_info2.set_address_family(ADDRESS_FAMILY_IPV6);
256 AddressList result1; 256 AddressList result1;
257 AddressList result2; 257 AddressList result2;
258 std::unique_ptr<HostResolver::Request> request1; 258 std::unique_ptr<HostResolver::Request> request1;
259 std::unique_ptr<HostResolver::Request> request2; 259 std::unique_ptr<HostResolver::Request> request2;
260 TestCompletionCallback callback1; 260 TestCompletionCallback callback1;
261 TestCompletionCallback callback2; 261 TestCompletionCallback callback2;
262 ASSERT_EQ(ERR_IO_PENDING, 262 ASSERT_EQ(ERR_IO_PENDING, resolver_->Resolve(request_info1, DEFAULT_PRIORITY,
263 resolver_->Resolve(request_info1, DEFAULT_PRIORITY, &result1, 263 &result1, callback1.callback(),
264 callback1.callback(), &request1, BoundNetLog())); 264 &request1, NetLogWithSource()));
265 ASSERT_EQ(ERR_IO_PENDING, 265 ASSERT_EQ(ERR_IO_PENDING, resolver_->Resolve(request_info2, DEFAULT_PRIORITY,
266 resolver_->Resolve(request_info2, DEFAULT_PRIORITY, &result2, 266 &result2, callback2.callback(),
267 callback2.callback(), &request2, BoundNetLog())); 267 &request2, NetLogWithSource()));
268 EXPECT_THAT(callback1.GetResult(ERR_IO_PENDING), IsOk()); 268 EXPECT_THAT(callback1.GetResult(ERR_IO_PENDING), IsOk());
269 EXPECT_THAT(callback2.GetResult(ERR_IO_PENDING), 269 EXPECT_THAT(callback2.GetResult(ERR_IO_PENDING),
270 IsError(ERR_NAME_NOT_RESOLVED)); 270 IsError(ERR_NAME_NOT_RESOLVED));
271 ASSERT_EQ(1u, result1.size()); 271 ASSERT_EQ(1u, result1.size());
272 EXPECT_EQ(address_list[0], result1[0]); 272 EXPECT_EQ(address_list[0], result1[0]);
273 ASSERT_EQ(0u, result2.size()); 273 ASSERT_EQ(0u, result2.size());
274 274
275 ASSERT_EQ(2u, mock_resolver_->requests().size()); 275 ASSERT_EQ(2u, mock_resolver_->requests().size());
276 interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0]; 276 interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0];
277 EXPECT_EQ("example.com", info1.host.To<std::string>()); 277 EXPECT_EQ("example.com", info1.host.To<std::string>());
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
315 } 315 }
316 316
317 TEST_F(HostResolverMojoTest, Cancel) { 317 TEST_F(HostResolverMojoTest, Cancel) {
318 mock_resolver_->AddAction(HostResolverAction::RetainRequest()); 318 mock_resolver_->AddAction(HostResolverAction::RetainRequest());
319 HostResolver::RequestInfo request_info( 319 HostResolver::RequestInfo request_info(
320 HostPortPair::FromString("example.com:80")); 320 HostPortPair::FromString("example.com:80"));
321 request_info.set_address_family(ADDRESS_FAMILY_IPV6); 321 request_info.set_address_family(ADDRESS_FAMILY_IPV6);
322 AddressList result; 322 AddressList result;
323 std::unique_ptr<HostResolver::Request> request; 323 std::unique_ptr<HostResolver::Request> request;
324 resolver_->Resolve(request_info, DEFAULT_PRIORITY, &result, base::Bind(&Fail), 324 resolver_->Resolve(request_info, DEFAULT_PRIORITY, &result, base::Bind(&Fail),
325 &request, BoundNetLog()); 325 &request, NetLogWithSource());
326 request.reset(); 326 request.reset();
327 waiter_.WaitForEvent(ConnectionErrorSource::REQUEST); 327 waiter_.WaitForEvent(ConnectionErrorSource::REQUEST);
328 EXPECT_TRUE(result.empty()); 328 EXPECT_TRUE(result.empty());
329 329
330 ASSERT_EQ(1u, mock_resolver_->requests().size()); 330 ASSERT_EQ(1u, mock_resolver_->requests().size());
331 interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0]; 331 interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0];
332 EXPECT_EQ("example.com", info1.host.To<std::string>()); 332 EXPECT_EQ("example.com", info1.host.To<std::string>());
333 EXPECT_EQ(80, info1.port); 333 EXPECT_EQ(80, info1.port);
334 EXPECT_EQ(interfaces::AddressFamily::IPV6, info1.address_family); 334 EXPECT_EQ(interfaces::AddressFamily::IPV6, info1.address_family);
335 EXPECT_FALSE(info1.is_my_ip_address); 335 EXPECT_FALSE(info1.is_my_ip_address);
(...skipping 12 matching lines...) Expand all
348 EXPECT_EQ("example.com", info2.host.To<std::string>()); 348 EXPECT_EQ("example.com", info2.host.To<std::string>());
349 EXPECT_EQ(1, info2.port); 349 EXPECT_EQ(1, info2.port);
350 EXPECT_EQ(interfaces::AddressFamily::UNSPECIFIED, info2.address_family); 350 EXPECT_EQ(interfaces::AddressFamily::UNSPECIFIED, info2.address_family);
351 EXPECT_FALSE(info2.is_my_ip_address); 351 EXPECT_FALSE(info2.is_my_ip_address);
352 } 352 }
353 353
354 TEST_F(HostResolverMojoTest, ResolveFromCache_Miss) { 354 TEST_F(HostResolverMojoTest, ResolveFromCache_Miss) {
355 HostResolver::RequestInfo request_info( 355 HostResolver::RequestInfo request_info(
356 HostPortPair::FromString("example.com:8080")); 356 HostPortPair::FromString("example.com:8080"));
357 AddressList result; 357 AddressList result;
358 EXPECT_EQ(ERR_DNS_CACHE_MISS, 358 EXPECT_EQ(ERR_DNS_CACHE_MISS, resolver_->ResolveFromCache(
359 resolver_->ResolveFromCache(request_info, &result, BoundNetLog())); 359 request_info, &result, NetLogWithSource()));
360 EXPECT_TRUE(result.empty()); 360 EXPECT_TRUE(result.empty());
361 } 361 }
362 362
363 TEST_F(HostResolverMojoTest, ResolveFromCache_Hit) { 363 TEST_F(HostResolverMojoTest, ResolveFromCache_Hit) {
364 AddressList address_list; 364 AddressList address_list;
365 IPAddress address(1, 2, 3, 4); 365 IPAddress address(1, 2, 3, 4);
366 address_list.push_back(IPEndPoint(address, 12345)); 366 address_list.push_back(IPEndPoint(address, 12345));
367 address_list.push_back( 367 address_list.push_back(
368 IPEndPoint(ConvertIPv4ToIPv4MappedIPv6(address), 12345)); 368 IPEndPoint(ConvertIPv4ToIPv4MappedIPv6(address), 12345));
369 mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list)); 369 mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list));
370 HostResolver::RequestInfo request_info( 370 HostResolver::RequestInfo request_info(
371 HostPortPair::FromString("example.com:12345")); 371 HostPortPair::FromString("example.com:12345"));
372 AddressList result; 372 AddressList result;
373 ASSERT_THAT(Resolve(request_info, &result), IsOk()); 373 ASSERT_THAT(Resolve(request_info, &result), IsOk());
374 EXPECT_EQ(1u, mock_resolver_->requests().size()); 374 EXPECT_EQ(1u, mock_resolver_->requests().size());
375 375
376 result.clear(); 376 result.clear();
377 EXPECT_EQ(OK, 377 EXPECT_EQ(OK, resolver_->ResolveFromCache(request_info, &result,
378 resolver_->ResolveFromCache(request_info, &result, BoundNetLog())); 378 NetLogWithSource()));
379 ASSERT_EQ(2u, result.size()); 379 ASSERT_EQ(2u, result.size());
380 EXPECT_EQ(address_list[0], result[0]); 380 EXPECT_EQ(address_list[0], result[0]);
381 EXPECT_EQ(address_list[1], result[1]); 381 EXPECT_EQ(address_list[1], result[1]);
382 EXPECT_EQ(1u, mock_resolver_->requests().size()); 382 EXPECT_EQ(1u, mock_resolver_->requests().size());
383 } 383 }
384 384
385 TEST_F(HostResolverMojoTest, ResolveFromCache_CacheNotAllowed) { 385 TEST_F(HostResolverMojoTest, ResolveFromCache_CacheNotAllowed) {
386 AddressList address_list; 386 AddressList address_list;
387 IPAddress address(1, 2, 3, 4); 387 IPAddress address(1, 2, 3, 4);
388 address_list.push_back(IPEndPoint(address, 12345)); 388 address_list.push_back(IPEndPoint(address, 12345));
389 address_list.push_back( 389 address_list.push_back(
390 IPEndPoint(ConvertIPv4ToIPv4MappedIPv6(address), 12345)); 390 IPEndPoint(ConvertIPv4ToIPv4MappedIPv6(address), 12345));
391 mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list)); 391 mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list));
392 HostResolver::RequestInfo request_info( 392 HostResolver::RequestInfo request_info(
393 HostPortPair::FromString("example.com:12345")); 393 HostPortPair::FromString("example.com:12345"));
394 AddressList result; 394 AddressList result;
395 ASSERT_THAT(Resolve(request_info, &result), IsOk()); 395 ASSERT_THAT(Resolve(request_info, &result), IsOk());
396 EXPECT_EQ(1u, mock_resolver_->requests().size()); 396 EXPECT_EQ(1u, mock_resolver_->requests().size());
397 397
398 result.clear(); 398 result.clear();
399 request_info.set_allow_cached_response(false); 399 request_info.set_allow_cached_response(false);
400 EXPECT_EQ(ERR_DNS_CACHE_MISS, 400 EXPECT_EQ(ERR_DNS_CACHE_MISS, resolver_->ResolveFromCache(
401 resolver_->ResolveFromCache(request_info, &result, BoundNetLog())); 401 request_info, &result, NetLogWithSource()));
402 EXPECT_TRUE(result.empty()); 402 EXPECT_TRUE(result.empty());
403 } 403 }
404 404
405 TEST_F(HostResolverMojoTest, GetHostCache) { 405 TEST_F(HostResolverMojoTest, GetHostCache) {
406 EXPECT_TRUE(resolver_->GetHostCache()); 406 EXPECT_TRUE(resolver_->GetHostCache());
407 } 407 }
408 408
409 } // namespace net 409 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698