| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright 2003 The WebRTC Project Authors. All rights reserved. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license | |
| 5 * that can be found in the LICENSE file in the root of the source | |
| 6 * tree. An additional intellectual property rights grant can be found | |
| 7 * in the file PATENTS. All contributing project authors may | |
| 8 * be found in the AUTHORS file in the root of the source tree. | |
| 9 */ | |
| 10 | |
| 11 // Unittest for registry access API | |
| 12 | |
| 13 #include "webrtc/base/arraysize.h" | |
| 14 #include "webrtc/base/gunit.h" | |
| 15 #include "webrtc/base/common.h" | |
| 16 #include "webrtc/base/win32regkey.h" | |
| 17 | |
| 18 namespace rtc { | |
| 19 | |
| 20 #ifndef EXPECT_SUCCEEDED | |
| 21 #define EXPECT_SUCCEEDED(x) EXPECT_TRUE(SUCCEEDED(x)) | |
| 22 #endif | |
| 23 | |
| 24 #ifndef EXPECT_FAILED | |
| 25 #define EXPECT_FAILED(x) EXPECT_TRUE(FAILED(x)) | |
| 26 #endif | |
| 27 | |
| 28 #define kBaseKey L"Software\\Google\\__TEST" | |
| 29 #define kSubkeyName L"subkey_test" | |
| 30 | |
| 31 const wchar_t kRkey1[] = kBaseKey; | |
| 32 const wchar_t kRkey1SubkeyName[] = kSubkeyName; | |
| 33 const wchar_t kRkey1Subkey[] = kBaseKey L"\\" kSubkeyName; | |
| 34 const wchar_t kFullRkey1[] = L"HKCU\\" kBaseKey; | |
| 35 const wchar_t kFullRkey1Subkey[] = L"HKCU\\" kBaseKey L"\\" kSubkeyName; | |
| 36 | |
| 37 const wchar_t kValNameInt[] = L"Int32 Value"; | |
| 38 const DWORD kIntVal = 20; | |
| 39 const DWORD kIntVal2 = 30; | |
| 40 | |
| 41 const wchar_t kValNameInt64[] = L"Int64 Value"; | |
| 42 const DWORD64 kIntVal64 = 119600064000000000uI64; | |
| 43 | |
| 44 const wchar_t kValNameFloat[] = L"Float Value"; | |
| 45 const float kFloatVal = 12.3456789f; | |
| 46 | |
| 47 const wchar_t kValNameDouble[] = L"Double Value"; | |
| 48 const double kDoubleVal = 98.7654321; | |
| 49 | |
| 50 const wchar_t kValNameStr[] = L"Str Value"; | |
| 51 const wchar_t kStrVal[] = L"Some string data 1"; | |
| 52 const wchar_t kStrVal2[] = L"Some string data 2"; | |
| 53 | |
| 54 const wchar_t kValNameBinary[] = L"Binary Value"; | |
| 55 const char kBinaryVal[] = "Some binary data abcdefghi 1"; | |
| 56 const char kBinaryVal2[] = "Some binary data abcdefghi 2"; | |
| 57 | |
| 58 const wchar_t kValNameMultiStr[] = L"MultiStr Value"; | |
| 59 const wchar_t kMultiSZ[] = L"abc\0def\0P12345\0"; | |
| 60 const wchar_t kEmptyMultiSZ[] = L""; | |
| 61 const wchar_t kInvalidMultiSZ[] = {L'6', L'7', L'8'}; | |
| 62 | |
| 63 // friend function of RegKey | |
| 64 void RegKeyHelperFunctionsTest() { | |
| 65 // Try out some dud values | |
| 66 std::wstring temp_key = L""; | |
| 67 EXPECT_TRUE(RegKey::GetRootKeyInfo(&temp_key) == NULL); | |
| 68 EXPECT_STREQ(temp_key.c_str(), L""); | |
| 69 | |
| 70 temp_key = L"a"; | |
| 71 EXPECT_TRUE(RegKey::GetRootKeyInfo(&temp_key) == NULL); | |
| 72 EXPECT_STREQ(temp_key.c_str(), L""); | |
| 73 | |
| 74 // The basics | |
| 75 temp_key = L"HKLM\\a"; | |
| 76 EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_LOCAL_MACHINE); | |
| 77 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 78 | |
| 79 temp_key = L"HKEY_LOCAL_MACHINE\\a"; | |
| 80 EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_LOCAL_MACHINE); | |
| 81 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 82 | |
| 83 temp_key = L"HKCU\\a"; | |
| 84 EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CURRENT_USER); | |
| 85 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 86 | |
| 87 temp_key = L"HKEY_CURRENT_USER\\a"; | |
| 88 EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CURRENT_USER); | |
| 89 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 90 | |
| 91 temp_key = L"HKU\\a"; | |
| 92 EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_USERS); | |
| 93 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 94 | |
| 95 temp_key = L"HKEY_USERS\\a"; | |
| 96 EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_USERS); | |
| 97 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 98 | |
| 99 temp_key = L"HKCR\\a"; | |
| 100 EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CLASSES_ROOT); | |
| 101 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 102 | |
| 103 temp_key = L"HKEY_CLASSES_ROOT\\a"; | |
| 104 EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CLASSES_ROOT); | |
| 105 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 106 | |
| 107 // Make sure it is case insensitive | |
| 108 temp_key = L"hkcr\\a"; | |
| 109 EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CLASSES_ROOT); | |
| 110 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 111 | |
| 112 temp_key = L"hkey_CLASSES_ROOT\\a"; | |
| 113 EXPECT_EQ(RegKey::GetRootKeyInfo(&temp_key), HKEY_CLASSES_ROOT); | |
| 114 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 115 | |
| 116 // | |
| 117 // Test RegKey::GetParentKeyInfo | |
| 118 // | |
| 119 | |
| 120 // dud cases | |
| 121 temp_key = L""; | |
| 122 EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(), L""); | |
| 123 EXPECT_STREQ(temp_key.c_str(), L""); | |
| 124 | |
| 125 temp_key = L"a"; | |
| 126 EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(), L""); | |
| 127 EXPECT_STREQ(temp_key.c_str(), L"a"); | |
| 128 | |
| 129 temp_key = L"a\\b"; | |
| 130 EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(), L"a"); | |
| 131 EXPECT_STREQ(temp_key.c_str(), L"b"); | |
| 132 | |
| 133 temp_key = L"\\b"; | |
| 134 EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(), L""); | |
| 135 EXPECT_STREQ(temp_key.c_str(), L"b"); | |
| 136 | |
| 137 // Some regular cases | |
| 138 temp_key = L"HKEY_CLASSES_ROOT\\moon"; | |
| 139 EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(), | |
| 140 L"HKEY_CLASSES_ROOT"); | |
| 141 EXPECT_STREQ(temp_key.c_str(), L"moon"); | |
| 142 | |
| 143 temp_key = L"HKEY_CLASSES_ROOT\\moon\\doggy"; | |
| 144 EXPECT_STREQ(RegKey::GetParentKeyInfo(&temp_key).c_str(), | |
| 145 L"HKEY_CLASSES_ROOT\\moon"); | |
| 146 EXPECT_STREQ(temp_key.c_str(), L"doggy"); | |
| 147 | |
| 148 // | |
| 149 // Test MultiSZBytesToStringArray | |
| 150 // | |
| 151 | |
| 152 std::vector<std::wstring> result; | |
| 153 EXPECT_SUCCEEDED(RegKey::MultiSZBytesToStringArray( | |
| 154 reinterpret_cast<const uint8_t*>(kMultiSZ), sizeof(kMultiSZ), &result)); | |
| 155 EXPECT_EQ(result.size(), 3); | |
| 156 EXPECT_STREQ(result[0].c_str(), L"abc"); | |
| 157 EXPECT_STREQ(result[1].c_str(), L"def"); | |
| 158 EXPECT_STREQ(result[2].c_str(), L"P12345"); | |
| 159 | |
| 160 EXPECT_SUCCEEDED(RegKey::MultiSZBytesToStringArray( | |
| 161 reinterpret_cast<const uint8_t*>(kEmptyMultiSZ), sizeof(kEmptyMultiSZ), | |
| 162 &result)); | |
| 163 EXPECT_EQ(result.size(), 0); | |
| 164 EXPECT_FALSE(SUCCEEDED(RegKey::MultiSZBytesToStringArray( | |
| 165 reinterpret_cast<const uint8_t*>(kInvalidMultiSZ), | |
| 166 sizeof(kInvalidMultiSZ), &result))); | |
| 167 } | |
| 168 | |
| 169 TEST(RegKeyTest, RegKeyHelperFunctionsTest) { | |
| 170 RegKeyHelperFunctionsTest(); | |
| 171 } | |
| 172 | |
| 173 void RegKeyNonStaticFunctionsTest() { | |
| 174 DWORD int_val = 0; | |
| 175 DWORD64 int64_val = 0; | |
| 176 wchar_t* str_val = NULL; | |
| 177 uint8_t* binary_val = NULL; | |
| 178 DWORD uint8_count = 0; | |
| 179 | |
| 180 // Just in case... | |
| 181 // make sure the no test key residue is left from previous aborted runs | |
| 182 RegKey::DeleteKey(kFullRkey1); | |
| 183 | |
| 184 // initial state | |
| 185 RegKey r_key; | |
| 186 EXPECT_TRUE(r_key.key() == NULL); | |
| 187 | |
| 188 // create a reg key | |
| 189 EXPECT_SUCCEEDED(r_key.Create(HKEY_CURRENT_USER, kRkey1)); | |
| 190 | |
| 191 // do the create twice - it should return the already created one | |
| 192 EXPECT_SUCCEEDED(r_key.Create(HKEY_CURRENT_USER, kRkey1)); | |
| 193 | |
| 194 // now do an open - should work just fine | |
| 195 EXPECT_SUCCEEDED(r_key.Open(HKEY_CURRENT_USER, kRkey1)); | |
| 196 | |
| 197 // get an in-existent value | |
| 198 EXPECT_EQ(r_key.GetValue(kValNameInt, &int_val), | |
| 199 HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)); | |
| 200 | |
| 201 // set and get some values | |
| 202 | |
| 203 // set an INT 32 | |
| 204 EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt, kIntVal)); | |
| 205 | |
| 206 // check that the value exists | |
| 207 EXPECT_TRUE(r_key.HasValue(kValNameInt)); | |
| 208 | |
| 209 // read it back | |
| 210 EXPECT_SUCCEEDED(r_key.GetValue(kValNameInt, &int_val)); | |
| 211 EXPECT_EQ(int_val, kIntVal); | |
| 212 | |
| 213 // set it again! | |
| 214 EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt, kIntVal2)); | |
| 215 | |
| 216 // read it again | |
| 217 EXPECT_SUCCEEDED(r_key.GetValue(kValNameInt, &int_val)); | |
| 218 EXPECT_EQ(int_val, kIntVal2); | |
| 219 | |
| 220 // delete the value | |
| 221 EXPECT_SUCCEEDED(r_key.DeleteValue(kValNameInt)); | |
| 222 | |
| 223 // check that the value is gone | |
| 224 EXPECT_FALSE(r_key.HasValue(kValNameInt)); | |
| 225 | |
| 226 // set an INT 64 | |
| 227 EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt64, kIntVal64)); | |
| 228 | |
| 229 // check that the value exists | |
| 230 EXPECT_TRUE(r_key.HasValue(kValNameInt64)); | |
| 231 | |
| 232 // read it back | |
| 233 EXPECT_SUCCEEDED(r_key.GetValue(kValNameInt64, &int64_val)); | |
| 234 EXPECT_EQ(int64_val, kIntVal64); | |
| 235 | |
| 236 // delete the value | |
| 237 EXPECT_SUCCEEDED(r_key.DeleteValue(kValNameInt64)); | |
| 238 | |
| 239 // check that the value is gone | |
| 240 EXPECT_FALSE(r_key.HasValue(kValNameInt64)); | |
| 241 | |
| 242 // set a string | |
| 243 EXPECT_SUCCEEDED(r_key.SetValue(kValNameStr, kStrVal)); | |
| 244 | |
| 245 // check that the value exists | |
| 246 EXPECT_TRUE(r_key.HasValue(kValNameStr)); | |
| 247 | |
| 248 // read it back | |
| 249 EXPECT_SUCCEEDED(r_key.GetValue(kValNameStr, &str_val)); | |
| 250 EXPECT_TRUE(lstrcmp(str_val, kStrVal) == 0); | |
| 251 delete[] str_val; | |
| 252 | |
| 253 // set it again | |
| 254 EXPECT_SUCCEEDED(r_key.SetValue(kValNameStr, kStrVal2)); | |
| 255 | |
| 256 // read it again | |
| 257 EXPECT_SUCCEEDED(r_key.GetValue(kValNameStr, &str_val)); | |
| 258 EXPECT_TRUE(lstrcmp(str_val, kStrVal2) == 0); | |
| 259 delete[] str_val; | |
| 260 | |
| 261 // delete the value | |
| 262 EXPECT_SUCCEEDED(r_key.DeleteValue(kValNameStr)); | |
| 263 | |
| 264 // check that the value is gone | |
| 265 EXPECT_FALSE(r_key.HasValue(kValNameInt)); | |
| 266 | |
| 267 // set a binary value | |
| 268 EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary, | |
| 269 reinterpret_cast<const uint8_t*>(kBinaryVal), | |
| 270 sizeof(kBinaryVal) - 1)); | |
| 271 | |
| 272 // check that the value exists | |
| 273 EXPECT_TRUE(r_key.HasValue(kValNameBinary)); | |
| 274 | |
| 275 // read it back | |
| 276 EXPECT_SUCCEEDED(r_key.GetValue(kValNameBinary, &binary_val, &uint8_count)); | |
| 277 EXPECT_TRUE(memcmp(binary_val, kBinaryVal, sizeof(kBinaryVal) - 1) == 0); | |
| 278 delete[] binary_val; | |
| 279 | |
| 280 // set it again | |
| 281 EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary, | |
| 282 reinterpret_cast<const uint8_t*>(kBinaryVal2), | |
| 283 sizeof(kBinaryVal) - 1)); | |
| 284 | |
| 285 // read it again | |
| 286 EXPECT_SUCCEEDED(r_key.GetValue(kValNameBinary, &binary_val, &uint8_count)); | |
| 287 EXPECT_TRUE(memcmp(binary_val, kBinaryVal2, sizeof(kBinaryVal2) - 1) == 0); | |
| 288 delete[] binary_val; | |
| 289 | |
| 290 // delete the value | |
| 291 EXPECT_SUCCEEDED(r_key.DeleteValue(kValNameBinary)); | |
| 292 | |
| 293 // check that the value is gone | |
| 294 EXPECT_FALSE(r_key.HasValue(kValNameBinary)); | |
| 295 | |
| 296 // set some values and check the total count | |
| 297 | |
| 298 // set an INT 32 | |
| 299 EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt, kIntVal)); | |
| 300 | |
| 301 // set an INT 64 | |
| 302 EXPECT_SUCCEEDED(r_key.SetValue(kValNameInt64, kIntVal64)); | |
| 303 | |
| 304 // set a string | |
| 305 EXPECT_SUCCEEDED(r_key.SetValue(kValNameStr, kStrVal)); | |
| 306 | |
| 307 // set a binary value | |
| 308 EXPECT_SUCCEEDED(r_key.SetValue(kValNameBinary, | |
| 309 reinterpret_cast<const uint8_t*>(kBinaryVal), | |
| 310 sizeof(kBinaryVal) - 1)); | |
| 311 | |
| 312 // get the value count | |
| 313 uint32_t value_count = r_key.GetValueCount(); | |
| 314 EXPECT_EQ(value_count, 4); | |
| 315 | |
| 316 // check the value names | |
| 317 std::wstring value_name; | |
| 318 DWORD type = 0; | |
| 319 | |
| 320 EXPECT_SUCCEEDED(r_key.GetValueNameAt(0, &value_name, &type)); | |
| 321 EXPECT_STREQ(value_name.c_str(), kValNameInt); | |
| 322 EXPECT_EQ(type, REG_DWORD); | |
| 323 | |
| 324 EXPECT_SUCCEEDED(r_key.GetValueNameAt(1, &value_name, &type)); | |
| 325 EXPECT_STREQ(value_name.c_str(), kValNameInt64); | |
| 326 EXPECT_EQ(type, REG_QWORD); | |
| 327 | |
| 328 EXPECT_SUCCEEDED(r_key.GetValueNameAt(2, &value_name, &type)); | |
| 329 EXPECT_STREQ(value_name.c_str(), kValNameStr); | |
| 330 EXPECT_EQ(type, REG_SZ); | |
| 331 | |
| 332 EXPECT_SUCCEEDED(r_key.GetValueNameAt(3, &value_name, &type)); | |
| 333 EXPECT_STREQ(value_name.c_str(), kValNameBinary); | |
| 334 EXPECT_EQ(type, REG_BINARY); | |
| 335 | |
| 336 // check that there are no more values | |
| 337 EXPECT_FAILED(r_key.GetValueNameAt(4, &value_name, &type)); | |
| 338 | |
| 339 uint32_t subkey_count = r_key.GetSubkeyCount(); | |
| 340 EXPECT_EQ(subkey_count, 0); | |
| 341 | |
| 342 // now create a subkey and make sure we can get the name | |
| 343 RegKey temp_key; | |
| 344 EXPECT_SUCCEEDED(temp_key.Create(HKEY_CURRENT_USER, kRkey1Subkey)); | |
| 345 | |
| 346 // check the subkey exists | |
| 347 EXPECT_TRUE(r_key.HasSubkey(kRkey1SubkeyName)); | |
| 348 | |
| 349 // check the name | |
| 350 EXPECT_EQ(r_key.GetSubkeyCount(), 1); | |
| 351 | |
| 352 std::wstring subkey_name; | |
| 353 EXPECT_SUCCEEDED(r_key.GetSubkeyNameAt(0, &subkey_name)); | |
| 354 EXPECT_STREQ(subkey_name.c_str(), kRkey1SubkeyName); | |
| 355 | |
| 356 // delete the key | |
| 357 EXPECT_SUCCEEDED(r_key.DeleteSubKey(kRkey1)); | |
| 358 | |
| 359 // close this key | |
| 360 EXPECT_SUCCEEDED(r_key.Close()); | |
| 361 | |
| 362 // whack the whole key | |
| 363 EXPECT_SUCCEEDED(RegKey::DeleteKey(kFullRkey1)); | |
| 364 } | |
| 365 | |
| 366 void RegKeyStaticFunctionsTest() { | |
| 367 DWORD int_val = 0; | |
| 368 DWORD64 int64_val = 0; | |
| 369 float float_val = 0; | |
| 370 double double_val = 0; | |
| 371 wchar_t* str_val = NULL; | |
| 372 std::wstring wstr_val; | |
| 373 uint8_t* binary_val = NULL; | |
| 374 DWORD uint8_count = 0; | |
| 375 | |
| 376 // Just in case... | |
| 377 // make sure the no test key residue is left from previous aborted runs | |
| 378 RegKey::DeleteKey(kFullRkey1); | |
| 379 | |
| 380 // get an in-existent value from an un-existent key | |
| 381 EXPECT_EQ(RegKey::GetValue(kFullRkey1, kValNameInt, &int_val), | |
| 382 HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)); | |
| 383 | |
| 384 // set int32_t | |
| 385 EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameInt, kIntVal)); | |
| 386 | |
| 387 // check that the value exists | |
| 388 EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameInt)); | |
| 389 | |
| 390 // get an in-existent value from an existent key | |
| 391 EXPECT_EQ(RegKey::GetValue(kFullRkey1, L"bogus", &int_val), | |
| 392 HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)); | |
| 393 | |
| 394 // read it back | |
| 395 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameInt, &int_val)); | |
| 396 EXPECT_EQ(int_val, kIntVal); | |
| 397 | |
| 398 // delete the value | |
| 399 EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameInt)); | |
| 400 | |
| 401 // check that the value is gone | |
| 402 EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameInt)); | |
| 403 | |
| 404 // set int64_t | |
| 405 EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameInt64, kIntVal64)); | |
| 406 | |
| 407 // check that the value exists | |
| 408 EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameInt64)); | |
| 409 | |
| 410 // read it back | |
| 411 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameInt64, &int64_val)); | |
| 412 EXPECT_EQ(int64_val, kIntVal64); | |
| 413 | |
| 414 // delete the value | |
| 415 EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameInt64)); | |
| 416 | |
| 417 // check that the value is gone | |
| 418 EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameInt64)); | |
| 419 | |
| 420 // set float | |
| 421 EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameFloat, kFloatVal)); | |
| 422 | |
| 423 // check that the value exists | |
| 424 EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameFloat)); | |
| 425 | |
| 426 // read it back | |
| 427 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameFloat, &float_val)); | |
| 428 EXPECT_EQ(float_val, kFloatVal); | |
| 429 | |
| 430 // delete the value | |
| 431 EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameFloat)); | |
| 432 | |
| 433 // check that the value is gone | |
| 434 EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameFloat)); | |
| 435 EXPECT_FAILED(RegKey::GetValue(kFullRkey1, kValNameFloat, &float_val)); | |
| 436 | |
| 437 // set double | |
| 438 EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameDouble, kDoubleVal)); | |
| 439 | |
| 440 // check that the value exists | |
| 441 EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameDouble)); | |
| 442 | |
| 443 // read it back | |
| 444 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameDouble, &double_val)); | |
| 445 EXPECT_EQ(double_val, kDoubleVal); | |
| 446 | |
| 447 // delete the value | |
| 448 EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameDouble)); | |
| 449 | |
| 450 // check that the value is gone | |
| 451 EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameDouble)); | |
| 452 EXPECT_FAILED(RegKey::GetValue(kFullRkey1, kValNameDouble, &double_val)); | |
| 453 | |
| 454 // set string | |
| 455 EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameStr, kStrVal)); | |
| 456 | |
| 457 // check that the value exists | |
| 458 EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameStr)); | |
| 459 | |
| 460 // read it back | |
| 461 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameStr, &str_val)); | |
| 462 EXPECT_TRUE(lstrcmp(str_val, kStrVal) == 0); | |
| 463 delete[] str_val; | |
| 464 | |
| 465 // read it back in std::wstring | |
| 466 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameStr, &wstr_val)); | |
| 467 EXPECT_STREQ(wstr_val.c_str(), kStrVal); | |
| 468 | |
| 469 // get an in-existent value from an existent key | |
| 470 EXPECT_EQ(RegKey::GetValue(kFullRkey1, L"bogus", &str_val), | |
| 471 HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)); | |
| 472 | |
| 473 // delete the value | |
| 474 EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameStr)); | |
| 475 | |
| 476 // check that the value is gone | |
| 477 EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameStr)); | |
| 478 | |
| 479 // set binary | |
| 480 EXPECT_SUCCEEDED(RegKey::SetValue( | |
| 481 kFullRkey1, kValNameBinary, reinterpret_cast<const uint8_t*>(kBinaryVal), | |
| 482 sizeof(kBinaryVal) - 1)); | |
| 483 | |
| 484 // check that the value exists | |
| 485 EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameBinary)); | |
| 486 | |
| 487 // read it back | |
| 488 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameBinary, | |
| 489 &binary_val, &uint8_count)); | |
| 490 EXPECT_TRUE(memcmp(binary_val, kBinaryVal, sizeof(kBinaryVal)-1) == 0); | |
| 491 delete[] binary_val; | |
| 492 | |
| 493 // delete the value | |
| 494 EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameBinary)); | |
| 495 | |
| 496 // check that the value is gone | |
| 497 EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameBinary)); | |
| 498 | |
| 499 // special case - set a binary value with length 0 | |
| 500 EXPECT_SUCCEEDED( | |
| 501 RegKey::SetValue(kFullRkey1, kValNameBinary, | |
| 502 reinterpret_cast<const uint8_t*>(kBinaryVal), 0)); | |
| 503 | |
| 504 // check that the value exists | |
| 505 EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameBinary)); | |
| 506 | |
| 507 // read it back | |
| 508 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameBinary, | |
| 509 &binary_val, &uint8_count)); | |
| 510 EXPECT_EQ(uint8_count, 0); | |
| 511 EXPECT_TRUE(binary_val == NULL); | |
| 512 delete[] binary_val; | |
| 513 | |
| 514 // delete the value | |
| 515 EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameBinary)); | |
| 516 | |
| 517 // check that the value is gone | |
| 518 EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameBinary)); | |
| 519 | |
| 520 // special case - set a NULL binary value | |
| 521 EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1, kValNameBinary, NULL, 100)); | |
| 522 | |
| 523 // check that the value exists | |
| 524 EXPECT_TRUE(RegKey::HasValue(kFullRkey1, kValNameBinary)); | |
| 525 | |
| 526 // read it back | |
| 527 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameBinary, | |
| 528 &binary_val, &uint8_count)); | |
| 529 EXPECT_EQ(uint8_count, 0); | |
| 530 EXPECT_TRUE(binary_val == NULL); | |
| 531 delete[] binary_val; | |
| 532 | |
| 533 // delete the value | |
| 534 EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1, kValNameBinary)); | |
| 535 | |
| 536 // check that the value is gone | |
| 537 EXPECT_FALSE(RegKey::HasValue(kFullRkey1, kValNameBinary)); | |
| 538 | |
| 539 // test read/write REG_MULTI_SZ value | |
| 540 std::vector<std::wstring> result; | |
| 541 EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ( | |
| 542 kFullRkey1, kValNameMultiStr, reinterpret_cast<const uint8_t*>(kMultiSZ), | |
| 543 sizeof(kMultiSZ))); | |
| 544 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result)); | |
| 545 EXPECT_EQ(result.size(), 3); | |
| 546 EXPECT_STREQ(result[0].c_str(), L"abc"); | |
| 547 EXPECT_STREQ(result[1].c_str(), L"def"); | |
| 548 EXPECT_STREQ(result[2].c_str(), L"P12345"); | |
| 549 EXPECT_SUCCEEDED(RegKey::SetValueMultiSZ( | |
| 550 kFullRkey1, kValNameMultiStr, | |
| 551 reinterpret_cast<const uint8_t*>(kEmptyMultiSZ), sizeof(kEmptyMultiSZ))); | |
| 552 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result)); | |
| 553 EXPECT_EQ(result.size(), 0); | |
| 554 // writing REG_MULTI_SZ value will automatically add ending null characters | |
| 555 EXPECT_SUCCEEDED( | |
| 556 RegKey::SetValueMultiSZ(kFullRkey1, kValNameMultiStr, | |
| 557 reinterpret_cast<const uint8_t*>(kInvalidMultiSZ), | |
| 558 sizeof(kInvalidMultiSZ))); | |
| 559 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1, kValNameMultiStr, &result)); | |
| 560 EXPECT_EQ(result.size(), 1); | |
| 561 EXPECT_STREQ(result[0].c_str(), L"678"); | |
| 562 | |
| 563 // Run the following test only in dev machine | |
| 564 // This is because the build machine might not have admin privilege | |
| 565 #ifdef IS_PRIVATE_BUILD | |
| 566 // get a temp file name | |
| 567 wchar_t temp_path[MAX_PATH] = {0}; | |
| 568 EXPECT_LT(::GetTempPath(arraysize(temp_path), temp_path), | |
| 569 static_cast<DWORD>(arraysize(temp_path))); | |
| 570 wchar_t temp_file[MAX_PATH] = {0}; | |
| 571 EXPECT_NE(::GetTempFileName(temp_path, L"rkut_", | |
| 572 ::GetTickCount(), temp_file), 0); | |
| 573 | |
| 574 // test save | |
| 575 EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1Subkey, kValNameInt, kIntVal)); | |
| 576 EXPECT_SUCCEEDED(RegKey::SetValue(kFullRkey1Subkey, kValNameInt64, kIntVal64))
; | |
| 577 EXPECT_SUCCEEDED(RegKey::Save(kFullRkey1Subkey, temp_file)); | |
| 578 EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1Subkey, kValNameInt)); | |
| 579 EXPECT_SUCCEEDED(RegKey::DeleteValue(kFullRkey1Subkey, kValNameInt64)); | |
| 580 | |
| 581 // test restore | |
| 582 EXPECT_SUCCEEDED(RegKey::Restore(kFullRkey1Subkey, temp_file)); | |
| 583 int_val = 0; | |
| 584 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1Subkey, kValNameInt, &int_val)); | |
| 585 EXPECT_EQ(int_val, kIntVal); | |
| 586 int64_val = 0; | |
| 587 EXPECT_SUCCEEDED(RegKey::GetValue(kFullRkey1Subkey, | |
| 588 kValNameInt64, | |
| 589 &int64_val)); | |
| 590 EXPECT_EQ(int64_val, kIntVal64); | |
| 591 | |
| 592 // delete the temp file | |
| 593 EXPECT_EQ(TRUE, ::DeleteFile(temp_file)); | |
| 594 #endif | |
| 595 | |
| 596 // whack the whole key | |
| 597 EXPECT_SUCCEEDED(RegKey::DeleteKey(kFullRkey1)); | |
| 598 } | |
| 599 | |
| 600 // Run both tests under the same test target. Because they access (read and | |
| 601 // write) the same registry keys they can't run in parallel with eachother. | |
| 602 TEST(RegKeyTest, RegKeyFunctionsTest) { | |
| 603 RegKeyNonStaticFunctionsTest(); | |
| 604 RegKeyStaticFunctionsTest(); | |
| 605 } | |
| 606 | |
| 607 } // namespace rtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2571763002:
Delete unused class rtc::RegKey. (Closed)
