blob: a6a4ee1e311b0c594c05457cc076d727f5238246 [file] [log] [blame]
henrike@webrtc.orgf0488722014-05-13 18:00:261/*
2 * Copyright 2006 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11#include <math.h>
12#include <time.h>
13#if defined(WEBRTC_POSIX)
14#include <netinet/in.h>
15#endif
16
jbauch555604a2016-04-26 10:13:2217#include <memory>
18
Mirko Bonadei92ea95e2017-09-15 04:47:3119#include "rtc_base/arraysize.h"
20#include "rtc_base/fakeclock.h"
21#include "rtc_base/gunit.h"
22#include "rtc_base/logging.h"
23#include "rtc_base/ptr_util.h"
24#include "rtc_base/testclient.h"
25#include "rtc_base/testutils.h"
26#include "rtc_base/thread.h"
27#include "rtc_base/timeutils.h"
28#include "rtc_base/virtualsocketserver.h"
henrike@webrtc.orgf0488722014-05-13 18:00:2629
30using namespace rtc;
31
kwibergd0d81482017-04-18 10:18:2232using webrtc::testing::SSE_CLOSE;
33using webrtc::testing::SSE_ERROR;
34using webrtc::testing::SSE_OPEN;
35using webrtc::testing::SSE_READ;
36using webrtc::testing::SSE_WRITE;
37using webrtc::testing::StreamSink;
38
henrike@webrtc.orgf0488722014-05-13 18:00:2639// Sends at a constant rate but with random packet sizes.
40struct Sender : public MessageHandler {
Peter Boström0c4e06b2015-10-07 10:23:2141 Sender(Thread* th, AsyncSocket* s, uint32_t rt)
42 : thread(th),
nisse32f25052017-05-08 08:57:1843 socket(MakeUnique<AsyncUDPSocket>(s)),
Peter Boström0c4e06b2015-10-07 10:23:2144 done(false),
45 rate(rt),
46 count(0) {
Honghai Zhang82d78622016-05-06 18:29:1547 last_send = rtc::TimeMillis();
Taylor Brandstetter5d97a9a2016-06-10 21:17:2748 thread->PostDelayed(RTC_FROM_HERE, NextDelay(), this, 1);
henrike@webrtc.orgf0488722014-05-13 18:00:2649 }
50
Peter Boström0c4e06b2015-10-07 10:23:2151 uint32_t NextDelay() {
52 uint32_t size = (rand() % 4096) + 1;
henrike@webrtc.orgf0488722014-05-13 18:00:2653 return 1000 * size / rate;
54 }
55
Steve Anton9de3aac2017-10-24 17:08:2656 void OnMessage(Message* pmsg) override {
henrike@webrtc.orgf0488722014-05-13 18:00:2657 ASSERT_EQ(1u, pmsg->message_id);
58
59 if (done)
60 return;
61
Honghai Zhang82d78622016-05-06 18:29:1562 int64_t cur_time = rtc::TimeMillis();
63 int64_t delay = cur_time - last_send;
64 uint32_t size = static_cast<uint32_t>(rate * delay / 1000);
Peter Boström0c4e06b2015-10-07 10:23:2165 size = std::min<uint32_t>(size, 4096);
66 size = std::max<uint32_t>(size, sizeof(uint32_t));
henrike@webrtc.orgf0488722014-05-13 18:00:2667
68 count += size;
69 memcpy(dummy, &cur_time, sizeof(cur_time));
70 socket->Send(dummy, size, options);
71
72 last_send = cur_time;
Taylor Brandstetter5d97a9a2016-06-10 21:17:2773 thread->PostDelayed(RTC_FROM_HERE, NextDelay(), this, 1);
henrike@webrtc.orgf0488722014-05-13 18:00:2674 }
75
76 Thread* thread;
jbauch555604a2016-04-26 10:13:2277 std::unique_ptr<AsyncUDPSocket> socket;
henrike@webrtc.orgf0488722014-05-13 18:00:2678 rtc::PacketOptions options;
79 bool done;
Peter Boström0c4e06b2015-10-07 10:23:2180 uint32_t rate; // bytes per second
81 uint32_t count;
Honghai Zhang82d78622016-05-06 18:29:1582 int64_t last_send;
henrike@webrtc.orgf0488722014-05-13 18:00:2683 char dummy[4096];
84};
85
86struct Receiver : public MessageHandler, public sigslot::has_slots<> {
Peter Boström0c4e06b2015-10-07 10:23:2187 Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
88 : thread(th),
nisse32f25052017-05-08 08:57:1889 socket(MakeUnique<AsyncUDPSocket>(s)),
Peter Boström0c4e06b2015-10-07 10:23:2190 bandwidth(bw),
91 done(false),
92 count(0),
93 sec_count(0),
94 sum(0),
95 sum_sq(0),
96 samples(0) {
henrike@webrtc.orgf0488722014-05-13 18:00:2697 socket->SignalReadPacket.connect(this, &Receiver::OnReadPacket);
Taylor Brandstetter5d97a9a2016-06-10 21:17:2798 thread->PostDelayed(RTC_FROM_HERE, 1000, this, 1);
henrike@webrtc.orgf0488722014-05-13 18:00:2699 }
100
Steve Anton9de3aac2017-10-24 17:08:26101 ~Receiver() override { thread->Clear(this); }
henrike@webrtc.orgf0488722014-05-13 18:00:26102
103 void OnReadPacket(AsyncPacketSocket* s, const char* data, size_t size,
104 const SocketAddress& remote_addr,
105 const PacketTime& packet_time) {
106 ASSERT_EQ(socket.get(), s);
107 ASSERT_GE(size, 4U);
108
109 count += size;
110 sec_count += size;
111
Peter Boström0c4e06b2015-10-07 10:23:21112 uint32_t send_time = *reinterpret_cast<const uint32_t*>(data);
Honghai Zhang82d78622016-05-06 18:29:15113 uint32_t recv_time = rtc::TimeMillis();
Peter Boström0c4e06b2015-10-07 10:23:21114 uint32_t delay = recv_time - send_time;
henrike@webrtc.orgf0488722014-05-13 18:00:26115 sum += delay;
116 sum_sq += delay * delay;
117 samples += 1;
118 }
119
Steve Anton9de3aac2017-10-24 17:08:26120 void OnMessage(Message* pmsg) override {
henrike@webrtc.orgf0488722014-05-13 18:00:26121 ASSERT_EQ(1u, pmsg->message_id);
122
123 if (done)
124 return;
125
126 // It is always possible for us to receive more than expected because
127 // packets can be further delayed in delivery.
128 if (bandwidth > 0)
129 ASSERT_TRUE(sec_count <= 5 * bandwidth / 4);
130 sec_count = 0;
Taylor Brandstetter5d97a9a2016-06-10 21:17:27131 thread->PostDelayed(RTC_FROM_HERE, 1000, this, 1);
henrike@webrtc.orgf0488722014-05-13 18:00:26132 }
133
134 Thread* thread;
jbauch555604a2016-04-26 10:13:22135 std::unique_ptr<AsyncUDPSocket> socket;
Peter Boström0c4e06b2015-10-07 10:23:21136 uint32_t bandwidth;
henrike@webrtc.orgf0488722014-05-13 18:00:26137 bool done;
138 size_t count;
139 size_t sec_count;
140 double sum;
141 double sum_sq;
Peter Boström0c4e06b2015-10-07 10:23:21142 uint32_t samples;
henrike@webrtc.orgf0488722014-05-13 18:00:26143};
144
deadbeef22e08142017-06-12 21:30:28145// Note: This test uses a fake clock in addition to a virtual network.
henrike@webrtc.orgf0488722014-05-13 18:00:26146class VirtualSocketServerTest : public testing::Test {
147 public:
deadbeef37f5ecf2017-02-27 22:06:41148 VirtualSocketServerTest()
deadbeef22e08142017-06-12 21:30:28149 : ss_(&fake_clock_),
150 thread_(&ss_),
deadbeef37f5ecf2017-02-27 22:06:41151 kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
152 kIPv6AnyAddress(IPAddress(in6addr_any), 0) {}
henrike@webrtc.orgf0488722014-05-13 18:00:26153
guoweis@webrtc.orgd3b453b2015-02-14 00:43:41154 void CheckPortIncrementalization(const SocketAddress& post,
155 const SocketAddress& pre) {
henrike@webrtc.orgf0488722014-05-13 18:00:26156 EXPECT_EQ(post.port(), pre.port() + 1);
157 IPAddress post_ip = post.ipaddr();
158 IPAddress pre_ip = pre.ipaddr();
159 EXPECT_EQ(pre_ip.family(), post_ip.family());
160 if (post_ip.family() == AF_INET) {
161 in_addr pre_ipv4 = pre_ip.ipv4_address();
162 in_addr post_ipv4 = post_ip.ipv4_address();
guoweis@webrtc.orgd3b453b2015-02-14 00:43:41163 EXPECT_EQ(post_ipv4.s_addr, pre_ipv4.s_addr);
henrike@webrtc.orgf0488722014-05-13 18:00:26164 } else if (post_ip.family() == AF_INET6) {
165 in6_addr post_ip6 = post_ip.ipv6_address();
166 in6_addr pre_ip6 = pre_ip.ipv6_address();
Peter Boström0c4e06b2015-10-07 10:23:21167 uint32_t* post_as_ints = reinterpret_cast<uint32_t*>(&post_ip6.s6_addr);
168 uint32_t* pre_as_ints = reinterpret_cast<uint32_t*>(&pre_ip6.s6_addr);
guoweis@webrtc.orgd3b453b2015-02-14 00:43:41169 EXPECT_EQ(post_as_ints[3], pre_as_ints[3]);
henrike@webrtc.orgf0488722014-05-13 18:00:26170 }
171 }
172
Guo-wei Shieh38f88932015-08-14 05:24:02173 // Test a client can bind to the any address, and all sent packets will have
174 // the default route as the source address. Also, it can receive packets sent
175 // to the default route.
176 void TestDefaultRoute(const IPAddress& default_route) {
nisse32f25052017-05-08 08:57:18177 ss_.SetDefaultRoute(default_route);
Guo-wei Shieh38f88932015-08-14 05:24:02178
179 // Create client1 bound to the any address.
180 AsyncSocket* socket =
nisse32f25052017-05-08 08:57:18181 ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
Guo-wei Shieh38f88932015-08-14 05:24:02182 socket->Bind(EmptySocketAddressWithFamily(default_route.family()));
183 SocketAddress client1_any_addr = socket->GetLocalAddress();
184 EXPECT_TRUE(client1_any_addr.IsAnyIP());
deadbeef22e08142017-06-12 21:30:28185 auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
186 &fake_clock_);
Guo-wei Shieh38f88932015-08-14 05:24:02187
188 // Create client2 bound to the default route.
189 AsyncSocket* socket2 =
nisse32f25052017-05-08 08:57:18190 ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
Guo-wei Shieh38f88932015-08-14 05:24:02191 socket2->Bind(SocketAddress(default_route, 0));
192 SocketAddress client2_addr = socket2->GetLocalAddress();
193 EXPECT_FALSE(client2_addr.IsAnyIP());
deadbeef22e08142017-06-12 21:30:28194 auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
195 &fake_clock_);
Guo-wei Shieh38f88932015-08-14 05:24:02196
197 // Client1 sends to client2, client2 should see the default route as
198 // client1's address.
199 SocketAddress client1_addr;
200 EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
201 EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
202 EXPECT_EQ(client1_addr,
203 SocketAddress(default_route, client1_any_addr.port()));
204
205 // Client2 can send back to client1's default route address.
206 EXPECT_EQ(3, client2->SendTo("foo", 3, client1_addr));
207 EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
208 }
209
henrike@webrtc.orgf0488722014-05-13 18:00:26210 void BasicTest(const SocketAddress& initial_addr) {
nisse32f25052017-05-08 08:57:18211 AsyncSocket* socket =
212 ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
henrike@webrtc.orgf0488722014-05-13 18:00:26213 socket->Bind(initial_addr);
214 SocketAddress server_addr = socket->GetLocalAddress();
215 // Make sure VSS didn't switch families on us.
216 EXPECT_EQ(server_addr.family(), initial_addr.family());
217
deadbeef22e08142017-06-12 21:30:28218 auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
219 &fake_clock_);
henrike@webrtc.orgf0488722014-05-13 18:00:26220 AsyncSocket* socket2 =
nisse32f25052017-05-08 08:57:18221 ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
deadbeef22e08142017-06-12 21:30:28222 auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
223 &fake_clock_);
henrike@webrtc.orgf0488722014-05-13 18:00:26224
225 SocketAddress client2_addr;
226 EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
227 EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
228
229 SocketAddress client1_addr;
230 EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
231 EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
232 EXPECT_EQ(client1_addr, server_addr);
233
234 SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
235 for (int i = 0; i < 10; i++) {
nisse32f25052017-05-08 08:57:18236 client2 = MakeUnique<TestClient>(
deadbeef22e08142017-06-12 21:30:28237 WrapUnique(AsyncUDPSocket::Create(&ss_, empty)), &fake_clock_);
henrike@webrtc.orgf0488722014-05-13 18:00:26238
239 SocketAddress next_client2_addr;
240 EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
241 EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
guoweis@webrtc.orgd3b453b2015-02-14 00:43:41242 CheckPortIncrementalization(next_client2_addr, client2_addr);
henrike@webrtc.orgf0488722014-05-13 18:00:26243 // EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
244
245 SocketAddress server_addr2;
246 EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
247 EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
248 EXPECT_EQ(server_addr2, server_addr);
249
250 client2_addr = next_client2_addr;
251 }
252 }
253
254 // initial_addr should be made from either INADDR_ANY or in6addr_any.
255 void ConnectTest(const SocketAddress& initial_addr) {
kwibergd0d81482017-04-18 10:18:22256 StreamSink sink;
henrike@webrtc.orgf0488722014-05-13 18:00:26257 SocketAddress accept_addr;
258 const SocketAddress kEmptyAddr =
259 EmptySocketAddressWithFamily(initial_addr.family());
260
261 // Create client
nisse32f25052017-05-08 08:57:18262 std::unique_ptr<AsyncSocket> client =
263 WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
264 sink.Monitor(client.get());
henrike@webrtc.orgf0488722014-05-13 18:00:26265 EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
266 EXPECT_TRUE(client->GetLocalAddress().IsNil());
267
268 // Create server
nisse32f25052017-05-08 08:57:18269 std::unique_ptr<AsyncSocket> server =
270 WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
271 sink.Monitor(server.get());
henrike@webrtc.orgf0488722014-05-13 18:00:26272 EXPECT_NE(0, server->Listen(5)); // Bind required
273 EXPECT_EQ(0, server->Bind(initial_addr));
274 EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
275 EXPECT_EQ(0, server->Listen(5));
276 EXPECT_EQ(server->GetState(), AsyncSocket::CS_CONNECTING);
277
278 // No pending server connections
nisse32f25052017-05-08 08:57:18279 EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
deadbeef37f5ecf2017-02-27 22:06:41280 EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
henrike@webrtc.orgf0488722014-05-13 18:00:26281 EXPECT_EQ(AF_UNSPEC, accept_addr.family());
282
283 // Attempt connect to listening socket
284 EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
285 EXPECT_NE(client->GetLocalAddress(), kEmptyAddr); // Implicit Bind
286 EXPECT_NE(AF_UNSPEC, client->GetLocalAddress().family()); // Implicit Bind
287 EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress());
288
289 // Client is connecting
290 EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
nisse32f25052017-05-08 08:57:18291 EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
292 EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
henrike@webrtc.orgf0488722014-05-13 18:00:26293
nisse32f25052017-05-08 08:57:18294 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26295
296 // Client still connecting
297 EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
nisse32f25052017-05-08 08:57:18298 EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
299 EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
henrike@webrtc.orgf0488722014-05-13 18:00:26300
301 // Server has pending connection
nisse32f25052017-05-08 08:57:18302 EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
303 std::unique_ptr<Socket> accepted = WrapUnique(server->Accept(&accept_addr));
deadbeef37f5ecf2017-02-27 22:06:41304 EXPECT_TRUE(nullptr != accepted);
henrike@webrtc.orgf0488722014-05-13 18:00:26305 EXPECT_NE(accept_addr, kEmptyAddr);
306 EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
307
308 EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
309 EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress());
310 EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
311
nisse32f25052017-05-08 08:57:18312 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26313
314 // Client has connected
315 EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTED);
nisse32f25052017-05-08 08:57:18316 EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
317 EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
henrike@webrtc.orgf0488722014-05-13 18:00:26318 EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
319 EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
320 }
321
322 void ConnectToNonListenerTest(const SocketAddress& initial_addr) {
kwibergd0d81482017-04-18 10:18:22323 StreamSink sink;
henrike@webrtc.orgf0488722014-05-13 18:00:26324 SocketAddress accept_addr;
325 const SocketAddress nil_addr;
326 const SocketAddress empty_addr =
327 EmptySocketAddressWithFamily(initial_addr.family());
328
329 // Create client
nisse32f25052017-05-08 08:57:18330 std::unique_ptr<AsyncSocket> client =
331 WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
332 sink.Monitor(client.get());
henrike@webrtc.orgf0488722014-05-13 18:00:26333
334 // Create server
nisse32f25052017-05-08 08:57:18335 std::unique_ptr<AsyncSocket> server =
336 WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
337 sink.Monitor(server.get());
henrike@webrtc.orgf0488722014-05-13 18:00:26338 EXPECT_EQ(0, server->Bind(initial_addr));
339 EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
340 // Attempt connect to non-listening socket
341 EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
342
nisse32f25052017-05-08 08:57:18343 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26344
345 // No pending server connections
nisse32f25052017-05-08 08:57:18346 EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
deadbeef37f5ecf2017-02-27 22:06:41347 EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
henrike@webrtc.orgf0488722014-05-13 18:00:26348 EXPECT_EQ(accept_addr, nil_addr);
349
350 // Connection failed
351 EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
nisse32f25052017-05-08 08:57:18352 EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
353 EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
henrike@webrtc.orgf0488722014-05-13 18:00:26354 EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
355 }
356
357 void CloseDuringConnectTest(const SocketAddress& initial_addr) {
kwibergd0d81482017-04-18 10:18:22358 StreamSink sink;
henrike@webrtc.orgf0488722014-05-13 18:00:26359 SocketAddress accept_addr;
360 const SocketAddress empty_addr =
361 EmptySocketAddressWithFamily(initial_addr.family());
362
363 // Create client and server
jbauch555604a2016-04-26 10:13:22364 std::unique_ptr<AsyncSocket> client(
nisse32f25052017-05-08 08:57:18365 ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
henrike@webrtc.orgf0488722014-05-13 18:00:26366 sink.Monitor(client.get());
jbauch555604a2016-04-26 10:13:22367 std::unique_ptr<AsyncSocket> server(
nisse32f25052017-05-08 08:57:18368 ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
henrike@webrtc.orgf0488722014-05-13 18:00:26369 sink.Monitor(server.get());
370
371 // Initiate connect
372 EXPECT_EQ(0, server->Bind(initial_addr));
373 EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
374
375 EXPECT_EQ(0, server->Listen(5));
376 EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
377
378 // Server close before socket enters accept queue
kwibergd0d81482017-04-18 10:18:22379 EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
henrike@webrtc.orgf0488722014-05-13 18:00:26380 server->Close();
381
nisse32f25052017-05-08 08:57:18382 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26383
384 // Result: connection failed
385 EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
kwibergd0d81482017-04-18 10:18:22386 EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
henrike@webrtc.orgf0488722014-05-13 18:00:26387
nisse32f25052017-05-08 08:57:18388 server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
henrike@webrtc.orgf0488722014-05-13 18:00:26389 sink.Monitor(server.get());
390
391 // Initiate connect
392 EXPECT_EQ(0, server->Bind(initial_addr));
393 EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
394
395 EXPECT_EQ(0, server->Listen(5));
396 EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
397
nisse32f25052017-05-08 08:57:18398 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26399
400 // Server close while socket is in accept queue
kwibergd0d81482017-04-18 10:18:22401 EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
henrike@webrtc.orgf0488722014-05-13 18:00:26402 server->Close();
403
nisse32f25052017-05-08 08:57:18404 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26405
406 // Result: connection failed
407 EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
kwibergd0d81482017-04-18 10:18:22408 EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
henrike@webrtc.orgf0488722014-05-13 18:00:26409
410 // New server
nisse32f25052017-05-08 08:57:18411 server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
henrike@webrtc.orgf0488722014-05-13 18:00:26412 sink.Monitor(server.get());
413
414 // Initiate connect
415 EXPECT_EQ(0, server->Bind(initial_addr));
416 EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
417
418 EXPECT_EQ(0, server->Listen(5));
419 EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
420
nisse32f25052017-05-08 08:57:18421 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26422
423 // Server accepts connection
kwibergd0d81482017-04-18 10:18:22424 EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
jbauch555604a2016-04-26 10:13:22425 std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
deadbeef37f5ecf2017-02-27 22:06:41426 ASSERT_TRUE(nullptr != accepted.get());
henrike@webrtc.orgf0488722014-05-13 18:00:26427 sink.Monitor(accepted.get());
428
429 // Client closes before connection complets
430 EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
431
432 // Connected message has not been processed yet.
433 EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
434 client->Close();
435
nisse32f25052017-05-08 08:57:18436 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26437
438 // Result: accepted socket closes
439 EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED);
kwibergd0d81482017-04-18 10:18:22440 EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE));
441 EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
henrike@webrtc.orgf0488722014-05-13 18:00:26442 }
443
444 void CloseTest(const SocketAddress& initial_addr) {
kwibergd0d81482017-04-18 10:18:22445 StreamSink sink;
henrike@webrtc.orgf0488722014-05-13 18:00:26446 const SocketAddress kEmptyAddr;
447
448 // Create clients
nisse32f25052017-05-08 08:57:18449 std::unique_ptr<AsyncSocket> a =
450 WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
451 sink.Monitor(a.get());
henrike@webrtc.orgf0488722014-05-13 18:00:26452 a->Bind(initial_addr);
453 EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
454
nisse32f25052017-05-08 08:57:18455 std::unique_ptr<AsyncSocket> b =
456 WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
henrike@webrtc.orgf0488722014-05-13 18:00:26457 sink.Monitor(b.get());
458 b->Bind(initial_addr);
459 EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
460
461 EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
462 EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
463
nisse32f25052017-05-08 08:57:18464 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26465
nisse32f25052017-05-08 08:57:18466 EXPECT_TRUE(sink.Check(a.get(), SSE_OPEN));
henrike@webrtc.orgf0488722014-05-13 18:00:26467 EXPECT_EQ(a->GetState(), AsyncSocket::CS_CONNECTED);
468 EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress());
469
kwibergd0d81482017-04-18 10:18:22470 EXPECT_TRUE(sink.Check(b.get(), SSE_OPEN));
henrike@webrtc.orgf0488722014-05-13 18:00:26471 EXPECT_EQ(b->GetState(), AsyncSocket::CS_CONNECTED);
472 EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress());
473
474 EXPECT_EQ(1, a->Send("a", 1));
475 b->Close();
476 EXPECT_EQ(1, a->Send("b", 1));
477
nisse32f25052017-05-08 08:57:18478 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26479
480 char buffer[10];
kwibergd0d81482017-04-18 10:18:22481 EXPECT_FALSE(sink.Check(b.get(), SSE_READ));
Stefan Holmer9131efd2016-05-23 16:19:26482 EXPECT_EQ(-1, b->Recv(buffer, 10, nullptr));
henrike@webrtc.orgf0488722014-05-13 18:00:26483
nisse32f25052017-05-08 08:57:18484 EXPECT_TRUE(sink.Check(a.get(), SSE_CLOSE));
henrike@webrtc.orgf0488722014-05-13 18:00:26485 EXPECT_EQ(a->GetState(), AsyncSocket::CS_CLOSED);
486 EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
487
488 // No signal for Closer
kwibergd0d81482017-04-18 10:18:22489 EXPECT_FALSE(sink.Check(b.get(), SSE_CLOSE));
henrike@webrtc.orgf0488722014-05-13 18:00:26490 EXPECT_EQ(b->GetState(), AsyncSocket::CS_CLOSED);
491 EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
492 }
493
494 void TcpSendTest(const SocketAddress& initial_addr) {
kwibergd0d81482017-04-18 10:18:22495 StreamSink sink;
henrike@webrtc.orgf0488722014-05-13 18:00:26496 const SocketAddress kEmptyAddr;
497
498 // Connect two sockets
nisse32f25052017-05-08 08:57:18499 std::unique_ptr<AsyncSocket> a =
500 WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
501 sink.Monitor(a.get());
henrike@webrtc.orgf0488722014-05-13 18:00:26502 a->Bind(initial_addr);
503 EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
504
nisse32f25052017-05-08 08:57:18505 std::unique_ptr<AsyncSocket> b =
506 WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
507 sink.Monitor(b.get());
henrike@webrtc.orgf0488722014-05-13 18:00:26508 b->Bind(initial_addr);
509 EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
510
511 EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
512 EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
513
nisse32f25052017-05-08 08:57:18514 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26515
516 const size_t kBufferSize = 2000;
nisse32f25052017-05-08 08:57:18517 ss_.set_send_buffer_capacity(kBufferSize);
518 ss_.set_recv_buffer_capacity(kBufferSize);
henrike@webrtc.orgf0488722014-05-13 18:00:26519
520 const size_t kDataSize = 5000;
521 char send_buffer[kDataSize], recv_buffer[kDataSize];
522 for (size_t i = 0; i < kDataSize; ++i)
523 send_buffer[i] = static_cast<char>(i % 256);
524 memset(recv_buffer, 0, sizeof(recv_buffer));
525 size_t send_pos = 0, recv_pos = 0;
526
527 // Can't send more than send buffer in one write
528 int result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
529 EXPECT_EQ(static_cast<int>(kBufferSize), result);
530 send_pos += result;
531
nisse32f25052017-05-08 08:57:18532 ss_.ProcessMessagesUntilIdle();
533 EXPECT_FALSE(sink.Check(a.get(), SSE_WRITE));
534 EXPECT_TRUE(sink.Check(b.get(), SSE_READ));
henrike@webrtc.orgf0488722014-05-13 18:00:26535
536 // Receive buffer is already filled, fill send buffer again
537 result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
538 EXPECT_EQ(static_cast<int>(kBufferSize), result);
539 send_pos += result;
540
nisse32f25052017-05-08 08:57:18541 ss_.ProcessMessagesUntilIdle();
542 EXPECT_FALSE(sink.Check(a.get(), SSE_WRITE));
543 EXPECT_FALSE(sink.Check(b.get(), SSE_READ));
henrike@webrtc.orgf0488722014-05-13 18:00:26544
545 // No more room in send or receive buffer
546 result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
547 EXPECT_EQ(-1, result);
548 EXPECT_TRUE(a->IsBlocking());
549
550 // Read a subset of the data
Stefan Holmer9131efd2016-05-23 16:19:26551 result = b->Recv(recv_buffer + recv_pos, 500, nullptr);
henrike@webrtc.orgf0488722014-05-13 18:00:26552 EXPECT_EQ(500, result);
553 recv_pos += result;
554
nisse32f25052017-05-08 08:57:18555 ss_.ProcessMessagesUntilIdle();
556 EXPECT_TRUE(sink.Check(a.get(), SSE_WRITE));
557 EXPECT_TRUE(sink.Check(b.get(), SSE_READ));
henrike@webrtc.orgf0488722014-05-13 18:00:26558
559 // Room for more on the sending side
560 result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
561 EXPECT_EQ(500, result);
562 send_pos += result;
563
564 // Empty the recv buffer
565 while (true) {
Stefan Holmer9131efd2016-05-23 16:19:26566 result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, nullptr);
henrike@webrtc.orgf0488722014-05-13 18:00:26567 if (result < 0) {
568 EXPECT_EQ(-1, result);
569 EXPECT_TRUE(b->IsBlocking());
570 break;
571 }
572 recv_pos += result;
573 }
574
nisse32f25052017-05-08 08:57:18575 ss_.ProcessMessagesUntilIdle();
576 EXPECT_TRUE(sink.Check(b.get(), SSE_READ));
henrike@webrtc.orgf0488722014-05-13 18:00:26577
578 // Continue to empty the recv buffer
579 while (true) {
Stefan Holmer9131efd2016-05-23 16:19:26580 result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, nullptr);
henrike@webrtc.orgf0488722014-05-13 18:00:26581 if (result < 0) {
582 EXPECT_EQ(-1, result);
583 EXPECT_TRUE(b->IsBlocking());
584 break;
585 }
586 recv_pos += result;
587 }
588
589 // Send last of the data
590 result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
591 EXPECT_EQ(500, result);
592 send_pos += result;
593
nisse32f25052017-05-08 08:57:18594 ss_.ProcessMessagesUntilIdle();
595 EXPECT_TRUE(sink.Check(b.get(), SSE_READ));
henrike@webrtc.orgf0488722014-05-13 18:00:26596
597 // Receive the last of the data
598 while (true) {
Stefan Holmer9131efd2016-05-23 16:19:26599 result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, nullptr);
henrike@webrtc.orgf0488722014-05-13 18:00:26600 if (result < 0) {
601 EXPECT_EQ(-1, result);
602 EXPECT_TRUE(b->IsBlocking());
603 break;
604 }
605 recv_pos += result;
606 }
607
nisse32f25052017-05-08 08:57:18608 ss_.ProcessMessagesUntilIdle();
609 EXPECT_FALSE(sink.Check(b.get(), SSE_READ));
henrike@webrtc.orgf0488722014-05-13 18:00:26610
611 // The received data matches the sent data
612 EXPECT_EQ(kDataSize, send_pos);
613 EXPECT_EQ(kDataSize, recv_pos);
614 EXPECT_EQ(0, memcmp(recv_buffer, send_buffer, kDataSize));
615 }
616
617 void TcpSendsPacketsInOrderTest(const SocketAddress& initial_addr) {
618 const SocketAddress kEmptyAddr;
619
620 // Connect two sockets
nisse32f25052017-05-08 08:57:18621 std::unique_ptr<AsyncSocket> a =
622 WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
623 std::unique_ptr<AsyncSocket> b =
624 WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
henrike@webrtc.orgf0488722014-05-13 18:00:26625 a->Bind(initial_addr);
626 EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
627
628 b->Bind(initial_addr);
629 EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
630
631 EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
632 EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
nisse32f25052017-05-08 08:57:18633 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26634
635 // First, deliver all packets in 0 ms.
636 char buffer[2] = { 0, 0 };
637 const char cNumPackets = 10;
638 for (char i = 0; i < cNumPackets; ++i) {
639 buffer[0] = '0' + i;
640 EXPECT_EQ(1, a->Send(buffer, 1));
641 }
642
nisse32f25052017-05-08 08:57:18643 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26644
645 for (char i = 0; i < cNumPackets; ++i) {
Stefan Holmer9131efd2016-05-23 16:19:26646 EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer), nullptr));
henrike@webrtc.orgf0488722014-05-13 18:00:26647 EXPECT_EQ(static_cast<char>('0' + i), buffer[0]);
648 }
649
650 // Next, deliver packets at random intervals
Peter Boström0c4e06b2015-10-07 10:23:21651 const uint32_t mean = 50;
652 const uint32_t stddev = 50;
henrike@webrtc.orgf0488722014-05-13 18:00:26653
nisse32f25052017-05-08 08:57:18654 ss_.set_delay_mean(mean);
655 ss_.set_delay_stddev(stddev);
656 ss_.UpdateDelayDistribution();
henrike@webrtc.orgf0488722014-05-13 18:00:26657
658 for (char i = 0; i < cNumPackets; ++i) {
659 buffer[0] = 'A' + i;
660 EXPECT_EQ(1, a->Send(buffer, 1));
661 }
662
nisse32f25052017-05-08 08:57:18663 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26664
665 for (char i = 0; i < cNumPackets; ++i) {
Stefan Holmer9131efd2016-05-23 16:19:26666 EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer), nullptr));
henrike@webrtc.orgf0488722014-05-13 18:00:26667 EXPECT_EQ(static_cast<char>('A' + i), buffer[0]);
668 }
669 }
670
guoweis@webrtc.orgf358aea2015-02-18 18:44:01671 // It is important that initial_addr's port has to be 0 such that the
672 // incremental port behavior could ensure the 2 Binds result in different
673 // address.
674 void BandwidthTest(const SocketAddress& initial_addr) {
henrike@webrtc.orgf0488722014-05-13 18:00:26675 AsyncSocket* send_socket =
nisse32f25052017-05-08 08:57:18676 ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
henrike@webrtc.orgf0488722014-05-13 18:00:26677 AsyncSocket* recv_socket =
nisse32f25052017-05-08 08:57:18678 ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
guoweis@webrtc.orgf358aea2015-02-18 18:44:01679 ASSERT_EQ(0, send_socket->Bind(initial_addr));
680 ASSERT_EQ(0, recv_socket->Bind(initial_addr));
681 EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
682 EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
henrike@webrtc.orgf0488722014-05-13 18:00:26683 ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
684
Peter Boström0c4e06b2015-10-07 10:23:21685 uint32_t bandwidth = 64 * 1024;
nisse32f25052017-05-08 08:57:18686 ss_.set_bandwidth(bandwidth);
henrike@webrtc.orgf0488722014-05-13 18:00:26687
688 Thread* pthMain = Thread::Current();
689 Sender sender(pthMain, send_socket, 80 * 1024);
690 Receiver receiver(pthMain, recv_socket, bandwidth);
691
deadbeef22e08142017-06-12 21:30:28692 // Allow the sender to run for 5 (simulated) seconds, then be stopped for 5
693 // seconds.
694 SIMULATED_WAIT(false, 5000, fake_clock_);
henrike@webrtc.orgf0488722014-05-13 18:00:26695 sender.done = true;
deadbeef22e08142017-06-12 21:30:28696 SIMULATED_WAIT(false, 5000, fake_clock_);
henrike@webrtc.orgf0488722014-05-13 18:00:26697
deadbeef22e08142017-06-12 21:30:28698 // Ensure the observed bandwidth fell within a reasonable margin of error.
699 EXPECT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
700 EXPECT_TRUE(receiver.count <= 6 * bandwidth); // queue could drain for 1s
henrike@webrtc.orgf0488722014-05-13 18:00:26701
nisse32f25052017-05-08 08:57:18702 ss_.set_bandwidth(0);
henrike@webrtc.orgf0488722014-05-13 18:00:26703 }
704
guoweis@webrtc.orgf358aea2015-02-18 18:44:01705 // It is important that initial_addr's port has to be 0 such that the
706 // incremental port behavior could ensure the 2 Binds result in different
707 // address.
708 void DelayTest(const SocketAddress& initial_addr) {
deadbeef37f5ecf2017-02-27 22:06:41709 time_t seed = ::time(nullptr);
Mirko Bonadei675513b2017-11-09 10:09:25710 RTC_LOG(LS_VERBOSE) << "seed = " << seed;
henrike@webrtc.orgf0488722014-05-13 18:00:26711 srand(static_cast<unsigned int>(seed));
712
Peter Boström0c4e06b2015-10-07 10:23:21713 const uint32_t mean = 2000;
714 const uint32_t stddev = 500;
henrike@webrtc.orgf0488722014-05-13 18:00:26715
nisse32f25052017-05-08 08:57:18716 ss_.set_delay_mean(mean);
717 ss_.set_delay_stddev(stddev);
718 ss_.UpdateDelayDistribution();
henrike@webrtc.orgf0488722014-05-13 18:00:26719
720 AsyncSocket* send_socket =
nisse32f25052017-05-08 08:57:18721 ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
henrike@webrtc.orgf0488722014-05-13 18:00:26722 AsyncSocket* recv_socket =
nisse32f25052017-05-08 08:57:18723 ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
guoweis@webrtc.orgf358aea2015-02-18 18:44:01724 ASSERT_EQ(0, send_socket->Bind(initial_addr));
725 ASSERT_EQ(0, recv_socket->Bind(initial_addr));
726 EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
727 EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
henrike@webrtc.orgf0488722014-05-13 18:00:26728 ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
729
730 Thread* pthMain = Thread::Current();
731 // Avg packet size is 2K, so at 200KB/s for 10s, we should see about
732 // 1000 packets, which is necessary to get a good distribution.
733 Sender sender(pthMain, send_socket, 100 * 2 * 1024);
734 Receiver receiver(pthMain, recv_socket, 0);
735
deadbeef22e08142017-06-12 21:30:28736 // Simulate 10 seconds of packets being sent, then check the observed delay
737 // distribution.
738 SIMULATED_WAIT(false, 10000, fake_clock_);
henrike@webrtc.orgf0488722014-05-13 18:00:26739 sender.done = receiver.done = true;
nisse32f25052017-05-08 08:57:18740 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26741
742 const double sample_mean = receiver.sum / receiver.samples;
743 double num =
744 receiver.samples * receiver.sum_sq - receiver.sum * receiver.sum;
745 double den = receiver.samples * (receiver.samples - 1);
746 const double sample_stddev = sqrt(num / den);
Mirko Bonadei675513b2017-11-09 10:09:25747 RTC_LOG(LS_VERBOSE) << "mean=" << sample_mean
748 << " stddev=" << sample_stddev;
henrike@webrtc.orgf0488722014-05-13 18:00:26749
750 EXPECT_LE(500u, receiver.samples);
751 // We initially used a 0.1 fudge factor, but on the build machine, we
752 // have seen the value differ by as much as 0.13.
753 EXPECT_NEAR(mean, sample_mean, 0.15 * mean);
754 EXPECT_NEAR(stddev, sample_stddev, 0.15 * stddev);
755
nisse32f25052017-05-08 08:57:18756 ss_.set_delay_mean(0);
757 ss_.set_delay_stddev(0);
758 ss_.UpdateDelayDistribution();
henrike@webrtc.orgf0488722014-05-13 18:00:26759 }
760
761 // Test cross-family communication between a client bound to client_addr and a
762 // server bound to server_addr. shouldSucceed indicates if communication is
763 // expected to work or not.
764 void CrossFamilyConnectionTest(const SocketAddress& client_addr,
765 const SocketAddress& server_addr,
766 bool shouldSucceed) {
kwibergd0d81482017-04-18 10:18:22767 StreamSink sink;
henrike@webrtc.orgf0488722014-05-13 18:00:26768 SocketAddress accept_address;
769 const SocketAddress kEmptyAddr;
770
771 // Client gets a IPv4 address
nisse32f25052017-05-08 08:57:18772 std::unique_ptr<AsyncSocket> client =
773 WrapUnique(ss_.CreateAsyncSocket(client_addr.family(), SOCK_STREAM));
774 sink.Monitor(client.get());
henrike@webrtc.orgf0488722014-05-13 18:00:26775 EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
776 EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
777 client->Bind(client_addr);
778
779 // Server gets a non-mapped non-any IPv6 address.
780 // IPv4 sockets should not be able to connect to this.
nisse32f25052017-05-08 08:57:18781 std::unique_ptr<AsyncSocket> server =
782 WrapUnique(ss_.CreateAsyncSocket(server_addr.family(), SOCK_STREAM));
783 sink.Monitor(server.get());
henrike@webrtc.orgf0488722014-05-13 18:00:26784 server->Bind(server_addr);
785 server->Listen(5);
786
787 if (shouldSucceed) {
788 EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
nisse32f25052017-05-08 08:57:18789 ss_.ProcessMessagesUntilIdle();
790 EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
791 std::unique_ptr<Socket> accepted =
792 WrapUnique(server->Accept(&accept_address));
deadbeef37f5ecf2017-02-27 22:06:41793 EXPECT_TRUE(nullptr != accepted);
henrike@webrtc.orgf0488722014-05-13 18:00:26794 EXPECT_NE(kEmptyAddr, accept_address);
nisse32f25052017-05-08 08:57:18795 ss_.ProcessMessagesUntilIdle();
796 EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
henrike@webrtc.orgf0488722014-05-13 18:00:26797 EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
798 } else {
799 // Check that the connection failed.
800 EXPECT_EQ(-1, client->Connect(server->GetLocalAddress()));
nisse32f25052017-05-08 08:57:18801 ss_.ProcessMessagesUntilIdle();
henrike@webrtc.orgf0488722014-05-13 18:00:26802
nisse32f25052017-05-08 08:57:18803 EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
deadbeef37f5ecf2017-02-27 22:06:41804 EXPECT_TRUE(nullptr == server->Accept(&accept_address));
henrike@webrtc.orgf0488722014-05-13 18:00:26805 EXPECT_EQ(accept_address, kEmptyAddr);
806 EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
nisse32f25052017-05-08 08:57:18807 EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
henrike@webrtc.orgf0488722014-05-13 18:00:26808 EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
809 }
810 }
811
812 // Test cross-family datagram sending between a client bound to client_addr
813 // and a server bound to server_addr. shouldSucceed indicates if sending is
jlmiller@webrtc.orgec499be2015-02-07 22:37:59814 // expected to succeed or not.
henrike@webrtc.orgf0488722014-05-13 18:00:26815 void CrossFamilyDatagramTest(const SocketAddress& client_addr,
816 const SocketAddress& server_addr,
817 bool shouldSucceed) {
nisse32f25052017-05-08 08:57:18818 AsyncSocket* socket = ss_.CreateAsyncSocket(SOCK_DGRAM);
henrike@webrtc.orgf0488722014-05-13 18:00:26819 socket->Bind(server_addr);
820 SocketAddress bound_server_addr = socket->GetLocalAddress();
deadbeef22e08142017-06-12 21:30:28821 auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
822 &fake_clock_);
henrike@webrtc.orgf0488722014-05-13 18:00:26823
nisse32f25052017-05-08 08:57:18824 AsyncSocket* socket2 = ss_.CreateAsyncSocket(SOCK_DGRAM);
henrike@webrtc.orgf0488722014-05-13 18:00:26825 socket2->Bind(client_addr);
deadbeef22e08142017-06-12 21:30:28826 auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
827 &fake_clock_);
henrike@webrtc.orgf0488722014-05-13 18:00:26828 SocketAddress client2_addr;
829
830 if (shouldSucceed) {
831 EXPECT_EQ(3, client2->SendTo("foo", 3, bound_server_addr));
832 EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
833 SocketAddress client1_addr;
834 EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
835 EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
836 EXPECT_EQ(client1_addr, bound_server_addr);
837 } else {
838 EXPECT_EQ(-1, client2->SendTo("foo", 3, bound_server_addr));
jlmiller@webrtc.orgec499be2015-02-07 22:37:59839 EXPECT_TRUE(client1->CheckNoPacket());
henrike@webrtc.orgf0488722014-05-13 18:00:26840 }
841 }
842
843 protected:
deadbeef22e08142017-06-12 21:30:28844 rtc::ScopedFakeClock fake_clock_;
nisse32f25052017-05-08 08:57:18845 VirtualSocketServer ss_;
nisse7eaa4ea2017-05-08 12:25:41846 AutoSocketServerThread thread_;
henrike@webrtc.orgf0488722014-05-13 18:00:26847 const SocketAddress kIPv4AnyAddress;
848 const SocketAddress kIPv6AnyAddress;
849};
850
henrike@webrtc.orgc732a3e2014-10-09 22:08:15851TEST_F(VirtualSocketServerTest, basic_v4) {
henrike@webrtc.orgf0488722014-05-13 18:00:26852 SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
853 BasicTest(ipv4_test_addr);
854}
855
henrike@webrtc.orgc732a3e2014-10-09 22:08:15856TEST_F(VirtualSocketServerTest, basic_v6) {
henrike@webrtc.orgf0488722014-05-13 18:00:26857 SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 5000);
858 BasicTest(ipv6_test_addr);
859}
860
Guo-wei Shieh38f88932015-08-14 05:24:02861TEST_F(VirtualSocketServerTest, TestDefaultRoute_v4) {
862 IPAddress ipv4_default_addr(0x01020304);
863 TestDefaultRoute(ipv4_default_addr);
864}
865
866TEST_F(VirtualSocketServerTest, TestDefaultRoute_v6) {
867 IPAddress ipv6_default_addr;
868 EXPECT_TRUE(
869 IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ipv6_default_addr));
870 TestDefaultRoute(ipv6_default_addr);
871}
872
henrike@webrtc.orgc732a3e2014-10-09 22:08:15873TEST_F(VirtualSocketServerTest, connect_v4) {
henrike@webrtc.orgf0488722014-05-13 18:00:26874 ConnectTest(kIPv4AnyAddress);
875}
876
henrike@webrtc.orgc732a3e2014-10-09 22:08:15877TEST_F(VirtualSocketServerTest, connect_v6) {
henrike@webrtc.orgf0488722014-05-13 18:00:26878 ConnectTest(kIPv6AnyAddress);
879}
880
henrike@webrtc.orgc732a3e2014-10-09 22:08:15881TEST_F(VirtualSocketServerTest, connect_to_non_listener_v4) {
henrike@webrtc.orgf0488722014-05-13 18:00:26882 ConnectToNonListenerTest(kIPv4AnyAddress);
883}
884
henrike@webrtc.orgc732a3e2014-10-09 22:08:15885TEST_F(VirtualSocketServerTest, connect_to_non_listener_v6) {
henrike@webrtc.orgf0488722014-05-13 18:00:26886 ConnectToNonListenerTest(kIPv6AnyAddress);
887}
888
henrike@webrtc.orgc732a3e2014-10-09 22:08:15889TEST_F(VirtualSocketServerTest, close_during_connect_v4) {
henrike@webrtc.orgf0488722014-05-13 18:00:26890 CloseDuringConnectTest(kIPv4AnyAddress);
891}
892
henrike@webrtc.orgc732a3e2014-10-09 22:08:15893TEST_F(VirtualSocketServerTest, close_during_connect_v6) {
henrike@webrtc.orgf0488722014-05-13 18:00:26894 CloseDuringConnectTest(kIPv6AnyAddress);
895}
896
897TEST_F(VirtualSocketServerTest, close_v4) {
898 CloseTest(kIPv4AnyAddress);
899}
900
901TEST_F(VirtualSocketServerTest, close_v6) {
902 CloseTest(kIPv6AnyAddress);
903}
904
henrike@webrtc.orgc732a3e2014-10-09 22:08:15905TEST_F(VirtualSocketServerTest, tcp_send_v4) {
henrike@webrtc.orgf0488722014-05-13 18:00:26906 TcpSendTest(kIPv4AnyAddress);
907}
908
henrike@webrtc.orgc732a3e2014-10-09 22:08:15909TEST_F(VirtualSocketServerTest, tcp_send_v6) {
henrike@webrtc.orgf0488722014-05-13 18:00:26910 TcpSendTest(kIPv6AnyAddress);
911}
912
913TEST_F(VirtualSocketServerTest, TcpSendsPacketsInOrder_v4) {
914 TcpSendsPacketsInOrderTest(kIPv4AnyAddress);
915}
916
917TEST_F(VirtualSocketServerTest, TcpSendsPacketsInOrder_v6) {
918 TcpSendsPacketsInOrderTest(kIPv6AnyAddress);
919}
920
henrike@webrtc.orgc732a3e2014-10-09 22:08:15921TEST_F(VirtualSocketServerTest, bandwidth_v4) {
guoweis@webrtc.orgf358aea2015-02-18 18:44:01922 BandwidthTest(kIPv4AnyAddress);
henrike@webrtc.orgf0488722014-05-13 18:00:26923}
924
henrike@webrtc.orgc732a3e2014-10-09 22:08:15925TEST_F(VirtualSocketServerTest, bandwidth_v6) {
guoweis@webrtc.orgf358aea2015-02-18 18:44:01926 BandwidthTest(kIPv6AnyAddress);
henrike@webrtc.orgf0488722014-05-13 18:00:26927}
928
deadbeef22e08142017-06-12 21:30:28929TEST_F(VirtualSocketServerTest, delay_v4) {
guoweis@webrtc.orgf358aea2015-02-18 18:44:01930 DelayTest(kIPv4AnyAddress);
henrike@webrtc.orgf0488722014-05-13 18:00:26931}
932
deadbeef22e08142017-06-12 21:30:28933TEST_F(VirtualSocketServerTest, delay_v6) {
guoweis@webrtc.orgf358aea2015-02-18 18:44:01934 DelayTest(kIPv6AnyAddress);
henrike@webrtc.orgf0488722014-05-13 18:00:26935}
936
937// Works, receiving socket sees 127.0.0.2.
henrike@webrtc.orgc732a3e2014-10-09 22:08:15938TEST_F(VirtualSocketServerTest, CanConnectFromMappedIPv6ToIPv4Any) {
henrike@webrtc.orgf0488722014-05-13 18:00:26939 CrossFamilyConnectionTest(SocketAddress("::ffff:127.0.0.2", 0),
940 SocketAddress("0.0.0.0", 5000),
941 true);
942}
943
944// Fails.
henrike@webrtc.orgc732a3e2014-10-09 22:08:15945TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToIPv4Any) {
henrike@webrtc.orgf0488722014-05-13 18:00:26946 CrossFamilyConnectionTest(SocketAddress("::2", 0),
947 SocketAddress("0.0.0.0", 5000),
948 false);
949}
950
951// Fails.
henrike@webrtc.orgc732a3e2014-10-09 22:08:15952TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToMappedIPv6) {
henrike@webrtc.orgf0488722014-05-13 18:00:26953 CrossFamilyConnectionTest(SocketAddress("::2", 0),
954 SocketAddress("::ffff:127.0.0.1", 5000),
955 false);
956}
957
958// Works. receiving socket sees ::ffff:127.0.0.2.
henrike@webrtc.orgc732a3e2014-10-09 22:08:15959TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToIPv6Any) {
henrike@webrtc.orgf0488722014-05-13 18:00:26960 CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
961 SocketAddress("::", 5000),
962 true);
963}
964
965// Fails.
henrike@webrtc.orgc732a3e2014-10-09 22:08:15966TEST_F(VirtualSocketServerTest, CantConnectFromIPv4ToUnMappedIPv6) {
henrike@webrtc.orgf0488722014-05-13 18:00:26967 CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
968 SocketAddress("::1", 5000),
969 false);
970}
971
972// Works. Receiving socket sees ::ffff:127.0.0.1.
henrike@webrtc.orgc732a3e2014-10-09 22:08:15973TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToMappedIPv6) {
henrike@webrtc.orgf0488722014-05-13 18:00:26974 CrossFamilyConnectionTest(SocketAddress("127.0.0.1", 0),
975 SocketAddress("::ffff:127.0.0.2", 5000),
976 true);
977}
978
979// Works, receiving socket sees a result from GetNextIP.
henrike@webrtc.orgc732a3e2014-10-09 22:08:15980TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv6ToIPv4Any) {
henrike@webrtc.orgf0488722014-05-13 18:00:26981 CrossFamilyConnectionTest(SocketAddress("::", 0),
982 SocketAddress("0.0.0.0", 5000),
983 true);
984}
985
986// Works, receiving socket sees whatever GetNextIP gave the client.
henrike@webrtc.orgc732a3e2014-10-09 22:08:15987TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv4ToIPv6Any) {
henrike@webrtc.orgf0488722014-05-13 18:00:26988 CrossFamilyConnectionTest(SocketAddress("0.0.0.0", 0),
989 SocketAddress("::", 5000),
990 true);
991}
992
henrike@webrtc.orgc732a3e2014-10-09 22:08:15993TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv4ToIPv6Any) {
henrike@webrtc.orgf0488722014-05-13 18:00:26994 CrossFamilyDatagramTest(SocketAddress("0.0.0.0", 0),
995 SocketAddress("::", 5000),
996 true);
997}
998
henrike@webrtc.orgc732a3e2014-10-09 22:08:15999TEST_F(VirtualSocketServerTest, CanSendDatagramFromMappedIPv6ToIPv4Any) {
henrike@webrtc.orgf0488722014-05-13 18:00:261000 CrossFamilyDatagramTest(SocketAddress("::ffff:127.0.0.1", 0),
1001 SocketAddress("0.0.0.0", 5000),
1002 true);
1003}
1004
henrike@webrtc.orgc732a3e2014-10-09 22:08:151005TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToIPv4Any) {
henrike@webrtc.orgf0488722014-05-13 18:00:261006 CrossFamilyDatagramTest(SocketAddress("::2", 0),
1007 SocketAddress("0.0.0.0", 5000),
1008 false);
1009}
1010
henrike@webrtc.orgc732a3e2014-10-09 22:08:151011TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToMappedIPv6) {
henrike@webrtc.orgf0488722014-05-13 18:00:261012 CrossFamilyDatagramTest(SocketAddress("::2", 0),
1013 SocketAddress("::ffff:127.0.0.1", 5000),
1014 false);
1015}
1016
henrike@webrtc.orgc732a3e2014-10-09 22:08:151017TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToIPv6Any) {
henrike@webrtc.orgf0488722014-05-13 18:00:261018 CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
1019 SocketAddress("::", 5000),
1020 true);
1021}
1022
henrike@webrtc.orgc732a3e2014-10-09 22:08:151023TEST_F(VirtualSocketServerTest, CantSendDatagramFromIPv4ToUnMappedIPv6) {
henrike@webrtc.orgf0488722014-05-13 18:00:261024 CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
1025 SocketAddress("::1", 5000),
1026 false);
1027}
1028
henrike@webrtc.orgc732a3e2014-10-09 22:08:151029TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToMappedIPv6) {
henrike@webrtc.orgf0488722014-05-13 18:00:261030 CrossFamilyDatagramTest(SocketAddress("127.0.0.1", 0),
1031 SocketAddress("::ffff:127.0.0.2", 5000),
1032 true);
1033}
1034
henrike@webrtc.orgc732a3e2014-10-09 22:08:151035TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
henrike@webrtc.orgf0488722014-05-13 18:00:261036 CrossFamilyDatagramTest(SocketAddress("::", 0),
1037 SocketAddress("0.0.0.0", 5000),
1038 true);
1039}
1040
Taylor Brandstettere7536412016-09-09 20:16:151041TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
1042 AsyncSocket* socket1 =
nisse32f25052017-05-08 08:57:181043 ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
1044 std::unique_ptr<AsyncSocket> socket2 =
1045 WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
Taylor Brandstettere7536412016-09-09 20:16:151046 socket1->Bind(kIPv4AnyAddress);
1047 socket2->Bind(kIPv4AnyAddress);
deadbeef22e08142017-06-12 21:30:281048 auto client1 =
1049 MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket1), &fake_clock_);
Taylor Brandstettere7536412016-09-09 20:16:151050
nisse32f25052017-05-08 08:57:181051 ss_.SetSendingBlocked(true);
Taylor Brandstettere7536412016-09-09 20:16:151052 EXPECT_EQ(-1, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
1053 EXPECT_TRUE(socket1->IsBlocking());
1054 EXPECT_EQ(0, client1->ready_to_send_count());
1055
nisse32f25052017-05-08 08:57:181056 ss_.SetSendingBlocked(false);
Taylor Brandstettere7536412016-09-09 20:16:151057 EXPECT_EQ(1, client1->ready_to_send_count());
1058 EXPECT_EQ(3, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
1059}
1060
1061TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
1062 constexpr size_t kBufferSize = 1024;
nisse32f25052017-05-08 08:57:181063 ss_.set_send_buffer_capacity(kBufferSize);
1064 ss_.set_recv_buffer_capacity(kBufferSize);
Taylor Brandstettere7536412016-09-09 20:16:151065
kwibergd0d81482017-04-18 10:18:221066 StreamSink sink;
nisse32f25052017-05-08 08:57:181067 std::unique_ptr<AsyncSocket> socket1 =
1068 WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
1069 std::unique_ptr<AsyncSocket> socket2 =
1070 WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
1071 sink.Monitor(socket1.get());
1072 sink.Monitor(socket2.get());
Taylor Brandstettere7536412016-09-09 20:16:151073 socket1->Bind(kIPv4AnyAddress);
1074 socket2->Bind(kIPv4AnyAddress);
1075
1076 // Connect sockets.
1077 EXPECT_EQ(0, socket1->Connect(socket2->GetLocalAddress()));
1078 EXPECT_EQ(0, socket2->Connect(socket1->GetLocalAddress()));
nisse32f25052017-05-08 08:57:181079 ss_.ProcessMessagesUntilIdle();
Taylor Brandstettere7536412016-09-09 20:16:151080
1081 char data[kBufferSize] = {};
1082
1083 // First Send call will fill the send buffer but not send anything.
nisse32f25052017-05-08 08:57:181084 ss_.SetSendingBlocked(true);
Taylor Brandstettere7536412016-09-09 20:16:151085 EXPECT_EQ(static_cast<int>(kBufferSize), socket1->Send(data, kBufferSize));
nisse32f25052017-05-08 08:57:181086 ss_.ProcessMessagesUntilIdle();
1087 EXPECT_FALSE(sink.Check(socket1.get(), SSE_WRITE));
1088 EXPECT_FALSE(sink.Check(socket2.get(), SSE_READ));
Taylor Brandstettere7536412016-09-09 20:16:151089 EXPECT_FALSE(socket1->IsBlocking());
1090
1091 // Since the send buffer is full, next Send will result in EWOULDBLOCK.
1092 EXPECT_EQ(-1, socket1->Send(data, kBufferSize));
nisse32f25052017-05-08 08:57:181093 EXPECT_FALSE(sink.Check(socket1.get(), SSE_WRITE));
1094 EXPECT_FALSE(sink.Check(socket2.get(), SSE_READ));
Taylor Brandstettere7536412016-09-09 20:16:151095 EXPECT_TRUE(socket1->IsBlocking());
1096
1097 // When sending is unblocked, the buffered data should be sent and
1098 // SignalWriteEvent should fire.
nisse32f25052017-05-08 08:57:181099 ss_.SetSendingBlocked(false);
1100 ss_.ProcessMessagesUntilIdle();
1101 EXPECT_TRUE(sink.Check(socket1.get(), SSE_WRITE));
1102 EXPECT_TRUE(sink.Check(socket2.get(), SSE_READ));
Taylor Brandstettere7536412016-09-09 20:16:151103}
1104
henrike@webrtc.orgf0488722014-05-13 18:00:261105TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) {
Peter Boström0c4e06b2015-10-07 10:23:211106 const uint32_t kTestMean[] = {10, 100, 333, 1000};
henrike@webrtc.orgf0488722014-05-13 18:00:261107 const double kTestDev[] = { 0.25, 0.1, 0.01 };
Taylor Brandstettere7536412016-09-09 20:16:151108 // TODO(deadbeef): The current code only works for 1000 data points or more.
Peter Boström0c4e06b2015-10-07 10:23:211109 const uint32_t kTestSamples[] = {/*10, 100,*/ 1000};
tfarina5237aaf2015-11-11 07:44:301110 for (size_t midx = 0; midx < arraysize(kTestMean); ++midx) {
1111 for (size_t didx = 0; didx < arraysize(kTestDev); ++didx) {
1112 for (size_t sidx = 0; sidx < arraysize(kTestSamples); ++sidx) {
henrike@webrtc.orgf0488722014-05-13 18:00:261113 ASSERT_LT(0u, kTestSamples[sidx]);
Peter Boström0c4e06b2015-10-07 10:23:211114 const uint32_t kStdDev =
1115 static_cast<uint32_t>(kTestDev[didx] * kTestMean[midx]);
henrike@webrtc.orgf0488722014-05-13 18:00:261116 VirtualSocketServer::Function* f =
1117 VirtualSocketServer::CreateDistribution(kTestMean[midx],
1118 kStdDev,
1119 kTestSamples[sidx]);
deadbeef37f5ecf2017-02-27 22:06:411120 ASSERT_TRUE(nullptr != f);
henrike@webrtc.orgf0488722014-05-13 18:00:261121 ASSERT_EQ(kTestSamples[sidx], f->size());
1122 double sum = 0;
Peter Boström0c4e06b2015-10-07 10:23:211123 for (uint32_t i = 0; i < f->size(); ++i) {
henrike@webrtc.orgf0488722014-05-13 18:00:261124 sum += (*f)[i].second;
1125 }
1126 const double mean = sum / f->size();
1127 double sum_sq_dev = 0;
Peter Boström0c4e06b2015-10-07 10:23:211128 for (uint32_t i = 0; i < f->size(); ++i) {
henrike@webrtc.orgf0488722014-05-13 18:00:261129 double dev = (*f)[i].second - mean;
1130 sum_sq_dev += dev * dev;
1131 }
1132 const double stddev = sqrt(sum_sq_dev / f->size());
1133 EXPECT_NEAR(kTestMean[midx], mean, 0.1 * kTestMean[midx])
1134 << "M=" << kTestMean[midx]
1135 << " SD=" << kStdDev
1136 << " N=" << kTestSamples[sidx];
1137 EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
1138 << "M=" << kTestMean[midx]
1139 << " SD=" << kStdDev
1140 << " N=" << kTestSamples[sidx];
1141 delete f;
1142 }
1143 }
1144 }
1145}