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

talk/app/webrtc/statscollector_unittest.cc

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 60 matching lines @@
 }  // namespace cricket
 
 namespace webrtc {
 
 // Error return values
 const char kNotFound[] = "NOT FOUND";
 
 // Constant names for track identification.
 const char kLocalTrackId[] = "local_track_id";
 const char kRemoteTrackId[] = "remote_track_id";
-const uint32 kSsrcOfTrack = 1234;
+const uint32_t kSsrcOfTrack = 1234;
 
 class MockWebRtcSession : public webrtc::WebRtcSession {
  public:
   explicit MockWebRtcSession(cricket::ChannelManager* channel_manager)
     : WebRtcSession(channel_manager, rtc::Thread::Current(),
                     rtc::Thread::Current(), NULL, NULL) {
   }
   MOCK_METHOD0(voice_channel, cricket::VoiceChannel*());
   MOCK_METHOD0(video_channel, cricket::VideoChannel*());
   MOCK_CONST_METHOD0(mediastream_signaling, const MediaStreamSignaling*());
   // Libjingle uses "local" for a outgoing track, and "remote" for a incoming
   // track.
-  MOCK_METHOD2(GetLocalTrackIdBySsrc, bool(uint32, std::string*));
-  MOCK_METHOD2(GetRemoteTrackIdBySsrc, bool(uint32, std::string*));
+  MOCK_METHOD2(GetLocalTrackIdBySsrc, bool(uint32_t, std::string*));
+  MOCK_METHOD2(GetRemoteTrackIdBySsrc, bool(uint32_t, std::string*));
   MOCK_METHOD1(GetTransportStats, bool(cricket::SessionStats*));
   MOCK_METHOD2(GetLocalCertificate,
                bool(const std::string& transport_name,
                     rtc::scoped_refptr<rtc::RTCCertificate>* certificate));
   MOCK_METHOD2(GetRemoteSSLCertificate,
                bool(const std::string& transport_name,
                     rtc::SSLCertificate** cert));
 };
 
 class MockVideoMediaChannel : public cricket::FakeVideoMediaChannel {
@@ skipping 188 matching lines @@
 
 void VerifyVoiceReceiverInfoReport(
     const StatsReport* report,
     const cricket::VoiceReceiverInfo& info) {
   std::string value_in_report;
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameAudioOutputLevel, &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.audio_level), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameBytesReceived, &value_in_report));
-  EXPECT_EQ(rtc::ToString<int64>(info.bytes_rcvd), value_in_report);
+  EXPECT_EQ(rtc::ToString<int64_t>(info.bytes_rcvd), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameJitterReceived, &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.jitter_ms), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameJitterBufferMs, &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.jitter_buffer_ms), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNamePreferredJitterBufferMs,
       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.jitter_buffer_preferred_ms),
@@ skipping 45 matching lines @@
 
 
 void VerifyVoiceSenderInfoReport(const StatsReport* report,
                                  const cricket::VoiceSenderInfo& sinfo) {
   std::string value_in_report;
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameCodecName, &value_in_report));
   EXPECT_EQ(sinfo.codec_name, value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameBytesSent, &value_in_report));
