Use suffixed {uint,int}{8,16,32,64}_t types.

webrtc/base/virtualsocket_unittest.cc

 /*
  *  Copyright 2006 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <math.h>
 #include <time.h>
 #if defined(WEBRTC_POSIX)
 #include <netinet/in.h>
 #endif
 
 #include "webrtc/base/logging.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/testutils.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/virtualsocketserver.h"
 #include "webrtc/test/testsupport/gtest_disable.h"
 
 using namespace rtc;
 
 // Sends at a constant rate but with random packet sizes.
 struct Sender : public MessageHandler {
-  Sender(Thread* th, AsyncSocket* s, uint32 rt)
-      : thread(th), socket(new AsyncUDPSocket(s)),
-        done(false), rate(rt), count(0) {
+  Sender(Thread* th, AsyncSocket* s, uint32_t rt)
+      : thread(th),
+        socket(new AsyncUDPSocket(s)),
+        done(false),
+        rate(rt),
+        count(0) {
     last_send = rtc::Time();
     thread->PostDelayed(NextDelay(), this, 1);
   }
 
-  uint32 NextDelay() {
-    uint32 size = (rand() % 4096) + 1;
+  uint32_t NextDelay() {
+    uint32_t size = (rand() % 4096) + 1;
     return 1000 * size / rate;
   }
 
   void OnMessage(Message* pmsg) {
     ASSERT_EQ(1u, pmsg->message_id);
 
     if (done)
       return;
 
-    uint32 cur_time = rtc::Time();
-    uint32 delay = cur_time - last_send;
-    uint32 size = rate * delay / 1000;
-    size = std::min<uint32>(size, 4096);
-    size = std::max<uint32>(size, sizeof(uint32));
+    uint32_t cur_time = rtc::Time();
+    uint32_t delay = cur_time - last_send;
+    uint32_t size = rate * delay / 1000;
+    size = std::min<uint32_t>(size, 4096);
+    size = std::max<uint32_t>(size, sizeof(uint32_t));
 
     count += size;
     memcpy(dummy, &cur_time, sizeof(cur_time));
     socket->Send(dummy, size, options);
 
     last_send = cur_time;
     thread->PostDelayed(NextDelay(), this, 1);
   }
 
   Thread* thread;
   scoped_ptr<AsyncUDPSocket> socket;
   rtc::PacketOptions options;
   bool done;
-  uint32 rate;  // bytes per second
-  uint32 count;
-  uint32 last_send;
+  uint32_t rate;  // bytes per second
+  uint32_t count;
+  uint32_t last_send;
   char dummy[4096];
 };
 
 struct Receiver : public MessageHandler, public sigslot::has_slots<> {
-  Receiver(Thread* th, AsyncSocket* s, uint32 bw)
-      : thread(th), socket(new AsyncUDPSocket(s)), bandwidth(bw), done(false),
-        count(0), sec_count(0), sum(0), sum_sq(0), samples(0) {
+  Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
+      : thread(th),
+        socket(new AsyncUDPSocket(s)),
+        bandwidth(bw),
+        done(false),
+        count(0),
+        sec_count(0),
+        sum(0),
+        sum_sq(0),
+        samples(0) {
     socket->SignalReadPacket.connect(this, &Receiver::OnReadPacket);
     thread->PostDelayed(1000, this, 1);
   }
 
   ~Receiver() {
     thread->Clear(this);
   }
 
   void OnReadPacket(AsyncPacketSocket* s, const char* data, size_t size,
                     const SocketAddress& remote_addr,
                     const PacketTime& packet_time) {
     ASSERT_EQ(socket.get(), s);
     ASSERT_GE(size, 4U);
 
     count += size;
     sec_count += size;
 
-    uint32 send_time = *reinterpret_cast<const uint32*>(data);
-    uint32 recv_time = rtc::Time();
-    uint32 delay = recv_time - send_time;
+    uint32_t send_time = *reinterpret_cast<const uint32_t*>(data);
+    uint32_t recv_time = rtc::Time();
+    uint32_t delay = recv_time - send_time;
     sum += delay;
     sum_sq += delay * delay;
     samples += 1;
   }
 
   void OnMessage(Message* pmsg) {
     ASSERT_EQ(1u, pmsg->message_id);
 
     if (done)
       return;
 
     // It is always possible for us to receive more than expected because
     // packets can be further delayed in delivery.
     if (bandwidth > 0)
       ASSERT_TRUE(sec_count <= 5 * bandwidth / 4);
     sec_count = 0;
     thread->PostDelayed(1000, this, 1);
   }
 
   Thread* thread;
   scoped_ptr<AsyncUDPSocket> socket;
-  uint32 bandwidth;
+  uint32_t bandwidth;
   bool done;
   size_t count;
   size_t sec_count;
   double sum;
   double sum_sq;
-  uint32 samples;
+  uint32_t samples;
 };
 
 class VirtualSocketServerTest : public testing::Test {
  public:
   VirtualSocketServerTest() : ss_(new VirtualSocketServer(NULL)),
                               kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
                               kIPv6AnyAddress(IPAddress(in6addr_any), 0) {
   }
 
   void CheckPortIncrementalization(const SocketAddress& post,
                                    const SocketAddress& pre) {
     EXPECT_EQ(post.port(), pre.port() + 1);
     IPAddress post_ip = post.ipaddr();
     IPAddress pre_ip = pre.ipaddr();
     EXPECT_EQ(pre_ip.family(), post_ip.family());
     if (post_ip.family() == AF_INET) {
       in_addr pre_ipv4 = pre_ip.ipv4_address();
       in_addr post_ipv4 = post_ip.ipv4_address();
       EXPECT_EQ(post_ipv4.s_addr, pre_ipv4.s_addr);
     } else if (post_ip.family() == AF_INET6) {
       in6_addr post_ip6 = post_ip.ipv6_address();
       in6_addr pre_ip6 = pre_ip.ipv6_address();
-      uint32* post_as_ints = reinterpret_cast<uint32*>(&post_ip6.s6_addr);
-      uint32* pre_as_ints = reinterpret_cast<uint32*>(&pre_ip6.s6_addr);
+      uint32_t* post_as_ints = reinterpret_cast<uint32_t*>(&post_ip6.s6_addr);
+      uint32_t* pre_as_ints = reinterpret_cast<uint32_t*>(&pre_ip6.s6_addr);
       EXPECT_EQ(post_as_ints[3], pre_as_ints[3]);
     }
   }
 
   // Test a client can bind to the any address, and all sent packets will have
   // the default route as the source address. Also, it can receive packets sent
   // to the default route.
   void TestDefaultRoute(const IPAddress& default_route) {
     ss_->SetDefaultRoute(default_route);
 
@@ skipping 455 matching lines @@
     }
 
     ss_->ProcessMessagesUntilIdle();
 
     for (char i = 0; i < cNumPackets; ++i) {
       EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer)));
       EXPECT_EQ(static_cast<char>('0' + i), buffer[0]);
     }
 
     // Next, deliver packets at random intervals
-    const uint32 mean = 50;
-    const uint32 stddev = 50;
+    const uint32_t mean = 50;
+    const uint32_t stddev = 50;
 
     ss_->set_delay_mean(mean);
     ss_->set_delay_stddev(stddev);
     ss_->UpdateDelayDistribution();
 
     for (char i = 0; i < cNumPackets; ++i) {
       buffer[0] = 'A' + i;
       EXPECT_EQ(1, a->Send(buffer, 1));
     }
 
@@ skipping 12 matching lines @@
     AsyncSocket* send_socket =
         ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     AsyncSocket* recv_socket =
         ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     ASSERT_EQ(0, send_socket->Bind(initial_addr));
     ASSERT_EQ(0, recv_socket->Bind(initial_addr));
     EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
     EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
     ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
 
-    uint32 bandwidth = 64 * 1024;
+    uint32_t bandwidth = 64 * 1024;
     ss_->set_bandwidth(bandwidth);
 
     Thread* pthMain = Thread::Current();
     Sender sender(pthMain, send_socket, 80 * 1024);
     Receiver receiver(pthMain, recv_socket, bandwidth);
 
     pthMain->ProcessMessages(5000);
     sender.done = true;
     pthMain->ProcessMessages(5000);
 
     ASSERT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
     ASSERT_TRUE(receiver.count <= 6 * bandwidth);  // queue could drain for 1s
 
     ss_->set_bandwidth(0);
   }
 
   // It is important that initial_addr's port has to be 0 such that the
   // incremental port behavior could ensure the 2 Binds result in different
   // address.
   void DelayTest(const SocketAddress& initial_addr) {
     time_t seed = ::time(NULL);
     LOG(LS_VERBOSE) << "seed = " << seed;
     srand(static_cast<unsigned int>(seed));
 
-    const uint32 mean = 2000;
-    const uint32 stddev = 500;
+    const uint32_t mean = 2000;
+    const uint32_t stddev = 500;
 
     ss_->set_delay_mean(mean);
     ss_->set_delay_stddev(stddev);
     ss_->UpdateDelayDistribution();
 
     AsyncSocket* send_socket =
         ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     AsyncSocket* recv_socket =
         ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     ASSERT_EQ(0, send_socket->Bind(initial_addr));
@@ skipping 307 matching lines @@
                           true);
 }
 
 TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
   CrossFamilyDatagramTest(SocketAddress("::", 0),
                           SocketAddress("0.0.0.0", 5000),
                           true);
 }
 
 TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) {
-  const uint32 kTestMean[] = { 10, 100, 333, 1000 };
+  const uint32_t kTestMean[] = {10, 100, 333, 1000};
   const double kTestDev[] = { 0.25, 0.1, 0.01 };
   // TODO: The current code only works for 1000 data points or more.
-  const uint32 kTestSamples[] = { /*10, 100,*/ 1000 };
+  const uint32_t kTestSamples[] = {/*10, 100,*/ 1000};
   for (size_t midx = 0; midx < ARRAY_SIZE(kTestMean); ++midx) {
     for (size_t didx = 0; didx < ARRAY_SIZE(kTestDev); ++didx) {
       for (size_t sidx = 0; sidx < ARRAY_SIZE(kTestSamples); ++sidx) {
         ASSERT_LT(0u, kTestSamples[sidx]);
-        const uint32 kStdDev =
-            static_cast<uint32>(kTestDev[didx] * kTestMean[midx]);
+        const uint32_t kStdDev =
+            static_cast<uint32_t>(kTestDev[didx] * kTestMean[midx]);
         VirtualSocketServer::Function* f =
             VirtualSocketServer::CreateDistribution(kTestMean[midx],
                                                     kStdDev,
                                                     kTestSamples[sidx]);
         ASSERT_TRUE(NULL != f);
         ASSERT_EQ(kTestSamples[sidx], f->size());
         double sum = 0;
-        for (uint32 i = 0; i < f->size(); ++i) {
+        for (uint32_t i = 0; i < f->size(); ++i) {
           sum += (*f)[i].second;
         }
         const double mean = sum / f->size();
         double sum_sq_dev = 0;
-        for (uint32 i = 0; i < f->size(); ++i) {
+        for (uint32_t i = 0; i < f->size(); ++i) {
           double dev = (*f)[i].second - mean;
           sum_sq_dev += dev * dev;
         }
         const double stddev = sqrt(sum_sq_dev / f->size());
         EXPECT_NEAR(kTestMean[midx], mean, 0.1 * kTestMean[midx])
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         delete f;
       }
     }
   }
 }