Change to use local Random object instead of global rand() in the RtcEventLog unit test.

webrtc/call/rtc_event_log_unittest.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
 #ifdef ENABLE_RTC_EVENT_LOG
 
-#include <stdio.h>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/call.h"
 #include "webrtc/call/rtc_event_log.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
 #include "webrtc/system_wrappers/interface/clock.h"
+#include "webrtc/test/random.h"
 #include "webrtc/test/test_suite.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/gtest_disable.h"
 
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/call/rtc_event_log.pb.h"
 #else
 #include "webrtc/call/rtc_event_log.pb.h"
 #endif
@@ skipping 246 matching lines @@
 }
 
 /*
  * Bit number i of extension_bitvector is set to indicate the
  * presence of extension number i from kExtensionTypes / kExtensionNames.
  * The least significant bit extension_bitvector has number 0.
  */
 size_t GenerateRtpPacket(uint32_t extensions_bitvector,
                          uint32_t csrcs_count,
                          uint8_t* packet,
-                         size_t packet_size) {
+                         size_t packet_size,
+                         test::Random& prng) {
   RTC_CHECK_GE(packet_size, 16 + 4 * csrcs_count + 4 * kNumExtensions);
   Clock* clock = Clock::GetRealTimeClock();
 
   RTPSender rtp_sender(false,     // bool audio
                        clock,     // Clock* clock
                        nullptr,   // Transport*
                        nullptr,   // RtpAudioFeedback*
                        nullptr,   // PacedSender*
                        nullptr,   // PacketRouter*
                        nullptr,   // SendTimeObserver*
                        nullptr,   // BitrateStatisticsObserver*
                        nullptr,   // FrameCountObserver*
                        nullptr);  // SendSideDelayObserver*
 
   std::vector<uint32_t> csrcs;
   for (unsigned i = 0; i < csrcs_count; i++) {
-    csrcs.push_back(rand());
+    csrcs.push_back(prng.Rand(0, 1000000000));

[the sun, 2015/10/19 11:47:26]

Duplicated a lot. Would it make sense to add a helper function on Random?

template<typename T> T Rand() {
  return Rand(std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
}

then call site would use e.g. prng.Rand<uint16_t>() etc

Could even make a specialization for bool:

template<bool> bool Rand() {
  return Rand(0, 1) == 1;
}

Maybe overkill. WDYT?

[terelius, 2015/10/21 12:18:28]

I was actually wishing for a function which returns a random bool, but I decided
against it because the name "RandBool" was too ugly. The template specialization
seems a lot less ad hoc. :)

   }
   rtp_sender.SetCsrcs(csrcs);
-  rtp_sender.SetSSRC(rand());
-  rtp_sender.SetStartTimestamp(rand(), true);
-  rtp_sender.SetSequenceNumber(rand());
+  rtp_sender.SetSSRC(prng.Rand(0, 1000000000));
+  rtp_sender.SetStartTimestamp(prng.Rand(0, 1000000000), true);
+  rtp_sender.SetSequenceNumber(prng.Rand(0, 16535));
 
   for (unsigned i = 0; i < kNumExtensions; i++) {
     if (extensions_bitvector & (1u << i)) {
       rtp_sender.RegisterRtpHeaderExtension(kExtensionTypes[i], i + 1);
     }
   }
 
-  int8_t payload_type = rand() % 128;
-  bool marker_bit = (rand() % 2 == 1);
-  uint32_t capture_timestamp = rand();
-  int64_t capture_time_ms = rand();
-  bool timestamp_provided = (rand() % 2 == 1);
-  bool inc_sequence_number = (rand() % 2 == 1);
+  int8_t payload_type = prng.Rand(0, 127);
+  bool marker_bit = (prng.Rand(0, 1) == 1);
+  uint32_t capture_timestamp = prng.Rand(0, 1000000000);
+  int64_t capture_time_ms = prng.Rand(0, 1000000000);
+  bool timestamp_provided = (prng.Rand(0, 1) == 1);
+  bool inc_sequence_number = (prng.Rand(0, 1) == 1);
 
   size_t header_size = rtp_sender.BuildRTPheader(
       packet, payload_type, marker_bit, capture_timestamp, capture_time_ms,
       timestamp_provided, inc_sequence_number);
 
   for (size_t i = header_size; i < packet_size; i++) {
-    packet[i] = rand();
+    packet[i] = prng.Rand(0, 1000000000);
   }
 
   return header_size;
 }
 
