1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "net/socket/socket_test_util.h" 6 7 #include "testing/platform_test.h" 8 #include "testing/gtest/include/gtest/gtest.h" 9 10 //----------------------------------------------------------------------------- 11 12 namespace { 13 14 static const char kMsg1[] = "\0hello!\xff"; 15 static const int kLen1 = arraysize(kMsg1); 16 static const char kMsg2[] = "\012345678\0"; 17 static const int kLen2 = arraysize(kMsg2); 18 static const char kMsg3[] = "bye!"; 19 static const int kLen3 = arraysize(kMsg3); 20 21 } // anonymous namespace 22 23 namespace net { 24 25 class DeterministicSocketDataTest : public PlatformTest { 26 public: 27 DeterministicSocketDataTest(); 28 29 virtual void TearDown(); 30 31 protected: 32 void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes, 33 size_t writes_count); 34 35 void AssertSyncReadEquals(const char* data, int len); 36 void AssertAsyncReadEquals(const char* data, int len); 37 void AssertReadReturns(const char* data, int len, int rv); 38 void AssertReadBufferEquals(const char* data, int len); 39 40 void AssertSyncWriteEquals(const char* data, int len); 41 void AssertAsyncWriteEquals(const char* data, int len); 42 void AssertWriteReturns(const char* data, int len, int rv); 43 44 TestCompletionCallback read_callback_; 45 TestCompletionCallback write_callback_; 46 ClientSocket* sock_; 47 scoped_refptr<DeterministicSocketData> data_; 48 49 private: 50 scoped_refptr<IOBuffer> read_buf_; 51 MockConnect connect_data_; 52 53 GURL url_; 54 HostPortPair endpoint_; 55 scoped_refptr<TransportSocketParams> tcp_params_; 56 ClientSocketPoolHistograms histograms_; 57 DeterministicMockClientSocketFactory socket_factory_; 58 MockTransportClientSocketPool socket_pool_; 59 ClientSocketHandle connection_; 60 61 DISALLOW_COPY_AND_ASSIGN(DeterministicSocketDataTest); 62 }; 63 64 DeterministicSocketDataTest::DeterministicSocketDataTest() 65 : read_callback_(), 66 write_callback_(), 67 sock_(NULL), 68 data_(NULL), 69 read_buf_(NULL), 70 connect_data_(false, OK), 71 url_("https://www.google.com"), 72 endpoint_("www.google.com", 443), 73 tcp_params_(new TransportSocketParams(endpoint_, 74 LOWEST, 75 url_, 76 false, 77 false)), 78 histograms_(""), 79 socket_pool_(10, 10, &histograms_, &socket_factory_) { 80 } 81 82 void DeterministicSocketDataTest::TearDown() { 83 // Empty the current queue. 84 MessageLoop::current()->RunAllPending(); 85 PlatformTest::TearDown(); 86 } 87 88 void DeterministicSocketDataTest::Initialize(MockRead* reads, 89 size_t reads_count, 90 MockWrite* writes, 91 size_t writes_count) { 92 data_ = new DeterministicSocketData(reads, reads_count, writes, writes_count); 93 data_->set_connect_data(connect_data_); 94 socket_factory_.AddSocketDataProvider(data_.get()); 95 96 // Perform the TCP connect 97 EXPECT_EQ(OK, 98 connection_.Init(endpoint_.ToString(), 99 tcp_params_, 100 LOWEST, 101 NULL, 102 reinterpret_cast<TransportClientSocketPool*>(&socket_pool_), 103 BoundNetLog())); 104 sock_ = connection_.socket(); 105 } 106 107 void DeterministicSocketDataTest::AssertSyncReadEquals(const char* data, 108 int len) { 109 // Issue the read, which will complete immediately 110 AssertReadReturns(data, len, len); 111 AssertReadBufferEquals(data, len); 112 } 113 114 void DeterministicSocketDataTest::AssertAsyncReadEquals(const char* data, 115 int len) { 116 // Issue the read, which will be completed asynchronously 117 AssertReadReturns(data, len, ERR_IO_PENDING); 118 119 EXPECT_FALSE(read_callback_.have_result()); 120 EXPECT_TRUE(sock_->IsConnected()); 121 data_->RunFor(1); // Runs 1 step, to cause the callbacks to be invoked 122 123 // Now the read should complete 124 ASSERT_EQ(len, read_callback_.WaitForResult()); 125 AssertReadBufferEquals(data, len); 126 } 127 128 void DeterministicSocketDataTest::AssertReadReturns(const char* data, 129 int len, int rv) { 130 read_buf_ = new IOBuffer(len); 131 ASSERT_EQ(rv, sock_->Read(read_buf_, len, &read_callback_)); 132 } 133 134 void DeterministicSocketDataTest::AssertReadBufferEquals(const char* data, 135 int len) { 136 ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len)); 137 } 138 139 void DeterministicSocketDataTest::AssertSyncWriteEquals(const char* data, 140 int len) { 141 scoped_refptr<IOBuffer> buf(new IOBuffer(len)); 142 memcpy(buf->data(), data, len); 143 144 // Issue the write, which will complete immediately 145 ASSERT_EQ(len, sock_->Write(buf, len, &write_callback_)); 146 } 147 148 void DeterministicSocketDataTest::AssertAsyncWriteEquals(const char* data, 149 int len) { 150 // Issue the read, which will be completed asynchronously 151 AssertWriteReturns(data, len, ERR_IO_PENDING); 152 153 EXPECT_FALSE(read_callback_.have_result()); 154 EXPECT_TRUE(sock_->IsConnected()); 155 data_->RunFor(1); // Runs 1 step, to cause the callbacks to be invoked 156 157 ASSERT_EQ(len, write_callback_.WaitForResult()); 158 } 159 160 void DeterministicSocketDataTest::AssertWriteReturns(const char* data, 161 int len, int rv) { 162 scoped_refptr<IOBuffer> buf(new IOBuffer(len)); 163 memcpy(buf->data(), data, len); 164 165 // Issue the read, which will complete asynchronously 166 ASSERT_EQ(rv, sock_->Write(buf, len, &write_callback_)); 167 } 168 169 // ----------- Read 170 171 TEST_F(DeterministicSocketDataTest, SingleSyncReadWhileStopped) { 172 MockRead reads[] = { 173 MockRead(false, kMsg1, kLen1, 0), // Sync Read 174 MockRead(false, 0, 1), // EOF 175 }; 176 177 Initialize(reads, arraysize(reads), NULL, 0); 178 179 data_->SetStopped(true); 180 AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED); 181 } 182 183 TEST_F(DeterministicSocketDataTest, SingleSyncReadTooEarly) { 184 MockRead reads[] = { 185 MockRead(false, kMsg1, kLen1, 1), // Sync Read 186 MockRead(false, 0, 2), // EOF 187 }; 188 189 Initialize(reads, arraysize(reads), NULL, 0); 190 191 data_->StopAfter(2); 192 ASSERT_FALSE(data_->stopped()); 193 AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED); 194 } 195 196 TEST_F(DeterministicSocketDataTest, SingleSyncRead) { 197 MockRead reads[] = { 198 MockRead(false, kMsg1, kLen1, 0), // Sync Read 199 MockRead(false, 0, 1), // EOF 200 }; 201 202 Initialize(reads, arraysize(reads), NULL, 0); 203 // Make sure we don't stop before we've read all the data 204 data_->StopAfter(1); 205 AssertSyncReadEquals(kMsg1, kLen1); 206 } 207 208 TEST_F(DeterministicSocketDataTest, MultipleSyncReads) { 209 MockRead reads[] = { 210 MockRead(false, kMsg1, kLen1, 0), // Sync Read 211 MockRead(false, kMsg2, kLen2, 1), // Sync Read 212 MockRead(false, kMsg3, kLen3, 2), // Sync Read 213 MockRead(false, kMsg3, kLen3, 3), // Sync Read 214 MockRead(false, kMsg2, kLen2, 4), // Sync Read 215 MockRead(false, kMsg3, kLen3, 5), // Sync Read 216 MockRead(false, kMsg1, kLen1, 6), // Sync Read 217 MockRead(false, 0, 7), // EOF 218 }; 219 220 Initialize(reads, arraysize(reads), NULL, 0); 221 222 // Make sure we don't stop before we've read all the data 223 data_->StopAfter(10); 224 AssertSyncReadEquals(kMsg1, kLen1); 225 AssertSyncReadEquals(kMsg2, kLen2); 226 AssertSyncReadEquals(kMsg3, kLen3); 227 AssertSyncReadEquals(kMsg3, kLen3); 228 AssertSyncReadEquals(kMsg2, kLen2); 229 AssertSyncReadEquals(kMsg3, kLen3); 230 AssertSyncReadEquals(kMsg1, kLen1); 231 } 232 233 TEST_F(DeterministicSocketDataTest, SingleAsyncRead) { 234 MockRead reads[] = { 235 MockRead(true, kMsg1, kLen1, 0), // Async Read 236 MockRead(false, 0, 1), // EOF 237 }; 238 239 Initialize(reads, arraysize(reads), NULL, 0); 240 241 AssertAsyncReadEquals(kMsg1, kLen1); 242 } 243 244 TEST_F(DeterministicSocketDataTest, MultipleAsyncReads) { 245 MockRead reads[] = { 246 MockRead(true, kMsg1, kLen1, 0), // Async Read 247 MockRead(true, kMsg2, kLen2, 1), // Async Read 248 MockRead(true, kMsg3, kLen3, 2), // Async Read 249 MockRead(true, kMsg3, kLen3, 3), // Async Read 250 MockRead(true, kMsg2, kLen2, 4), // Async Read 251 MockRead(true, kMsg3, kLen3, 5), // Async Read 252 MockRead(true, kMsg1, kLen1, 6), // Async Read 253 MockRead(false, 0, 7), // EOF 254 }; 255 256 Initialize(reads, arraysize(reads), NULL, 0); 257 258 AssertAsyncReadEquals(kMsg1, kLen1); 259 AssertAsyncReadEquals(kMsg2, kLen2); 260 AssertAsyncReadEquals(kMsg3, kLen3); 261 AssertAsyncReadEquals(kMsg3, kLen3); 262 AssertAsyncReadEquals(kMsg2, kLen2); 263 AssertAsyncReadEquals(kMsg3, kLen3); 264 AssertAsyncReadEquals(kMsg1, kLen1); 265 } 266 267 TEST_F(DeterministicSocketDataTest, MixedReads) { 268 MockRead reads[] = { 269 MockRead(false, kMsg1, kLen1, 0), // Sync Read 270 MockRead(true, kMsg2, kLen2, 1), // Async Read 271 MockRead(false, kMsg3, kLen3, 2), // Sync Read 272 MockRead(true, kMsg3, kLen3, 3), // Async Read 273 MockRead(false, kMsg2, kLen2, 4), // Sync Read 274 MockRead(true, kMsg3, kLen3, 5), // Async Read 275 MockRead(false, kMsg1, kLen1, 6), // Sync Read 276 MockRead(false, 0, 7), // EOF 277 }; 278 279 Initialize(reads, arraysize(reads), NULL, 0); 280 281 data_->StopAfter(1); 282 AssertSyncReadEquals(kMsg1, kLen1); 283 AssertAsyncReadEquals(kMsg2, kLen2); 284 data_->StopAfter(1); 285 AssertSyncReadEquals(kMsg3, kLen3); 286 AssertAsyncReadEquals(kMsg3, kLen3); 287 data_->StopAfter(1); 288 AssertSyncReadEquals(kMsg2, kLen2); 289 AssertAsyncReadEquals(kMsg3, kLen3); 290 data_->StopAfter(1); 291 AssertSyncReadEquals(kMsg1, kLen1); 292 } 293 294 // ----------- Write 295 296 TEST_F(DeterministicSocketDataTest, SingleSyncWriteWhileStopped) { 297 MockWrite writes[] = { 298 MockWrite(false, kMsg1, kLen1, 0), // Sync Read 299 }; 300 301 Initialize(NULL, 0, writes, arraysize(writes)); 302 303 data_->SetStopped(true); 304 AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED); 305 } 306 307 TEST_F(DeterministicSocketDataTest, SingleSyncWriteTooEarly) { 308 MockWrite writes[] = { 309 MockWrite(false, kMsg1, kLen1, 1), // Sync Write 310 }; 311 312 Initialize(NULL, 0, writes, arraysize(writes)); 313 314 data_->StopAfter(2); 315 ASSERT_FALSE(data_->stopped()); 316 AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED); 317 } 318 319 TEST_F(DeterministicSocketDataTest, SingleSyncWrite) { 320 MockWrite writes[] = { 321 MockWrite(false, kMsg1, kLen1, 0), // Sync Write 322 }; 323 324 Initialize(NULL, 0, writes, arraysize(writes)); 325 326 // Make sure we don't stop before we've read all the data 327 data_->StopAfter(1); 328 AssertSyncWriteEquals(kMsg1, kLen1); 329 } 330 331 TEST_F(DeterministicSocketDataTest, MultipleSyncWrites) { 332 MockWrite writes[] = { 333 MockWrite(false, kMsg1, kLen1, 0), // Sync Write 334 MockWrite(false, kMsg2, kLen2, 1), // Sync Write 335 MockWrite(false, kMsg3, kLen3, 2), // Sync Write 336 MockWrite(false, kMsg3, kLen3, 3), // Sync Write 337 MockWrite(false, kMsg2, kLen2, 4), // Sync Write 338 MockWrite(false, kMsg3, kLen3, 5), // Sync Write 339 MockWrite(false, kMsg1, kLen1, 6), // Sync Write 340 }; 341 342 Initialize(NULL, 0, writes, arraysize(writes)); 343 344 // Make sure we don't stop before we've read all the data 345 data_->StopAfter(10); 346 AssertSyncWriteEquals(kMsg1, kLen1); 347 AssertSyncWriteEquals(kMsg2, kLen2); 348 AssertSyncWriteEquals(kMsg3, kLen3); 349 AssertSyncWriteEquals(kMsg3, kLen3); 350 AssertSyncWriteEquals(kMsg2, kLen2); 351 AssertSyncWriteEquals(kMsg3, kLen3); 352 AssertSyncWriteEquals(kMsg1, kLen1); 353 } 354 355 TEST_F(DeterministicSocketDataTest, SingleAsyncWrite) { 356 MockWrite writes[] = { 357 MockWrite(true, kMsg1, kLen1, 0), // Async Write 358 }; 359 360 Initialize(NULL, 0, writes, arraysize(writes)); 361 362 AssertAsyncWriteEquals(kMsg1, kLen1); 363 } 364 365 TEST_F(DeterministicSocketDataTest, MultipleAsyncWrites) { 366 MockWrite writes[] = { 367 MockWrite(true, kMsg1, kLen1, 0), // Async Write 368 MockWrite(true, kMsg2, kLen2, 1), // Async Write 369 MockWrite(true, kMsg3, kLen3, 2), // Async Write 370 MockWrite(true, kMsg3, kLen3, 3), // Async Write 371 MockWrite(true, kMsg2, kLen2, 4), // Async Write 372 MockWrite(true, kMsg3, kLen3, 5), // Async Write 373 MockWrite(true, kMsg1, kLen1, 6), // Async Write 374 }; 375 376 Initialize(NULL, 0, writes, arraysize(writes)); 377 378 AssertAsyncWriteEquals(kMsg1, kLen1); 379 AssertAsyncWriteEquals(kMsg2, kLen2); 380 AssertAsyncWriteEquals(kMsg3, kLen3); 381 AssertAsyncWriteEquals(kMsg3, kLen3); 382 AssertAsyncWriteEquals(kMsg2, kLen2); 383 AssertAsyncWriteEquals(kMsg3, kLen3); 384 AssertAsyncWriteEquals(kMsg1, kLen1); 385 } 386 387 TEST_F(DeterministicSocketDataTest, MixedWrites) { 388 MockWrite writes[] = { 389 MockWrite(false, kMsg1, kLen1, 0), // Sync Write 390 MockWrite(true, kMsg2, kLen2, 1), // Async Write 391 MockWrite(false, kMsg3, kLen3, 2), // Sync Write 392 MockWrite(true, kMsg3, kLen3, 3), // Async Write 393 MockWrite(false, kMsg2, kLen2, 4), // Sync Write 394 MockWrite(true, kMsg3, kLen3, 5), // Async Write 395 MockWrite(false, kMsg1, kLen1, 6), // Sync Write 396 }; 397 398 Initialize(NULL, 0, writes, arraysize(writes)); 399 400 data_->StopAfter(1); 401 AssertSyncWriteEquals(kMsg1, kLen1); 402 AssertAsyncWriteEquals(kMsg2, kLen2); 403 data_->StopAfter(1); 404 AssertSyncWriteEquals(kMsg3, kLen3); 405 AssertAsyncWriteEquals(kMsg3, kLen3); 406 data_->StopAfter(1); 407 AssertSyncWriteEquals(kMsg2, kLen2); 408 AssertAsyncWriteEquals(kMsg3, kLen3); 409 data_->StopAfter(1); 410 AssertSyncWriteEquals(kMsg1, kLen1); 411 } 412 413 // ----------- Mixed Reads and Writes 414 415 TEST_F(DeterministicSocketDataTest, MixedSyncOperations) { 416 MockRead reads[] = { 417 MockRead(false, kMsg1, kLen1, 0), // Sync Read 418 MockRead(false, kMsg2, kLen2, 3), // Sync Read 419 MockRead(false, 0, 4), // EOF 420 }; 421 422 MockWrite writes[] = { 423 MockWrite(false, kMsg2, kLen2, 1), // Sync Write 424 MockWrite(false, kMsg3, kLen3, 2), // Sync Write 425 }; 426 427 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 428 429 // Make sure we don't stop before we've read/written everything 430 data_->StopAfter(10); 431 AssertSyncReadEquals(kMsg1, kLen1); 432 AssertSyncWriteEquals(kMsg2, kLen2); 433 AssertSyncWriteEquals(kMsg3, kLen3); 434 AssertSyncReadEquals(kMsg2, kLen2); 435 } 436 437 TEST_F(DeterministicSocketDataTest, MixedAsyncOperations) { 438 MockRead reads[] = { 439 MockRead(true, kMsg1, kLen1, 0), // Sync Read 440 MockRead(true, kMsg2, kLen2, 3), // Sync Read 441 MockRead(true, 0, 4), // EOF 442 }; 443 444 MockWrite writes[] = { 445 MockWrite(true, kMsg2, kLen2, 1), // Sync Write 446 MockWrite(true, kMsg3, kLen3, 2), // Sync Write 447 }; 448 449 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 450 451 AssertAsyncReadEquals(kMsg1, kLen1); 452 AssertAsyncWriteEquals(kMsg2, kLen2); 453 AssertAsyncWriteEquals(kMsg3, kLen3); 454 AssertAsyncReadEquals(kMsg2, kLen2); 455 } 456 457 TEST_F(DeterministicSocketDataTest, InterleavedAsyncOperations) { 458 // Order of completion is read, write, write, read 459 MockRead reads[] = { 460 MockRead(true, kMsg1, kLen1, 0), // Async Read 461 MockRead(true, kMsg2, kLen2, 3), // Async Read 462 MockRead(true, 0, 4), // EOF 463 }; 464 465 MockWrite writes[] = { 466 MockWrite(true, kMsg2, kLen2, 1), // Async Write 467 MockWrite(true, kMsg3, kLen3, 2), // Async Write 468 }; 469 470 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 471 472 // Issue the write, which will block until the read completes 473 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING); 474 475 // Issue the read which will return first 476 AssertReadReturns(kMsg1, kLen1, ERR_IO_PENDING); 477 478 data_->RunFor(1); 479 ASSERT_EQ(kLen1, read_callback_.WaitForResult()); 480 AssertReadBufferEquals(kMsg1, kLen1); 481 482 data_->RunFor(1); 483 ASSERT_EQ(kLen2, write_callback_.WaitForResult()); 484 485 data_->StopAfter(1); 486 // Issue the read, which will block until the write completes 487 AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING); 488 489 // Issue the writes which will return first 490 AssertWriteReturns(kMsg3, kLen3, ERR_IO_PENDING); 491 492 data_->RunFor(1); 493 ASSERT_EQ(kLen3, write_callback_.WaitForResult()); 494 495 data_->RunFor(1); 496 ASSERT_EQ(kLen2, read_callback_.WaitForResult()); 497 AssertReadBufferEquals(kMsg2, kLen2); 498 } 499 500 TEST_F(DeterministicSocketDataTest, InterleavedMixedOperations) { 501 // Order of completion is read, write, write, read 502 MockRead reads[] = { 503 MockRead(false, kMsg1, kLen1, 0), // Sync Read 504 MockRead(true, kMsg2, kLen2, 3), // Async Read 505 MockRead(false, 0, 4), // EOF 506 }; 507 508 MockWrite writes[] = { 509 MockWrite(true, kMsg2, kLen2, 1), // Async Write 510 MockWrite(false, kMsg3, kLen3, 2), // Sync Write 511 }; 512 513 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 514 515 // Issue the write, which will block until the read completes 516 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING); 517 518 // Issue the writes which will complete immediately 519 data_->StopAfter(1); 520 AssertSyncReadEquals(kMsg1, kLen1); 521 522 data_->RunFor(1); 523 ASSERT_EQ(kLen2, write_callback_.WaitForResult()); 524 525 // Issue the read, which will block until the write completes 526 AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING); 527 528 // Issue the writes which will complete immediately 529 data_->StopAfter(1); 530 AssertSyncWriteEquals(kMsg3, kLen3); 531 532 data_->RunFor(1); 533 ASSERT_EQ(kLen2, read_callback_.WaitForResult()); 534 AssertReadBufferEquals(kMsg2, kLen2); 535 } 536 537 } // namespace net 538
