Convert some more things to size_t.

webrtc/common_audio/signal_processing/signal_processing_unittest.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 203 matching lines @@
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ((B[kk]>>1), bTmp32[kk]);
     }
 
     WebRtcSpl_MemCpyReversedOrder(&bTmp16[3], b16, kVectorSize);
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ(b16[3-kk], bTmp16[kk]);
     }
 }
 
-TEST_F(SplTest, ExeptionsHandlingMinMaxOperationsTest) {
-  // Test how the functions handle exceptional cases.
-  const size_t kVectorSize = 2;
-  int16_t vector16[kVectorSize] = {0};
-  int32_t vector32[kVectorSize] = {0};
-
-  EXPECT_EQ(-1, WebRtcSpl_MaxAbsValueW16(vector16, 0));
-  EXPECT_EQ(-1, WebRtcSpl_MaxAbsValueW16(NULL, kVectorSize));
-  EXPECT_EQ(WEBRTC_SPL_WORD16_MIN, WebRtcSpl_MaxValueW16(vector16, 0));
-  EXPECT_EQ(WEBRTC_SPL_WORD16_MIN, WebRtcSpl_MaxValueW16(NULL, kVectorSize));
-  EXPECT_EQ(WEBRTC_SPL_WORD16_MAX, WebRtcSpl_MinValueW16(vector16, 0));
-  EXPECT_EQ(WEBRTC_SPL_WORD16_MAX, WebRtcSpl_MinValueW16(NULL, kVectorSize));
-  EXPECT_EQ(-1, WebRtcSpl_MaxAbsValueW32(vector32, 0));
-  EXPECT_EQ(-1, WebRtcSpl_MaxAbsValueW32(NULL, kVectorSize));
-  EXPECT_EQ(WEBRTC_SPL_WORD32_MIN, WebRtcSpl_MaxValueW32(vector32, 0));
-  EXPECT_EQ(WEBRTC_SPL_WORD32_MIN, WebRtcSpl_MaxValueW32(NULL, kVectorSize));
-  EXPECT_EQ(WEBRTC_SPL_WORD32_MAX, WebRtcSpl_MinValueW32(vector32, 0));
-  EXPECT_EQ(WEBRTC_SPL_WORD32_MAX, WebRtcSpl_MinValueW32(NULL, kVectorSize));
-  EXPECT_EQ(-1, WebRtcSpl_MaxAbsIndexW16(vector16, 0));
-  EXPECT_EQ(-1, WebRtcSpl_MaxAbsIndexW16(NULL, kVectorSize));
-  EXPECT_EQ(-1, WebRtcSpl_MaxIndexW16(vector16, 0));
-  EXPECT_EQ(-1, WebRtcSpl_MaxIndexW16(NULL, kVectorSize));
-  EXPECT_EQ(-1, WebRtcSpl_MaxIndexW32(vector32, 0));
-  EXPECT_EQ(-1, WebRtcSpl_MaxIndexW32(NULL, kVectorSize));
-  EXPECT_EQ(-1, WebRtcSpl_MinIndexW16(vector16, 0));
-  EXPECT_EQ(-1, WebRtcSpl_MinIndexW16(NULL, kVectorSize));
-  EXPECT_EQ(-1, WebRtcSpl_MinIndexW32(vector32, 0));
-  EXPECT_EQ(-1, WebRtcSpl_MinIndexW32(NULL, kVectorSize));
-}
-
 TEST_F(SplTest, MinMaxOperationsTest) {
   const size_t kVectorSize = 17;
 
   // Vectors to test the cases where minimum values have to be caught
   // outside of the unrolled loops in ARM-Neon.
   int16_t vector16[kVectorSize] = {-1, 7485, 0, 3333,
       -18283, 0, 12334, -29871, 988, -3333,
       345, -456, 222, 999,  888, 8774, WEBRTC_SPL_WORD16_MIN};
   int32_t vector32[kVectorSize] = {-1, 0, 283211, 3333,
       8712345, 0, -3333, 89345, -374585456, 222, 999, 122345334,
       -12389756, -987329871, 888, -2, WEBRTC_SPL_WORD32_MIN};
 
   EXPECT_EQ(WEBRTC_SPL_WORD16_MIN,
             WebRtcSpl_MinValueW16(vector16, kVectorSize));
   EXPECT_EQ(WEBRTC_SPL_WORD32_MIN,
             WebRtcSpl_MinValueW32(vector32, kVectorSize));
-  EXPECT_EQ(static_cast<int>(kVectorSize - 1),
-            WebRtcSpl_MinIndexW16(vector16, kVectorSize));
-  EXPECT_EQ(static_cast<int>(kVectorSize - 1),
-            WebRtcSpl_MinIndexW32(vector32, kVectorSize));
+  EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MinIndexW16(vector16, kVectorSize));
+  EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MinIndexW32(vector32, kVectorSize));
 
   // Test the cases where maximum values have to be caught
   // outside of the unrolled loops in ARM-Neon.
   vector16[kVectorSize - 1] = WEBRTC_SPL_WORD16_MAX;
   vector32[kVectorSize - 1] = WEBRTC_SPL_WORD32_MAX;
 
   EXPECT_EQ(WEBRTC_SPL_WORD16_MAX,
             WebRtcSpl_MaxAbsValueW16(vector16, kVectorSize));
   EXPECT_EQ(WEBRTC_SPL_WORD16_MAX,
             WebRtcSpl_MaxValueW16(vector16, kVectorSize));
   EXPECT_EQ(WEBRTC_SPL_WORD32_MAX,
             WebRtcSpl_MaxAbsValueW32(vector32, kVectorSize));
   EXPECT_EQ(WEBRTC_SPL_WORD32_MAX,
             WebRtcSpl_MaxValueW32(vector32, kVectorSize));
