Switch to standard integer types in base/i18n/.

base/i18n/streaming_utf8_validator_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/i18n/streaming_utf8_validator.h"
 
+#include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <string>
 
+#include "base/macros.h"
 #include "base/strings/string_piece.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Define BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST to verify that this class
 // accepts exactly the same set of 4-byte strings as ICU-based validation. This
 // tests every possible 4-byte string, so it is too slow to run routinely on
 // low-powered machines.
 //
 // #define BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
 
 #ifdef BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "third_party/icu/source/common/unicode/utf8.h"
 
 #endif  // BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
 
 namespace base {
 namespace {
 
 // Avoid having to qualify the enum values in the tests.
 const StreamingUtf8Validator::State VALID_ENDPOINT =
     StreamingUtf8Validator::VALID_ENDPOINT;
 const StreamingUtf8Validator::State VALID_MIDPOINT =
     StreamingUtf8Validator::VALID_MIDPOINT;
 const StreamingUtf8Validator::State INVALID = StreamingUtf8Validator::INVALID;
 
 #ifdef BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
 
-const uint32 kThoroughTestChunkSize = 1 << 24;
+const uint32_t kThoroughTestChunkSize = 1 << 24;
 
 class StreamingUtf8ValidatorThoroughTest : public ::testing::Test {
  protected:
   StreamingUtf8ValidatorThoroughTest()
       : all_done_(&lock_), tasks_dispatched_(0), tasks_finished_(0) {}
 
   // This uses the same logic as base::IsStringUTF8 except it considers
   // non-characters valid (and doesn't require a string as input).
-  static bool IsStringUtf8(const char* src, int32 src_len) {
-    int32 char_index = 0;
+  static bool IsStringUtf8(const char* src, int32_t src_len) {
+    int32_t char_index = 0;
 
     while (char_index < src_len) {
-      int32 code_point;
+      int32_t code_point;
       U8_NEXT(src, char_index, src_len, code_point);
       if (!base::IsValidCodepoint(code_point))
         return false;
     }
     return true;
   }
 
   // Converts the passed-in integer to a 4 byte string and then
   // verifies that IsStringUtf8 and StreamingUtf8Validator agree on
   // whether it is valid UTF-8 or not.
-  void TestNumber(uint32 n) const {
+  void TestNumber(uint32_t n) const {
     char test[sizeof n];
     memcpy(test, &n, sizeof n);
     StreamingUtf8Validator validator;
     EXPECT_EQ(IsStringUtf8(test, sizeof n),
               validator.AddBytes(test, sizeof n) == VALID_ENDPOINT)
         << "Difference of opinion for \""
         << base::StringPrintf("\\x%02X\\x%02X\\x%02X\\x%02X",
                               test[0] & 0xFF,
                               test[1] & 0xFF,
                               test[2] & 0xFF,
                               test[3] & 0xFF) << "\"";
   }
 
  public:
   // Tests the 4-byte sequences corresponding to the |size| integers
   // starting at |begin|. This is intended to be run from a worker
   // pool. Signals |all_done_| at the end if it thinks all tasks are
   // finished.
-  void TestRange(uint32 begin, uint32 size) {
-    for (uint32 i = 0; i < size; ++i) {
+  void TestRange(uint32_t begin, uint32_t size) {
+    for (uint32_t i = 0; i < size; ++i) {
       TestNumber(begin + i);
     }
     base::AutoLock al(lock_);
     ++tasks_finished_;
     LOG(INFO) << tasks_finished_ << " / " << tasks_dispatched_
               << " tasks done\n";
     if (tasks_finished_ >= tasks_dispatched_) {
       all_done_.Signal();
     }
   }
 
  protected:
   base::Lock lock_;
   base::ConditionVariable all_done_;
   int tasks_dispatched_;
   int tasks_finished_;
 };
 
 TEST_F(StreamingUtf8ValidatorThoroughTest, TestEverything) {
   scoped_refptr<base::SequencedWorkerPool> pool =
       new base::SequencedWorkerPool(32, "TestEverything");
   base::AutoLock al(lock_);
-  uint32 begin = 0;
+  uint32_t begin = 0;
   do {
     pool->PostWorkerTask(
         FROM_HERE,
         base::Bind(&StreamingUtf8ValidatorThoroughTest::TestRange,
                    base::Unretained(this),
                    begin,
                    kThoroughTestChunkSize));
     ++tasks_dispatched_;
     begin += kThoroughTestChunkSize;
   } while (begin != 0);
@@ skipping 274 matching lines @@
 TEST(StreamingUtf8ValidatorValidateTest, SimpleInvalidCase) {
   EXPECT_FALSE(StreamingUtf8Validator::Validate("\xc0\x80"));
 }
 
 TEST(StreamingUtf8ValidatorValidateTest, TruncatedIsInvalid) {
   EXPECT_FALSE(StreamingUtf8Validator::Validate("\xc2"));
 }
 
 }  // namespace
 }  // namespace base