-  EXPECT_EQ(rtc::ToString<int64>(sinfo.bytes_sent), value_in_report);
+  EXPECT_EQ(rtc::ToString<int64_t>(sinfo.bytes_sent), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNamePacketsSent, &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(sinfo.packets_sent), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNamePacketsLost, &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(sinfo.packets_lost), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameRtt, &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(sinfo.rtt_ms), value_in_report);
   EXPECT_TRUE(GetValue(
@@ skipping 222 matching lines @@
     // Verify the existence of the track report.
     const StatsReport* report = FindNthReportByType(
         *reports, StatsReport::kStatsReportTypeSsrc, 1);
     EXPECT_FALSE(report == NULL);
     EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
     std::string track_id = ExtractSsrcStatsValue(
         *reports, StatsReport::kStatsValueNameTrackId);
     EXPECT_EQ(audio_track->id(), track_id);
     std::string ssrc_id = ExtractSsrcStatsValue(
         *reports, StatsReport::kStatsValueNameSsrc);
-    EXPECT_EQ(rtc::ToString<uint32>(kSsrcOfTrack), ssrc_id);
+    EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
     // Verifies the values in the track report.
     if (voice_sender_info) {
       UpdateVoiceSenderInfoFromAudioTrack(audio_track, voice_sender_info);
       VerifyVoiceSenderInfoReport(report, *voice_sender_info);
     }
     if (voice_receiver_info) {
       VerifyVoiceReceiverInfoReport(report, *voice_receiver_info);
     }
 
     // Verify we get the same result by passing a track to GetStats().
     StatsReports track_reports;  // returned values.
     stats->GetStats(audio_track, &track_reports);
     const StatsReport* track_report = FindNthReportByType(
         track_reports, StatsReport::kStatsReportTypeSsrc, 1);
     EXPECT_TRUE(track_report);
     EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
     track_id = ExtractSsrcStatsValue(track_reports,
                                      StatsReport::kStatsValueNameTrackId);
     EXPECT_EQ(audio_track->id(), track_id);
     ssrc_id = ExtractSsrcStatsValue(track_reports,
                                     StatsReport::kStatsValueNameSsrc);
-    EXPECT_EQ(rtc::ToString<uint32>(kSsrcOfTrack), ssrc_id);
+    EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
     if (voice_sender_info)
       VerifyVoiceSenderInfoReport(track_report, *voice_sender_info);
     if (voice_receiver_info)
     VerifyVoiceReceiverInfoReport(track_report, *voice_receiver_info);
   }
 
   void TestCertificateReports(const rtc::FakeSSLCertificate& local_cert,
                               const std::vector<std::string>& local_ders,
                               const rtc::FakeSSLCertificate& remote_cert,
                               const std::vector<std::string>& remote_ders) {
@@ skipping 121 matching lines @@
 
   StatsReport::Id reportId = StatsReport::NewTypedIntId(
       StatsReport::kStatsReportTypeDataChannel, id);
 
   EXPECT_TRUE(reportId->Equals(report->id()));
 
   EXPECT_EQ(stats.GetTimeNow(), report->timestamp());
   EXPECT_EQ(label, ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,
                                      reports,
                                      StatsReport::kStatsValueNameLabel));
-  EXPECT_EQ(rtc::ToString<int64>(id),
-            ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,
-                              reports,
+  EXPECT_EQ(rtc::ToString<int64_t>(id),
+            ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
                               StatsReport::kStatsValueNameDataChannelId));
   EXPECT_EQ(state, ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,
                                      reports,
                                      StatsReport::kStatsValueNameState));
   EXPECT_EQ("", ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,
                                   reports,
                                   StatsReport::kStatsValueNameProtocol));
 }
 
 // This test verifies that 64-bit counters are passed successfully.
@@ skipping 12 matching lines @@
       .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
                             Return(true)));
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVideoChannelName, false);
   StatsReports reports;  // returned values.
   cricket::VideoSenderInfo video_sender_info;
   cricket::VideoMediaInfo stats_read;
   // The number of bytes must be larger than 0xFFFFFFFF for this test.
-  const int64 kBytesSent = 12345678901234LL;
+  const int64_t kBytesSent = 12345678901234LL;
   const std::string kBytesSentString("12345678901234");
 
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Construct a stats value to read.
   video_sender_info.add_ssrc(1234);
   video_sender_info.bytes_sent = kBytesSent;
   stats_read.senders.push_back(video_sender_info);
 
@@ skipping 27 matching lines @@
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVideoChannelName, false);
 
   StatsReports reports;  // returned values.
   cricket::VideoSenderInfo video_sender_info;
   cricket::VideoMediaInfo stats_read;
   // Set up an SSRC just to test that we get both kinds of stats back: SSRC and
   // BWE.
-  const int64 kBytesSent = 12345678901234LL;
+  const int64_t kBytesSent = 12345678901234LL;
   const std::string kBytesSentString("12345678901234");
 
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Construct a stats value to read.
   video_sender_info.add_ssrc(1234);
   video_sender_info.bytes_sent = kBytesSent;
   stats_read.senders.push_back(video_sender_info);
   cricket::BandwidthEstimationInfo bwe;
@@ skipping 94 matching lines @@
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVideoChannelName, false);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Constructs an ssrc stats update.
   cricket::VideoSenderInfo video_sender_info;
   cricket::VideoMediaInfo stats_read;
-  const int64 kBytesSent = 12345678901234LL;
+  const int64_t kBytesSent = 12345678901234LL;
 
   // Construct a stats value to read.
   video_sender_info.add_ssrc(1234);
   video_sender_info.bytes_sent = kBytesSent;
   stats_read.senders.push_back(video_sender_info);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
     .WillOnce(DoAll(SetArgPointee<0>(stats_read),
@@ skipping 15 matching lines @@
   // |reports| should contain at least one session report, one track report,
   // and one ssrc report.
   EXPECT_LE((size_t)3, reports.size());
   track_report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeTrack, 1);
   EXPECT_TRUE(track_report);
   EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());
 
   std::string ssrc_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameSsrc);
-  EXPECT_EQ(rtc::ToString<uint32>(kSsrcOfTrack), ssrc_id);
+  EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
   std::string track_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kLocalTrackId, track_id);
 }
 
 // This test verifies that an SSRC object has the identifier of a Transport
 // stats object, and that this transport stats object exists in stats.
 TEST_F(StatsCollectorTest, TransportObjectLinkedFromSsrcObject) {
   StatsCollectorForTest stats(&session_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
       .WillRepeatedly(Return(false));
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   // The transport_name known by the video channel.
   const std::string kVcName("vcname");
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVcName, false);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Constructs an ssrc stats update.
   cricket::VideoSenderInfo video_sender_info;
   cricket::VideoMediaInfo stats_read;
-  const int64 kBytesSent = 12345678901234LL;
+  const int64_t kBytesSent = 12345678901234LL;
 
   // Construct a stats value to read.
   video_sender_info.add_ssrc(1234);
   video_sender_info.bytes_sent = kBytesSent;
   stats_read.senders.push_back(video_sender_info);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
     .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),
@@ skipping 121 matching lines @@
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVideoChannelName, false);
   AddIncomingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Constructs an ssrc stats update.
   cricket::VideoReceiverInfo video_receiver_info;
   cricket::VideoMediaInfo stats_read;
-  const int64 kNumOfPacketsConcealed = 54321;
+  const int64_t kNumOfPacketsConcealed = 54321;
 
   // Construct a stats value to read.
   video_receiver_info.add_ssrc(1234);
   video_receiver_info.packets_concealed = kNumOfPacketsConcealed;
   stats_read.receivers.push_back(video_receiver_info);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
       .WillOnce(DoAll(SetArgPointee<0>(stats_read),
                       Return(true)));
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   StatsReports reports;
   stats.GetStats(NULL, &reports);
   // |reports| should contain at least one session report, one track report,
   // and one ssrc report.
   EXPECT_LE(static_cast<size_t>(3), reports.size());
   const StatsReport* track_report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeTrack, 1);
   EXPECT_TRUE(track_report);
   EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());
 
   std::string ssrc_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameSsrc);
-  EXPECT_EQ(rtc::ToString<uint32>(kSsrcOfTrack), ssrc_id);
+  EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
   std::string track_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kRemoteTrackId, track_id);
 }
 
 // This test verifies the Ice Candidate report should contain the correct
 // information from local/remote candidates.
 TEST_F(StatsCollectorTest, IceCandidateReport) {
   StatsCollectorForTest stats(&session_);
 
   StatsReports reports;                     // returned values.
 
   const int local_port = 2000;
   const char local_ip[] = "192.168.0.1";
   const int remote_port = 2001;
   const char remote_ip[] = "192.168.0.2";
 
   rtc::SocketAddress local_address(local_ip, local_port);
   rtc::SocketAddress remote_address(remote_ip, remote_port);
   rtc::AdapterType network_type = rtc::ADAPTER_TYPE_ETHERNET;
-  uint32 priority = 1000;
+  uint32_t priority = 1000;
 
   cricket::Candidate c;
   ASSERT(c.id().length() > 0);
   c.set_type(cricket::LOCAL_PORT_TYPE);
   c.set_protocol(cricket::UDP_PROTOCOL_NAME);
   c.set_address(local_address);
   c.set_priority(priority);
   c.set_network_type(network_type);
   std::string report_id = AddCandidateReport(&stats, c, true)->id()->ToString();
   EXPECT_EQ("Cand-" + c.id(), report_id);
@@ skipping 342 matching lines @@
   // The report will exist since we don't remove them in RemoveStream().
   const StatsReport* report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeSsrc, 1);
   EXPECT_FALSE(report == NULL);
   EXPECT_EQ(stats.GetTimeNow(), report->timestamp());
   std::string track_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kLocalTrackId, track_id);
   std::string ssrc_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameSsrc);
-  EXPECT_EQ(rtc::ToString<uint32>(kSsrcOfTrack), ssrc_id);
+  EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
   // Verifies the values in the track report, no value will be changed by the
   // AudioTrackInterface::GetSignalValue() and
   // AudioProcessorInterface::AudioProcessorStats::GetStats();
   VerifyVoiceSenderInfoReport(report, voice_sender_info);
 }
 
 // This test verifies that when ongoing and incoming audio tracks are using
 // the same ssrc, they populate stats reports correctly.
 TEST_F(StatsCollectorTest, LocalAndRemoteTracksWithSameSsrc) {
@@ skipping 128 matching lines @@
   cricket::VoiceSenderInfo new_voice_sender_info;
   InitVoiceSenderInfo(&new_voice_sender_info);
   cricket::VoiceMediaInfo new_stats_read;
   reports.clear();
   SetupAndVerifyAudioTrackStats(
       new_audio_track.get(), stream_.get(), &stats, &voice_channel, kVcName,
       media_channel, &new_voice_sender_info, NULL, &new_stats_read, &reports);
 }
 
 }  // namespace webrtc