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