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

webrtc/base/win32regkey_unittest.cc

 /*
  *  Copyright 2003 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 132 matching lines @@
   EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(),
                L"HKEY_CLASSES_ROOT\\moon");
   EXPECT_STREQ(temp_key.c_str(), L"doggy");
 
   //
   // Test MultiSZBytesToStringArray
   //
 
   std::vector<std::wstring> result;
   EXPECT_SUCCEEDED(RegKey::MultiSZBytesToStringArray(
-      reinterpret_cast<const uint8*>(kMultiSZ), sizeof(kMultiSZ), &result));
+      reinterpret_cast<const uint8_t*>(kMultiSZ), sizeof(kMultiSZ), &result));
   EXPECT_EQ(result.size(), 3);
   EXPECT_STREQ(result[0].c_str(), L"abc");
   EXPECT_STREQ(result[1].c_str(), L"def");
   EXPECT_STREQ(result[2].c_str(), L"P12345");
 
   EXPECT_SUCCEEDED(RegKey::MultiSZBytesToStringArray(
-      reinterpret_cast<const uint8*>(kEmptyMultiSZ),
-      sizeof(kEmptyMultiSZ), &result));
+      reinterpret_cast<const uint8_t*>(kEmptyMultiSZ), sizeof(kEmptyMultiSZ),
+      &result));
   EXPECT_EQ(result.size(), 0);
   EXPECT_FALSE(SUCCEEDED(RegKey::MultiSZBytesToStringArray(
-      reinterpret_cast<const uint8*>(kInvalidMultiSZ),
+      reinterpret_cast<const uint8_t*>(kInvalidMultiSZ),
       sizeof(kInvalidMultiSZ), &result)));
 }
 
 TEST(RegKeyTest, RegKeyHelperFunctionsTest) {
   RegKeyHelperFunctionsTest();
 }
 
 void RegKeyNonStaticFunctionsTest() {
   DWORD int_val = 0;
   DWORD64 int64_val = 0;
   wchar_t* str_val = NULL;
-  uint8* binary_val = NULL;
+  uint8_t* binary_val = NULL;
   DWORD uint8_count = 0;
 
   // Just in case...
   // make sure the no test key residue is left from previous aborted runs
   RegKey::DeleteKey(kFullRkey1);
 
   // initial state
   RegKey r_key;
   EXPECT_TRUE(r_key.key() == NULL);
 
@@ skipping 71 matching lines @@
   delete[] str_val;
 
   // delete the value
   EXPECT_SUCCEEDED(r_key.DeleteValue(kValNameStr));
 
   // check that the value is gone
   EXPECT_FALSE(r_key.HasValue(kValNameInt));
 
   // set a binary value
   EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary,
-      reinterpret_cast<const uint8*>(kBinaryVal), sizeof(kBinaryVal) - 1));
+                                  reinterpret_cast<const uint8_t*>(kBinaryVal),
+                                  sizeof(kBinaryVal) - 1));
 
   // check that the value exists
   EXPECT_TRUE(r_key.HasValue(kValNameBinary));
 
   // read it back
   EXPECT_SUCCEEDED(r_key.GetValue(kValNameBinary, &binary_val, &uint8_count));
   EXPECT_TRUE(memcmp(binary_val, kBinaryVal, sizeof(kBinaryVal) - 1) == 0);
   delete[] binary_val;
 
   // set it again
   EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary,
-      reinterpret_cast<const uint8*>(kBinaryVal2), sizeof(kBinaryVal) - 1));
+                                  reinterpret_cast<const uint8_t*>(kBinaryVal2),
+                                  sizeof(kBinaryVal) - 1));
 
   // read it again
   EXPECT_SUCCEEDED(r_key.GetValue(kValNameBinary, &binary_val, &uint8_count));
   EXPECT_TRUE(memcmp(binary_val, kBinaryVal2, sizeof(kBinaryVal2) - 1) == 0);
   delete[] binary_val;
 
   // delete the value
   EXPECT_SUCCEEDED(r_key.DeleteValue(kValNameBinary));
 
   // check that the value is gone
   EXPECT_FALSE(r_key.HasValue(kValNameBinary));
 
   // set some values and check the total count
 
   // set an INT 32
   EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt, kIntVal));
 
   // set an INT 64
   EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt64, kIntVal64));
 
   // set a string
   EXPECT_SUCCEEDED(r_key.SetValue(kValNameStr, kStrVal));
 
   // set a binary value
   EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary,
-      reinterpret_cast<const uint8*>(kBinaryVal), sizeof(kBinaryVal) - 1));
+                                  reinterpret_cast<const uint8_t*>(kBinaryVal),
+                                  sizeof(kBinaryVal) - 1));
 
   // get the value count
-  uint32 value_count = r_key.GetValueCount();
+  uint32_t value_count = r_key.GetValueCount();
   EXPECT_EQ(value_count, 4);
 
   // check the value names
   std::wstring value_name;
   DWORD type = 0;
 
   EXPECT_SUCCEEDED(r_key.GetValueNameAt(0, &value_name, &type));
   EXPECT_STREQ(value_name.c_str(), kValNameInt);
   EXPECT_EQ(type, REG_DWORD);
 
   EXPECT_SUCCEEDED(r_key.GetValueNameAt(1, &value_name, &type));
   EXPECT_STREQ(value_name.c_str(), kValNameInt64);
   EXPECT_EQ(type, REG_QWORD);
 
   EXPECT_SUCCEEDED(r_key.GetValueNameAt(2, &value_name, &type));
   EXPECT_STREQ(value_name.c_str(), kValNameStr);
   EXPECT_EQ(type, REG_SZ);
 
   EXPECT_SUCCEEDED(r_key.GetValueNameAt(3, &value_name, &type));
   EXPECT_STREQ(value_name.c_str(), kValNameBinary);
   EXPECT_EQ(type, REG_BINARY);
 
   // check that there are no more values
   EXPECT_FAILED(r_key.GetValueNameAt(4, &value_name, &type));
 
-  uint32 subkey_count = r_key.GetSubkeyCount();
+  uint32_t subkey_count = r_key.GetSubkeyCount();
   EXPECT_EQ(subkey_count, 0);
 
   // now create a subkey and make sure we can get the name
   RegKey temp_key;
   EXPECT_SUCCEEDED(temp_key.Create(HKEY_CURRENT_USER, kRkey1Subkey));
 
   // check the subkey exists
   EXPECT_TRUE(r_key.HasSubkey(kRkey1SubkeyName));
 
   // check the name
@@ skipping 13 matching lines @@
   EXPECT_SUCCEEDED(RegKey::DeleteKey(kFullRkey1));
 }
 
 void RegKeyStaticFunctionsTest() {
   DWORD int_val = 0;
   DWORD64 int64_val = 0;
   float float_val = 0;
   double double_val = 0;
   wchar_t* str_val = NULL;
   std::wstring wstr_val;
-  uint8* binary_val = NULL;
+  uint8_t* binary_val = NULL;
   DWORD uint8_count = 0;
 
   // Just in case...
   // make sure the no test key residue is left from previous aborted runs
   RegKey::DeleteKey(kFullRkey1);
 
   // get an in-existent value from an un-existent key
   EXPECT_EQ(RegKey::GetValue(kFullRkey1, kValNameInt, &int_val),
             HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND));
 
-  // set int32
+  // set int32_t
   EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameInt, kIntVal));
 
   // check that the value exists
   EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameInt));
 
   // get an in-existent value from an existent key
   EXPECT_EQ(RegKey::GetValue(kFullRkey1, L"bogus", &int_val),
             HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND));
 
   // read it back
   EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameInt, &int_val));
   EXPECT_EQ(int_val, kIntVal);
 
   // delete the value
   EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameInt));
 
   // check that the value is gone
   EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameInt));
 
-  // set int64
+  // set int64_t
   EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameInt64, kIntVal64));
 
   // check that the value exists
   EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameInt64));
 
   // read it back
   EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameInt64, &int64_val));
   EXPECT_EQ(int64_val, kIntVal64);
 
   // delete the value
@@ skipping 55 matching lines @@
   EXPECT_EQ(RegKey::GetValue(kFullRkey1, L"bogus", &str_val),
             HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND));
 
   // delete the value
   EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameStr));
 
   // check that the value is gone
   EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameStr));
 
   // set binary
-  EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameBinary,
-      reinterpret_cast<const uint8*>(kBinaryVal), sizeof(kBinaryVal)-1));
+  EXPECT_SUCCEEDED(RegKey::SetValue(
+      kFullRkey1, kValNameBinary, reinterpret_cast<const uint8_t*>(kBinaryVal),
+      sizeof(kBinaryVal) - 1));
 
   // check that the value exists
   EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameBinary));
 
   // read it back
   EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameBinary,
       &binary_val, &uint8_count));
   EXPECT_TRUE(memcmp(binary_val, kBinaryVal, sizeof(kBinaryVal)-1) == 0);
   delete[] binary_val;
 
   // delete the value
   EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameBinary));
 
   // check that the value is gone
   EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameBinary));
 
   // special case - set a binary value with length 0
-  EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameBinary,
-      reinterpret_cast<const uint8*>(kBinaryVal), 0));
+  EXPECT_SUCCEEDED(
+      RegKey::SetValue(kFullRkey1, kValNameBinary,
+                       reinterpret_cast<const uint8_t*>(kBinaryVal), 0));
 
   // check that the value exists
   EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameBinary));
 
   // read it back
   EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameBinary,
       &binary_val, &uint8_count));
   EXPECT_EQ(uint8_count, 0);
   EXPECT_TRUE(binary_val == NULL);
   delete[] binary_val;
@@ skipping 18 matching lines @@
   delete[] binary_val;
 
   // delete the value
   EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameBinary));
 
   // check that the value is gone
   EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameBinary));
 
   // test read/write REG_MULTI_SZ value
   std::vector<std::wstring> result;
-  EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
-      reinterpret_cast<const uint8*>(kMultiSZ), sizeof(kMultiSZ)));
+  EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(
+      kFullRkey1, kValNameMultiStr, reinterpret_cast<const uint8_t*>(kMultiSZ),
+      sizeof(kMultiSZ)));
   EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result));
   EXPECT_EQ(result.size(), 3);
   EXPECT_STREQ(result[0].c_str(), L"abc");
   EXPECT_STREQ(result[1].c_str(), L"def");
   EXPECT_STREQ(result[2].c_str(), L"P12345");
-  EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
-      reinterpret_cast<const uint8*>(kEmptyMultiSZ), sizeof(kEmptyMultiSZ)));
+  EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(
+      kFullRkey1, kValNameMultiStr,
+      reinterpret_cast<const uint8_t*>(kEmptyMultiSZ), sizeof(kEmptyMultiSZ)));
   EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result));
   EXPECT_EQ(result.size(), 0);
   // writing REG_MULTI_SZ value will automatically add ending null characters
-  EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
-      reinterpret_cast<const uint8*>(kInvalidMultiSZ), sizeof(kInvalidMultiSZ)));
+  EXPECT_SUCCEEDED(
+      RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr,
+                              reinterpret_cast<const uint8_t*>(kInvalidMultiSZ),
+                              sizeof(kInvalidMultiSZ)));
   EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result));
   EXPECT_EQ(result.size(), 1);
   EXPECT_STREQ(result[0].c_str(), L"678");
 
   // Run the following test only in dev machine
   // This is because the build machine might not have admin privilege
 #ifdef IS_PRIVATE_BUILD
   // get a temp file name
   wchar_t temp_path[MAX_PATH] = {0};
   EXPECT_LT(::GetTempPath(ARRAY_SIZE(temp_path), temp_path),
@@ skipping 29 matching lines @@
 }
 
 // Run both tests under the same test target. Because they access (read and
 // write) the same registry keys they can't run in parallel with eachother.
 TEST(RegKeyTest, RegKeyFunctionsTest) {
   RegKeyNonStaticFunctionsTest();
   RegKeyStaticFunctionsTest();
 }
 
 }  // namespace rtc