1 // Copyright (c) 2012 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 "base/basictypes.h" 6 #include "base/message_loop/message_loop.h" 7 #include "chrome/browser/net/network_stats.h" 8 #include "net/base/net_errors.h" 9 #include "net/base/network_change_notifier.h" 10 #include "net/base/test_completion_callback.h" 11 #include "net/dns/host_resolver.h" 12 #include "net/dns/mock_host_resolver.h" 13 #include "net/socket/socket_test_util.h" 14 #include "testing/gtest/include/gtest/gtest.h" 15 #include "testing/platform_test.h" 16 17 namespace chrome_browser_net { 18 19 class NetworkStatsTest : public PlatformTest { 20 public: 21 NetworkStatsTest() {} 22 23 protected: 24 25 virtual void SetUp() { 26 net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 27 base::MessageLoop::current()->RunUntilIdle(); 28 mock_writes_.clear(); 29 mock_reads_.clear(); 30 } 31 32 virtual void TearDown() { 33 net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 34 // Empty the current queue. 35 base::MessageLoop::current()->RunUntilIdle(); 36 PlatformTest::TearDown(); 37 } 38 39 void CreateToken(uint64 timestamp_micros, 40 const string& hash, 41 ProbePacket_Token* token) { 42 token->set_timestamp_micros(timestamp_micros); 43 token->mutable_hash()->assign(hash); 44 } 45 46 // DeterministicMockData defines the exact sequence of the read/write 47 // operations (specified by the last parameter of MockRead/MockWrite). 48 // |io_mode_write| is the IO mode for writing only. Reading is always async. 49 void MakeDeterministicMockData(uint32 max_tests, 50 uint32 max_probe_packets, 51 uint32 probe_bytes, 52 net::IoMode io_mode_write) { 53 // Only allow 0 or 1 test because the test 2 in NetworkStats is random. 54 DCHECK_LT(max_tests, 2U); 55 outputs_.resize(10); 56 ProbePacket probe_packet; 57 ProbeMessage probe_message; 58 probe_message.SetPacketHeader(ProbePacket_Type_HELLO_REQUEST, 59 &probe_packet); 60 probe_packet.set_group_id(0); 61 outputs_[0] = probe_message.MakeEncodedPacket(probe_packet); 62 mock_writes_.clear(); 63 mock_writes_.push_back(net::MockWrite( 64 io_mode_write, &outputs_[0][0], outputs_[0].size(), 0)); 65 // Add one probe_request. 66 probe_packet = ProbePacket(); // Clear all content. 67 ProbePacket_Token token; 68 CreateToken(1L, "1010", &token); 69 probe_message.GenerateProbeRequest( 70 token, 1, probe_bytes, 0, max_probe_packets, &probe_packet); 71 outputs_[1] = probe_message.MakeEncodedPacket(probe_packet); 72 mock_writes_.push_back(net::MockWrite( 73 io_mode_write, &outputs_[1][0], outputs_[1].size(), 2)); 74 75 inputs_.resize(10); 76 mock_reads_.clear(); 77 // Add a hello reply. 78 probe_packet = ProbePacket(); // Clear all content. 79 probe_message.SetPacketHeader(ProbePacket_Type_HELLO_REPLY, &probe_packet); 80 probe_packet.set_group_id(0); 81 CreateToken(1L, "1010", probe_packet.mutable_token()); 82 inputs_[0] = probe_message.MakeEncodedPacket(probe_packet); 83 mock_reads_.push_back( 84 net::MockRead(net::ASYNC, &inputs_[0][0], inputs_[0].size(), 1)); 85 86 for (uint32 i = 0; i < max_probe_packets; ++i) { 87 // Add a probe reply. 88 probe_packet = ProbePacket(); // Clear all content. 89 probe_message.SetPacketHeader(ProbePacket_Type_PROBE_REPLY, 90 &probe_packet); 91 int padding_size = probe_bytes - probe_packet.ByteSize() - 8; 92 probe_packet.mutable_padding()->append( 93 std::string(std::max(0, padding_size), 0)); 94 probe_packet.mutable_header()->set_checksum(0); 95 probe_packet.set_group_id(1); 96 probe_packet.set_packet_index(i); 97 inputs_[1 + i] = probe_message.MakeEncodedPacket(probe_packet); 98 mock_reads_.push_back(net::MockRead( 99 net::ASYNC, &inputs_[1 + i][0], inputs_[1 + i].size(), 3 + i)); 100 } 101 } 102 103 // Test NetworkStats::Start(...) method. 104 void TestStart(bool has_proxy, 105 uint32 max_tests, 106 uint32 max_probe_packets, 107 uint32 bytes, 108 net::IoMode io_mode) { 109 net::DeterministicMockClientSocketFactory mock_socket_factory; 110 MakeDeterministicMockData(max_tests, max_probe_packets, bytes, io_mode); 111 net::DeterministicSocketData test_data( 112 &mock_reads_[0], mock_reads_.size(), 113 &mock_writes_[0], mock_writes_.size()); 114 mock_socket_factory.AddSocketDataProvider(&test_data); 115 NetworkStats* udp_stats_client = new NetworkStats(&mock_socket_factory); 116 udp_stats_client->maximum_tests_ = max_tests; 117 udp_stats_client->maximum_sequential_packets_ = max_probe_packets; 118 119 net::TestCompletionCallback cb; 120 scoped_ptr<net::MockHostResolver> host_resolver( 121 new net::MockHostResolver()); 122 net::HostPortPair host_port_pair; 123 EXPECT_TRUE(udp_stats_client->Start(host_resolver.get(), 124 host_port_pair, 125 9999, 126 has_proxy, 127 bytes, 128 bytes, 129 cb.callback())); 130 int num_packets_run = (max_tests + 1) * 2 + max_probe_packets - 1; 131 test_data.RunFor(num_packets_run); 132 int rv = cb.WaitForResult(); 133 // Check there were no errors during connect/write/read to echo UDP server. 134 EXPECT_EQ(0, rv); 135 } 136 137 // Make one write and then |max_probe_packets| reads. 138 void MakeDelayedMockData(NetworkStats::TestType test_type, 139 uint32 probe_bytes, 140 uint32 pacing_interval_micros, 141 uint32 max_probe_packets, 142 net::IoMode io_mode) { 143 outputs_.resize(1); 144 ProbePacket probe_packet; 145 ProbeMessage probe_message; 146 mock_writes_.clear(); 147 ProbePacket_Token token; 148 CreateToken(2L, "2a2b", &token); 149 switch (test_type) { 150 case NetworkStats::PACKET_SIZE_TEST: 151 case NetworkStats::NON_PACED_PACKET_TEST: 152 pacing_interval_micros = 0; 153 break; 154 case NetworkStats::NAT_BIND_TEST: 155 // For NAT_BIND_TEST, we always set this to 1000000 to avoid the 156 // randomness in NetworkStats::SendProbeRequest() and to match 157 // the value chosen in TestStartOneTest() below. 158 pacing_interval_micros = 1000000; 159 break; 160 default: {} // Do nothing here. 161 } 162 probe_message.GenerateProbeRequest(token, 163 1, // current_test_index_ = 1. 164 probe_bytes, 165 pacing_interval_micros, 166 max_probe_packets, 167 &probe_packet); 168 outputs_[0] = probe_message.MakeEncodedPacket(probe_packet); 169 mock_writes_.push_back( 170 net::MockWrite(io_mode, &outputs_[0][0], outputs_[0].size())); 171 172 inputs_.resize(max_probe_packets); 173 mock_reads_.clear(); 174 for (uint32 i = 0; i < max_probe_packets; ++i) { 175 // Add a probe reply. 176 probe_packet = ProbePacket(); // Clear all content. 177 probe_message.SetPacketHeader(ProbePacket_Type_PROBE_REPLY, 178 &probe_packet); 179 int padding_size = probe_bytes - probe_packet.ByteSize() - 8; 180 probe_packet.mutable_padding()->append( 181 std::string(std::max(0, padding_size), 0)); 182 probe_packet.mutable_header()->set_checksum(0); 183 probe_packet.set_group_id(1); 184 probe_packet.set_packet_index(i); 185 inputs_[i] = probe_message.MakeEncodedPacket(probe_packet); 186 mock_reads_.push_back( 187 net::MockRead(io_mode, &inputs_[i][0], inputs_[i].size())); 188 } 189 } 190 191 // Test NetworkStats::StartOneTest(...) method. 192 void TestStartOneTest(bool has_proxy, 193 NetworkStats::TestType test_type, 194 uint32 bytes, 195 uint32 interval_micros, 196 uint32 max_probe_packets, 197 net::IoMode io_mode) { 198 199 net::MockClientSocketFactory mock_socket_factory; 200 MakeDelayedMockData( 201 test_type, bytes, interval_micros, max_probe_packets, io_mode); 202 net::DelayedSocketData test_data(1, 203 &mock_reads_[0], 204 mock_reads_.size(), 205 &mock_writes_[0], 206 mock_writes_.size()); 207 mock_socket_factory.AddSocketDataProvider(&test_data); 208 NetworkStats* udp_stats_client = new NetworkStats(&mock_socket_factory); 209 udp_stats_client->maximum_tests_ = 1; // Only do one probe at a time. 210 udp_stats_client->maximum_sequential_packets_ = max_probe_packets; 211 udp_stats_client->maximum_NAT_packets_ = max_probe_packets; 212 // For NAT_BIND_TEST, we always set this to 1 (second) to avoid the 213 // randomness in NetworkStats::SendProbeRequest(). 214 udp_stats_client->maximum_NAT_idle_seconds_ = 1; 215 udp_stats_client->start_test_after_connect_ = false; 216 udp_stats_client->inter_arrival_time_ = 217 base::TimeDelta::FromMicroseconds(interval_micros); 218 CreateToken(2L, "2a2b", &udp_stats_client->token_); 219 220 net::TestCompletionCallback cb; 221 scoped_ptr<net::MockHostResolver> host_resolver( 222 new net::MockHostResolver()); 223 net::HostPortPair host_port_pair; 224 EXPECT_TRUE(udp_stats_client->Start(host_resolver.get(), 225 host_port_pair, 226 9999, 227 has_proxy, 228 bytes, 229 bytes, 230 cb.callback())); 231 // Test need to be added after Start() because Start() will reset 232 // test_sequence_ 233 udp_stats_client->test_sequence_.push_back(test_type); 234 udp_stats_client->current_test_index_ = 1; 235 // Wait for host resolving and check if there were no errors during 236 // connect/write/read to UDP server. 237 int rv = cb.WaitForResult(); 238 EXPECT_EQ(0, rv); 239 udp_stats_client->ReadData(); 240 udp_stats_client->StartOneTest(); 241 rv = cb.WaitForResult(); 242 EXPECT_EQ(0, rv); 243 } 244 245 base::MessageLoopForIO message_loop_; 246 std::vector<std::string> inputs_; 247 std::vector<std::string> outputs_; 248 std::vector<net::MockRead> mock_reads_; 249 std::vector<net::MockWrite> mock_writes_; 250 }; 251 252 TEST_F(NetworkStatsTest, ProbeTest100BHasProxyGetToken) { 253 TestStart(true, 0, 1, 100, net::ASYNC); 254 } 255 256 TEST_F(NetworkStatsTest, ProbeTest500BHasNoProxyGetTokenSync) { 257 TestStart(false, 0, 1, 500, net::SYNCHRONOUS); 258 } 259 260 TEST_F(NetworkStatsTest, ProbeTest100BHasNoProxyOneTest) { 261 TestStart(false, 1, 1, 100, net::ASYNC); 262 } 263 264 TEST_F(NetworkStatsTest, ProbeTest100BHasNoProxyOneTestSync) { 265 TestStart(false, 1, 1, 100, net::SYNCHRONOUS); 266 } 267 268 TEST_F(NetworkStatsTest, ProbeTest100BHasProxyOneTest) { 269 TestStart(true, 1, 1, 100, net::ASYNC); 270 } 271 272 TEST_F(NetworkStatsTest, ProbeTest100BHasProxyOneTestSync) { 273 TestStart(true, 1, 1, 100, net::SYNCHRONOUS); 274 } 275 276 TEST_F(NetworkStatsTest, ProbeTest500BHasProxyOneTest) { 277 TestStart(true, 1, 1, 500, net::ASYNC); 278 } 279 280 TEST_F(NetworkStatsTest, ProbeTest500BHasNoProxyOneTestSync) { 281 TestStart(false, 1, 1, 500, net::SYNCHRONOUS); 282 } 283 284 TEST_F(NetworkStatsTest, ProbeTest500BHasNoProxyOneTest) { 285 TestStart(false, 1, 1, 500, net::ASYNC); 286 } 287 288 TEST_F(NetworkStatsTest, ProbeTest500BHasProxyOneTestSync) { 289 TestStart(true, 1, 1, 500, net::SYNCHRONOUS); 290 } 291 292 TEST_F(NetworkStatsTest, ProbeTest1200BHasProxyOneTest) { 293 TestStart(true, 1, 1, 1200, net::ASYNC); 294 } 295 296 TEST_F(NetworkStatsTest, ProbeTest1200BHasNoProxyOneTestSync) { 297 TestStart(false, 1, 1, 1200, net::SYNCHRONOUS); 298 } 299 300 TEST_F(NetworkStatsTest, ProbeTest1200BHasNoProxyOneTest) { 301 TestStart(false, 1, 1, 1200, net::ASYNC); 302 } 303 304 TEST_F(NetworkStatsTest, ProbeTest1200BHasProxyOneTestSync) { 305 TestStart(true, 1, 1, 1200, net::SYNCHRONOUS); 306 } 307 308 TEST_F(NetworkStatsTest, ProbeTest100BHasNoProxyOneTestMultiPackets) { 309 TestStart(false, 1, 4, 100, net::ASYNC); 310 } 311 312 TEST_F(NetworkStatsTest, ProbeTest1200BHasProxyOneTestMultiPacketsSync) { 313 TestStart(true, 1, 4, 1200, net::SYNCHRONOUS); 314 } 315 316 TEST_F(NetworkStatsTest, StartNonPacedTest100BHasProxy) { 317 TestStartOneTest( 318 true, NetworkStats::NON_PACED_PACKET_TEST, 100, 0, 1, net::ASYNC); 319 } 320 321 TEST_F(NetworkStatsTest, StartNonPacedTest100BHasNoProxySync) { 322 TestStartOneTest( 323 false, NetworkStats::NON_PACED_PACKET_TEST, 100, 0, 1, net::SYNCHRONOUS); 324 } 325 326 TEST_F(NetworkStatsTest, StartNonPacedTest500BHasNoProxy) { 327 TestStartOneTest( 328 false, NetworkStats::NON_PACED_PACKET_TEST, 500, 3, 1, net::ASYNC); 329 } 330 331 TEST_F(NetworkStatsTest, StartNonPacedTest1200BHasProxySync) { 332 TestStartOneTest( 333 true, NetworkStats::NON_PACED_PACKET_TEST, 1200, 1, 1, net::SYNCHRONOUS); 334 } 335 336 TEST_F(NetworkStatsTest, StartNonPacedTest500BHasNoProxyMulti) { 337 TestStartOneTest( 338 false, NetworkStats::NON_PACED_PACKET_TEST, 500, 2, 3, net::ASYNC); 339 } 340 341 TEST_F(NetworkStatsTest, StartNonPacedTest1200BHasProxySyncMulti) { 342 TestStartOneTest( 343 true, NetworkStats::NON_PACED_PACKET_TEST, 1200, 1, 4, net::SYNCHRONOUS); 344 } 345 346 TEST_F(NetworkStatsTest, StartPacedTest100BHasProxy) { 347 TestStartOneTest( 348 true, NetworkStats::PACED_PACKET_TEST, 100, 0, 1, net::ASYNC); 349 } 350 351 TEST_F(NetworkStatsTest, StartPacedTest100BHasNoProxySync) { 352 TestStartOneTest( 353 false, NetworkStats::PACED_PACKET_TEST, 100, 0, 1, net::SYNCHRONOUS); 354 } 355 356 TEST_F(NetworkStatsTest, StartPacedTest500BHasNoProxy) { 357 TestStartOneTest( 358 false, NetworkStats::PACED_PACKET_TEST, 500, 3, 1, net::ASYNC); 359 } 360 361 TEST_F(NetworkStatsTest, StartPacedTest1200BHasProxySync) { 362 TestStartOneTest( 363 true, NetworkStats::PACED_PACKET_TEST, 1200, 1, 1, net::SYNCHRONOUS); 364 } 365 366 TEST_F(NetworkStatsTest, StartPacedTest500BHasNoProxyMulti) { 367 TestStartOneTest( 368 false, NetworkStats::PACED_PACKET_TEST, 500, 2, 3, net::ASYNC); 369 } 370 371 TEST_F(NetworkStatsTest, StartPacedTest1200BHasProxySyncMulti) { 372 TestStartOneTest( 373 true, NetworkStats::PACED_PACKET_TEST, 1200, 1, 4, net::SYNCHRONOUS); 374 } 375 376 TEST_F(NetworkStatsTest, StartNATBindTest100BHasProxy) { 377 TestStartOneTest(true, NetworkStats::NAT_BIND_TEST, 100, 0, 1, net::ASYNC); 378 } 379 380 TEST_F(NetworkStatsTest, StartNATBindTest100BHasNoProxySync) { 381 TestStartOneTest( 382 false, NetworkStats::NAT_BIND_TEST, 100, 3, 1, net::SYNCHRONOUS); 383 } 384 385 TEST_F(NetworkStatsTest, StartNATBindTest500BHasNoProxy) { 386 TestStartOneTest(false, NetworkStats::NAT_BIND_TEST, 500, 0, 2, net::ASYNC); 387 } 388 389 TEST_F(NetworkStatsTest, StartNATBindTest1200BHasProxySync) { 390 TestStartOneTest( 391 true, NetworkStats::NAT_BIND_TEST, 1200, 3, 2, net::SYNCHRONOUS); 392 } 393 394 TEST_F(NetworkStatsTest, StartPacketSizeTest1500BHasProxy) { 395 TestStartOneTest( 396 true, NetworkStats::PACKET_SIZE_TEST, 1500, 0, 1, net::ASYNC); 397 } 398 399 TEST_F(NetworkStatsTest, StartPacketSizeTest1500HasNoProxySync) { 400 TestStartOneTest( 401 false, NetworkStats::PACKET_SIZE_TEST, 1500, 0, 1, net::SYNCHRONOUS); 402 } 403 404 TEST_F(NetworkStatsTest, StartPacketSizeTest1500BHasNoProxy) { 405 TestStartOneTest( 406 false, NetworkStats::PACKET_SIZE_TEST, 1500, 0, 1, net::ASYNC); 407 } 408 409 } // namespace chrome_browser_net 410