-void GenerateRtcpPacket(uint8_t* packet, size_t packet_size) {
+void GenerateRtcpPacket(uint8_t* packet,
+                        size_t packet_size,
+                        test::Random& prng) {
   for (size_t i = 0; i < packet_size; i++) {
-    packet[i] = rand();
+    packet[i] = prng.Rand(0, 1000000000);
   }
 }
 
 void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
-                                VideoReceiveStream::Config* config) {
+                                VideoReceiveStream::Config* config,
+                                test::Random& prng) {
   // Create a map from a payload type to an encoder name.
   VideoReceiveStream::Decoder decoder;
-  decoder.payload_type = rand();
-  decoder.payload_name = (rand() % 2 ? "VP8" : "H264");
+  decoder.payload_type = prng.Rand(0, 1000000000);
+  decoder.payload_name = (prng.Rand(0, 1) ? "VP8" : "H264");
   config->decoders.push_back(decoder);
   // Add SSRCs for the stream.
-  config->rtp.remote_ssrc = rand();
-  config->rtp.local_ssrc = rand();
+  config->rtp.remote_ssrc = prng.Rand(0, 1000000000);
+  config->rtp.local_ssrc = prng.Rand(0, 1000000000);
   // Add extensions and settings for RTCP.
   config->rtp.rtcp_mode =
-      rand() % 2 ? RtcpMode::kCompound : RtcpMode::kReducedSize;
-  config->rtp.rtcp_xr.receiver_reference_time_report = (rand() % 2 == 1);
-  config->rtp.remb = (rand() % 2 == 1);
+      prng.Rand(0, 1) ? RtcpMode::kCompound : RtcpMode::kReducedSize;
+  config->rtp.rtcp_xr.receiver_reference_time_report = (prng.Rand(0, 1) == 1);
+  config->rtp.remb = (prng.Rand(0, 1) == 1);
   // Add a map from a payload type to a new ssrc and a new payload type for RTX.
   VideoReceiveStream::Config::Rtp::Rtx rtx_pair;
-  rtx_pair.ssrc = rand();
-  rtx_pair.payload_type = rand();
-  config->rtp.rtx.insert(std::make_pair(rand(), rtx_pair));
+  rtx_pair.ssrc = prng.Rand(0, 1000000000);
+  rtx_pair.payload_type = prng.Rand(0, 1000000000);
+  config->rtp.rtx.insert(std::make_pair(prng.Rand(0, 1000000000), rtx_pair));
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
     if (extensions_bitvector & (1u << i)) {
       config->rtp.extensions.push_back(
-          RtpExtension(kExtensionNames[i], rand()));
+          RtpExtension(kExtensionNames[i], prng.Rand(0, 1000000000)));
     }
   }
 }
 
 void GenerateVideoSendConfig(uint32_t extensions_bitvector,
-                             VideoSendStream::Config* config) {
+                             VideoSendStream::Config* config,
+                             test::Random& prng) {
   // Create a map from a payload type to an encoder name.
-  config->encoder_settings.payload_type = rand();
-  config->encoder_settings.payload_name = (rand() % 2 ? "VP8" : "H264");
+  config->encoder_settings.payload_type = prng.Rand(0, 1000000000);
+  config->encoder_settings.payload_name = (prng.Rand(0, 1) ? "VP8" : "H264");
   // Add SSRCs for the stream.
-  config->rtp.ssrcs.push_back(rand());
+  config->rtp.ssrcs.push_back(prng.Rand(0, 1000000000));
   // Add a map from a payload type to new ssrcs and a new payload type for RTX.
-  config->rtp.rtx.ssrcs.push_back(rand());
-  config->rtp.rtx.payload_type = rand();
+  config->rtp.rtx.ssrcs.push_back(prng.Rand(0, 1000000000));
+  config->rtp.rtx.payload_type = prng.Rand(0, 1000000000);
   // Add a CNAME.
   config->rtp.c_name = "some.user@some.host";
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
     if (extensions_bitvector & (1u << i)) {
       config->rtp.extensions.push_back(
-          RtpExtension(kExtensionNames[i], rand()));
+          RtpExtension(kExtensionNames[i], prng.Rand(0, 1000000000)));
     }
   }
 }
 
 // Test for the RtcEventLog class. Dumps some RTP packets and other events
 // to disk, then reads them back to see if they match.
 void LogSessionAndReadBack(size_t rtp_count,
                            size_t rtcp_count,
                            size_t playout_count,
                            uint32_t extensions_bitvector,
                            uint32_t csrcs_count,
                            unsigned int random_seed) {
   ASSERT_LE(rtcp_count, rtp_count);
   ASSERT_LE(playout_count, rtp_count);
   std::vector<rtc::Buffer> rtp_packets;
   std::vector<rtc::Buffer> rtcp_packets;
   std::vector<size_t> rtp_header_sizes;
   std::vector<uint32_t> playout_ssrcs;
 
   VideoReceiveStream::Config receiver_config(nullptr);
   VideoSendStream::Config sender_config(nullptr);
 
-  srand(random_seed);
+  test::Random prng(random_seed);
 
   // Create rtp_count RTP packets containing random data.
   for (size_t i = 0; i < rtp_count; i++) {
-    size_t packet_size = 1000 + rand() % 64;
+    size_t packet_size = prng.Rand(1000, 1100);
     rtp_packets.push_back(rtc::Buffer(packet_size));
-    size_t header_size = GenerateRtpPacket(extensions_bitvector, csrcs_count,
-                                           rtp_packets[i].data(), packet_size);
+    size_t header_size =
+        GenerateRtpPacket(extensions_bitvector, csrcs_count,
+                          rtp_packets[i].data(), packet_size, prng);
     rtp_header_sizes.push_back(header_size);
   }
   // Create rtcp_count RTCP packets containing random data.
   for (size_t i = 0; i < rtcp_count; i++) {
-    size_t packet_size = 1000 + rand() % 64;
+    size_t packet_size = prng.Rand(1000, 1100);
     rtcp_packets.push_back(rtc::Buffer(packet_size));
-    GenerateRtcpPacket(rtcp_packets[i].data(), packet_size);
+    GenerateRtcpPacket(rtcp_packets[i].data(), packet_size, prng);
   }
   // Create playout_count random SSRCs to use when logging AudioPlayout events.
   for (size_t i = 0; i < playout_count; i++) {
-    playout_ssrcs.push_back(static_cast<uint32_t>(rand()));
+    playout_ssrcs.push_back(static_cast<uint32_t>(prng.Rand(0, 1000000000)));
   }
   // Create configurations for the video streams.
-  GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config);
-  GenerateVideoSendConfig(extensions_bitvector, &sender_config);
+  GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config, prng);
+  GenerateVideoSendConfig(extensions_bitvector, &sender_config, prng);
   const int config_count = 2;
 
   // Find the name of the current test, in order to use it as a temporary
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // When log_dumper goes out of scope, it causes the log file to be flushed
   // to disk.