-  EXPECT_EQ(static_cast<int>(kVectorSize - 1),
-            WebRtcSpl_MaxAbsIndexW16(vector16, kVectorSize));
-  EXPECT_EQ(static_cast<int>(kVectorSize - 1),
-            WebRtcSpl_MaxIndexW16(vector16, kVectorSize));
-  EXPECT_EQ(static_cast<int>(kVectorSize - 1),
-            WebRtcSpl_MaxIndexW32(vector32, kVectorSize));
+  EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxAbsIndexW16(vector16, kVectorSize));
+  EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxIndexW16(vector16, kVectorSize));
+  EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxIndexW32(vector32, kVectorSize));
 
   // Test the cases where multiple maximum and minimum values are present.
   vector16[1] = WEBRTC_SPL_WORD16_MAX;
   vector16[6] = WEBRTC_SPL_WORD16_MIN;
   vector16[11] = WEBRTC_SPL_WORD16_MIN;
   vector32[1] = WEBRTC_SPL_WORD32_MAX;
   vector32[6] = WEBRTC_SPL_WORD32_MIN;
   vector32[11] = WEBRTC_SPL_WORD32_MIN;
 
   EXPECT_EQ(WEBRTC_SPL_WORD16_MAX,
             WebRtcSpl_MaxAbsValueW16(vector16, kVectorSize));
   EXPECT_EQ(WEBRTC_SPL_WORD16_MAX,
             WebRtcSpl_MaxValueW16(vector16, kVectorSize));
   EXPECT_EQ(WEBRTC_SPL_WORD16_MIN,
             WebRtcSpl_MinValueW16(vector16, kVectorSize));
   EXPECT_EQ(WEBRTC_SPL_WORD32_MAX,
             WebRtcSpl_MaxAbsValueW32(vector32, kVectorSize));
   EXPECT_EQ(WEBRTC_SPL_WORD32_MAX,
             WebRtcSpl_MaxValueW32(vector32, kVectorSize));
   EXPECT_EQ(WEBRTC_SPL_WORD32_MIN,
             WebRtcSpl_MinValueW32(vector32, kVectorSize));
-  EXPECT_EQ(6, WebRtcSpl_MaxAbsIndexW16(vector16, kVectorSize));
-  EXPECT_EQ(1, WebRtcSpl_MaxIndexW16(vector16, kVectorSize));
-  EXPECT_EQ(1, WebRtcSpl_MaxIndexW32(vector32, kVectorSize));
-  EXPECT_EQ(6, WebRtcSpl_MinIndexW16(vector16, kVectorSize));
-  EXPECT_EQ(6, WebRtcSpl_MinIndexW32(vector32, kVectorSize));
+  EXPECT_EQ(6u, WebRtcSpl_MaxAbsIndexW16(vector16, kVectorSize));
+  EXPECT_EQ(1u, WebRtcSpl_MaxIndexW16(vector16, kVectorSize));
+  EXPECT_EQ(1u, WebRtcSpl_MaxIndexW32(vector32, kVectorSize));
+  EXPECT_EQ(6u, WebRtcSpl_MinIndexW16(vector16, kVectorSize));
+  EXPECT_EQ(6u, WebRtcSpl_MinIndexW32(vector32, kVectorSize));
 }
 
 TEST_F(SplTest, VectorOperationsTest) {
     const size_t kVectorSize = 4;
     int B[] = {4, 12, 133, 1100};
     int16_t a16[kVectorSize];
     int16_t b16[kVectorSize];
     int16_t bTmp16[kVectorSize];
 
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
@@ skipping 163 matching lines @@
     EXPECT_EQ(expected[i], vector32[i]);
   }
 }
 
 TEST_F(SplTest, AutoCorrelationTest) {
   int scale = 0;
   int32_t vector32[kVector16Size];
   const int32_t expected[kVector16Size] = {302681398, 14223410, -121705063,
     -85221647, -17104971, 61806945, 6644603, -669329, 43};
 
-  EXPECT_EQ(-1, WebRtcSpl_AutoCorrelation(vector16, kVector16Size,
-                                          kVector16Size + 1, vector32, &scale));
-  EXPECT_EQ(static_cast<int>(kVector16Size),
+  EXPECT_EQ(kVector16Size,
             WebRtcSpl_AutoCorrelation(vector16, kVector16Size,
                                       kVector16Size - 1, vector32, &scale));
   EXPECT_EQ(3, scale);
   for (size_t i = 0; i < kVector16Size; ++i) {
     EXPECT_EQ(expected[i], vector32[i]);
   }
 }
 
 TEST_F(SplTest, SignalProcessingTest) {
     const size_t kVectorSize = 4;
@@ skipping 91 matching lines @@
   // 12-15 are skipped to account for the filter lag.
   for (size_t i = 0; i < 12; ++i) {
     EXPECT_EQ(kRefValue32kHz1, out_vector[i]);
     EXPECT_EQ(kRefValue16kHz1, out_vector_w16[i]);
   }
   for (size_t i = 16; i < 2 * kBlockSize; ++i) {
     EXPECT_EQ(kRefValue32kHz2, out_vector[i]);
     EXPECT_EQ(kRefValue16kHz2, out_vector_w16[i]);
   }
 }