Fix some signed overflow errors causing undefined behavior (in theory).

webrtc/base/random_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.
  */
 
 #include <math.h>
 
 #include <limits>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/mathutils.h"  // unsigned difference
 #include "webrtc/base/random.h"
 
 namespace webrtc {
 
 namespace {
 // Computes the positive remainder of x/n.
 template <typename T>
 T fdiv_remainder(T x, T n) {
   RTC_CHECK_GE(n, static_cast<T>(0));
   T remainder = x % n;
@@ skipping 84 matching lines @@
 void BucketTestSignedInterval(unsigned int bucket_count,
                               unsigned int samples,
                               int32_t low,
                               int32_t high,
                               int sigma_level,
                               Random* prng) {
   std::vector<unsigned int> buckets(bucket_count, 0);
 
   ASSERT_GE(high, low);
   ASSERT_GE(bucket_count, 2u);
-  uint32_t interval = static_cast<uint32_t>(high - low + 1);
+  uint32_t interval = unsigned_difference<int32_t>(high, low) + 1;
   uint32_t numbers_per_bucket;
   if (interval == 0) {
     // The computation high - low + 1 should be 2^32 but overflowed
     // Hence, bucket_count must be a power of 2
     ASSERT_EQ(bucket_count & (bucket_count - 1), 0u);
     numbers_per_bucket = (0x80000000u / bucket_count) * 2;
   } else {
     ASSERT_EQ(interval % bucket_count, 0u);
     numbers_per_bucket = interval / bucket_count;
   }
 
   for (unsigned int i = 0; i < samples; i++) {
     int32_t sample = prng->Rand(low, high);
     EXPECT_LE(low, sample);
     EXPECT_GE(high, sample);
-    buckets[static_cast<uint32_t>(sample - low) / numbers_per_bucket]++;
+    buckets[unsigned_difference<int32_t>(sample, low) / numbers_per_bucket]++;
   }
 
   for (unsigned int i = 0; i < bucket_count; i++) {
     // Expect the result to be within 3 standard deviations of the mean,
     // or more generally, within sigma_level standard deviations of the mean.
     double mean = static_cast<double>(samples) / bucket_count;
     EXPECT_NEAR(buckets[i], mean, sigma_level * sqrt(mean));
   }
 }
 
 // The range of the random numbers is divided into bucket_count intervals
 // of consecutive numbers. Check that approximately equally many numbers
 // from each inteval are generated.
 void BucketTestUnsignedInterval(unsigned int bucket_count,
                                 unsigned int samples,
                                 uint32_t low,
                                 uint32_t high,
                                 int sigma_level,
                                 Random* prng) {
   std::vector<unsigned int> buckets(bucket_count, 0);
 
   ASSERT_GE(high, low);
   ASSERT_GE(bucket_count, 2u);
-  uint32_t interval = static_cast<uint32_t>(high - low + 1);
+  uint32_t interval = high - low + 1;
   uint32_t numbers_per_bucket;
   if (interval == 0) {
     // The computation high - low + 1 should be 2^32 but overflowed
     // Hence, bucket_count must be a power of 2
     ASSERT_EQ(bucket_count & (bucket_count - 1), 0u);
     numbers_per_bucket = (0x80000000u / bucket_count) * 2;
   } else {
     ASSERT_EQ(interval % bucket_count, 0u);
     numbers_per_bucket = interval / bucket_count;
   }
 
   for (unsigned int i = 0; i < samples; i++) {
     uint32_t sample = prng->Rand(low, high);
     EXPECT_LE(low, sample);
     EXPECT_GE(high, sample);
-    buckets[static_cast<uint32_t>(sample - low) / numbers_per_bucket]++;
+    buckets[(sample - low) / numbers_per_bucket]++;
   }
 
   for (unsigned int i = 0; i < bucket_count; i++) {
     // Expect the result to be within 3 standard deviations of the mean,
     // or more generally, within sigma_level standard deviations of the mean.
     double mean = static_cast<double>(samples) / bucket_count;
     EXPECT_NEAR(buckets[i], mean, sigma_level * sqrt(mean));
   }
 }
 
@@ skipping 111 matching lines @@
     double f_mid = kScale * exp((n - kMean) * (n - kMean) / kDiv);
     double f_right = kScale * exp((n - kMean + 0.5) * (n - kMean + 0.5) / kDiv);
     double normal_dist = (f_left + 4 * f_mid + f_right) / 6;
     // Expect the number of samples to be within 3 standard deviations
     // (rounded up) of the expected number of samples in the bucket.
     EXPECT_NEAR(buckets[n], kN * normal_dist, 3 * sqrt(kN * normal_dist) + 1);
   }
 }
 
 }  // namespace webrtc