@@ skipping 87 matching lines @@
   LogSessionAndReadBack(8, 2, 0, extensions, 0, 3141592653u);
 
   extensions = (1u << kNumExtensions) - 1;  // Enable all header extensions
   LogSessionAndReadBack(9, 2, 3, extensions, 2, 2718281828u);
 
   // Try all combinations of header extensions and up to 2 CSRCS.
   for (extensions = 0; extensions < (1u << kNumExtensions); extensions++) {
     for (uint32_t csrcs_count = 0; csrcs_count < 3; csrcs_count++) {
       LogSessionAndReadBack(5 + extensions,   // Number of RTP packets.
                             2 + csrcs_count,  // Number of RTCP packets.
-                            3 + csrcs_count,  // Number of playout events
-                            extensions,       // Bit vector choosing extensions
-                            csrcs_count,      // Number of contributing sources
-                            rand());
+                            3 + csrcs_count,  // Number of playout events.
+                            extensions,       // Bit vector choosing extensions.
+                            csrcs_count,      // Number of contributing sources.
+                            extensions + csrcs_count);  // Random seed.
     }
   }
 }
 
 // Tests that the event queue works correctly, i.e. drops old RTP, RTCP and
 // debug events, but keeps config events even if they are older than the limit.
 void DropOldEvents(uint32_t extensions_bitvector,
                    uint32_t csrcs_count,
                    unsigned int random_seed) {
   rtc::Buffer old_rtp_packet;
   rtc::Buffer recent_rtp_packet;
   rtc::Buffer old_rtcp_packet;
   rtc::Buffer recent_rtcp_packet;
 
   VideoReceiveStream::Config receiver_config(nullptr);
   VideoSendStream::Config sender_config(nullptr);
 
-  srand(random_seed);
+  test::Random prng(random_seed);
 
   // Create two RTP packets containing random data.
-  size_t packet_size = 1000 + rand() % 64;
+  size_t packet_size = prng.Rand(1000, 1100);
   old_rtp_packet.SetSize(packet_size);
   GenerateRtpPacket(extensions_bitvector, csrcs_count, old_rtp_packet.data(),
-                    packet_size);
-  packet_size = 1000 + rand() % 64;
+                    packet_size, prng);
+  packet_size = prng.Rand(1000, 1100);
   recent_rtp_packet.SetSize(packet_size);
