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

talk/session/media/srtpfilter_unittest.cc

 /*
  * libjingle
  * Copyright 2004 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 28 matching lines @@
 #include "third_party/libsrtp/srtp/crypto/include/err.h"
 #endif
 }
 
 using rtc::CS_AES_CM_128_HMAC_SHA1_80;
 using rtc::CS_AES_CM_128_HMAC_SHA1_32;
 using cricket::CryptoParams;
 using cricket::CS_LOCAL;
 using cricket::CS_REMOTE;
 
-static const uint8 kTestKey1[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234";
-static const uint8 kTestKey2[] = "4321ZYXWVUTSRQPONMLKJIHGFEDCBA";
+static const uint8_t kTestKey1[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234";
+static const uint8_t kTestKey2[] = "4321ZYXWVUTSRQPONMLKJIHGFEDCBA";
 static const int kTestKeyLen = 30;
 static const std::string kTestKeyParams1 =
     "inline:WVNfX19zZW1jdGwgKCkgewkyMjA7fQp9CnVubGVz";
 static const std::string kTestKeyParams2 =
     "inline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR";
 static const std::string kTestKeyParams3 =
     "inline:1234X19zZW1jdGwgKCkgewkyMjA7fQp9CnVubGVz";
 static const std::string kTestKeyParams4 =
     "inline:4567QCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR";
 static const cricket::CryptoParams kTestCryptoParams1(
@@ skipping 31 matching lines @@
     EXPECT_TRUE(f2_.IsActive());
   }
   void TestProtectUnprotect(const std::string& cs1, const std::string& cs2) {
     char rtp_packet[sizeof(kPcmuFrame) + 10];
     char original_rtp_packet[sizeof(kPcmuFrame)];
     char rtcp_packet[sizeof(kRtcpReport) + 4 + 10];
     int rtp_len = sizeof(kPcmuFrame), rtcp_len = sizeof(kRtcpReport), out_len;
     memcpy(rtp_packet, kPcmuFrame, rtp_len);
     // In order to be able to run this test function multiple times we can not
     // use the same sequence number twice. Increase the sequence number by one.
-    rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet) + 2,
-                       ++sequence_number_);
+    rtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet) + 2,
+                 ++sequence_number_);
     memcpy(original_rtp_packet, rtp_packet, rtp_len);
     memcpy(rtcp_packet, kRtcpReport, rtcp_len);
 
     EXPECT_TRUE(f1_.ProtectRtp(rtp_packet, rtp_len,
                                sizeof(rtp_packet), &out_len));
     EXPECT_EQ(out_len, rtp_len + rtp_auth_tag_len(cs1));
     EXPECT_NE(0, memcmp(rtp_packet, original_rtp_packet, rtp_len));
     EXPECT_TRUE(f2_.UnprotectRtp(rtp_packet, out_len, &out_len));
     EXPECT_EQ(rtp_len, out_len);
     EXPECT_EQ(0, memcmp(rtp_packet, original_rtp_packet, rtp_len));
@@ skipping 453 matching lines @@
 #if defined(ENABLE_EXTERNAL_AUTH)
 TEST_F(SrtpFilterTest, TestGetSendAuthParams) {
   EXPECT_TRUE(f1_.SetRtpParams(CS_AES_CM_128_HMAC_SHA1_32,
                                kTestKey1, kTestKeyLen,
                                CS_AES_CM_128_HMAC_SHA1_32,
                                kTestKey2, kTestKeyLen));
   EXPECT_TRUE(f1_.SetRtcpParams(CS_AES_CM_128_HMAC_SHA1_32,
                                 kTestKey1, kTestKeyLen,
                                 CS_AES_CM_128_HMAC_SHA1_32,
                                 kTestKey2, kTestKeyLen));
-  uint8* auth_key = NULL;
+  uint8_t* auth_key = NULL;
   int auth_key_len = 0, auth_tag_len = 0;
   EXPECT_TRUE(f1_.GetRtpAuthParams(&auth_key, &auth_key_len, &auth_tag_len));
   EXPECT_TRUE(auth_key != NULL);
   EXPECT_EQ(20, auth_key_len);
   EXPECT_EQ(4, auth_tag_len);
 }
 #endif
 
 class SrtpSessionTest : public testing::Test {
  protected:
@@ skipping 74 matching lines @@
   EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_32, kTestKey1, kTestKeyLen));
   EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_32, kTestKey1, kTestKeyLen));
   TestProtectRtp(CS_AES_CM_128_HMAC_SHA1_32);
   TestProtectRtcp(CS_AES_CM_128_HMAC_SHA1_32);
   TestUnprotectRtp(CS_AES_CM_128_HMAC_SHA1_32);
   TestUnprotectRtcp(CS_AES_CM_128_HMAC_SHA1_32);
 }
 
 TEST_F(SrtpSessionTest, TestGetSendStreamPacketIndex) {
   EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_32, kTestKey1, kTestKeyLen));
-  int64 index;
+  int64_t index;
   int out_len = 0;
   EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_,
                              sizeof(rtp_packet_), &out_len, &index));
   // |index| will be shifted by 16.
-  int64 be64_index = static_cast<int64>(rtc::NetworkToHost64(1 << 16));
+  int64_t be64_index = static_cast<int64_t>(rtc::NetworkToHost64(1 << 16));
   EXPECT_EQ(be64_index, index);
 }
 
 // Test that we fail to unprotect if someone tampers with the RTP/RTCP paylaods.
 TEST_F(SrtpSessionTest, TestTamperReject) {
   int out_len;
   EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
   EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
   TestProtectRtp(CS_AES_CM_128_HMAC_SHA1_80);
   TestProtectRtcp(CS_AES_CM_128_HMAC_SHA1_80);
@@ skipping 16 matching lines @@
 TEST_F(SrtpSessionTest, TestBuffersTooSmall) {
   int out_len;
   EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
   EXPECT_FALSE(s1_.ProtectRtp(rtp_packet_, rtp_len_,
                               sizeof(rtp_packet_) - 10, &out_len));
   EXPECT_FALSE(s1_.ProtectRtcp(rtcp_packet_, rtcp_len_,
                                sizeof(rtcp_packet_) - 14, &out_len));
 }
 
 TEST_F(SrtpSessionTest, TestReplay) {
-  static const uint16 kMaxSeqnum = static_cast<uint16>(-1);
-  static const uint16 seqnum_big = 62275;
-  static const uint16 seqnum_small = 10;
-  static const uint16 replay_window = 1024;
+  static const uint16_t kMaxSeqnum = static_cast<uint16_t>(-1);
+  static const uint16_t seqnum_big = 62275;
+  static const uint16_t seqnum_small = 10;
+  static const uint16_t replay_window = 1024;
   int out_len;
 
   EXPECT_TRUE(s1_.SetSend(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
   EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
 
   // Initial sequence number.
-  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum_big);
+  rtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_) + 2, seqnum_big);
   EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                              &out_len));
 
   // Replay within the 1024 window should succeed.
-  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
-                     seqnum_big - replay_window + 1);
+  rtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_) + 2,
+               seqnum_big - replay_window + 1);
   EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                              &out_len));
 
   // Replay out side of the 1024 window should fail.
-  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
-                     seqnum_big - replay_window - 1);
+  rtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_) + 2,
+               seqnum_big - replay_window - 1);
   EXPECT_FALSE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                               &out_len));
 
   // Increment sequence number to a small number.
-  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum_small);
+  rtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_) + 2, seqnum_small);
   EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                              &out_len));
 
   // Replay around 0 but out side of the 1024 window should fail.
-  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
-                     kMaxSeqnum + seqnum_small - replay_window - 1);
+  rtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_) + 2,
+               kMaxSeqnum + seqnum_small - replay_window - 1);
   EXPECT_FALSE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                               &out_len));
 
   // Replay around 0 but within the 1024 window should succeed.
-  for (uint16 seqnum = 65000; seqnum < 65003; ++seqnum) {
-    rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum);
+  for (uint16_t seqnum = 65000; seqnum < 65003; ++seqnum) {
+    rtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_) + 2, seqnum);
     EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                                &out_len));
   }
 
   // Go back to normal sequence nubmer.
   // NOTE: without the fix in libsrtp, this would fail. This is because
   // without the fix, the loop above would keep incrementing local sequence
   // number in libsrtp, eventually the new sequence number would go out side
   // of the window.
-  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
-                     seqnum_small + 1);
+  rtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_) + 2, seqnum_small + 1);
   EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                              &out_len));
 }
 
 class SrtpStatTest
     : public testing::Test,
       public sigslot::has_slots<> {
  public:
   SrtpStatTest()
       : ssrc_(0U),
         mode_(-1),
         error_(cricket::SrtpFilter::ERROR_NONE) {
     srtp_stat_.SignalSrtpError.connect(this, &SrtpStatTest::OnSrtpError);
     srtp_stat_.set_signal_silent_time(200);
   }
 
  protected:
-  void OnSrtpError(uint32 ssrc, cricket::SrtpFilter::Mode mode,
+  void OnSrtpError(uint32_t ssrc,
+                   cricket::SrtpFilter::Mode mode,
                    cricket::SrtpFilter::Error error) {
     ssrc_ = ssrc;
     mode_ = mode;
     error_ = error;
   }
   void Reset() {
     ssrc_ = 0U;
     mode_ = -1;
     error_ = cricket::SrtpFilter::ERROR_NONE;
   }
 
   cricket::SrtpStat srtp_stat_;
-  uint32 ssrc_;
+  uint32_t ssrc_;
   int mode_;
   cricket::SrtpFilter::Error error_;
 
  private:
   RTC_DISALLOW_COPY_AND_ASSIGN(SrtpStatTest);
 };
 
 TEST_F(SrtpStatTest, TestProtectRtpError) {
   Reset();
   srtp_stat_.AddProtectRtpResult(1, err_status_ok);
@@ skipping 120 matching lines @@
   srtp_stat_.AddUnprotectRtcpResult(err_status_fail);
   EXPECT_EQ(-1, mode_);
   EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
   // Now the error will be triggered again.
   Reset();
   rtc::Thread::Current()->SleepMs(210);
   srtp_stat_.AddUnprotectRtcpResult(err_status_fail);
   EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
   EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
 }