-  size_t recent_header_size = GenerateRtpPacket(
-      extensions_bitvector, csrcs_count, recent_rtp_packet.data(), packet_size);
+  size_t recent_header_size =
+      GenerateRtpPacket(extensions_bitvector, csrcs_count,
+                        recent_rtp_packet.data(), packet_size, prng);
 
   // Create two RTCP packets containing random data.
-  packet_size = 1000 + rand() % 64;
+  packet_size = prng.Rand(1000, 1100);
   old_rtcp_packet.SetSize(packet_size);
-  GenerateRtcpPacket(old_rtcp_packet.data(), packet_size);
-  packet_size = 1000 + rand() % 64;
+  GenerateRtcpPacket(old_rtcp_packet.data(), packet_size, prng);
+  packet_size = prng.Rand(1000, 1100);
   recent_rtcp_packet.SetSize(packet_size);
-  GenerateRtcpPacket(recent_rtcp_packet.data(), packet_size);
+  GenerateRtcpPacket(recent_rtcp_packet.data(), packet_size, prng);
 
   // Create configurations for the video streams.
-  GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config);
-  GenerateVideoSendConfig(extensions_bitvector, &sender_config);
+  GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config, prng);
+  GenerateVideoSendConfig(extensions_bitvector, &sender_config, prng);
 
   // Find the name of the current test, in order to use it as a temporary
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // The log file will be flushed to disk when the log_dumper goes out of scope.
   {
     rtc::scoped_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
@@ skipping 40 matching lines @@
   // Enable all header extensions
   uint32_t extensions = (1u << kNumExtensions) - 1;
   uint32_t csrcs_count = 2;
   DropOldEvents(extensions, csrcs_count, 141421356);
   DropOldEvents(extensions, csrcs_count, 173205080);
 }
 
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG