OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <windows.h> | 5 #include <windows.h> |
6 | 6 |
7 #include "base/files/file_path.h" | 7 #include "base/files/file_path.h" |
8 #include "base/memory/scoped_ptr.h" | 8 #include "base/memory/scoped_ptr.h" |
9 #include "base/strings/string_util.h" | 9 #include "base/strings/string_util.h" |
10 #include "base/win/registry.h" | 10 #include "base/win/registry.h" |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
51 | 51 |
52 std::wstring parent_key(kTestRoot); | 52 std::wstring parent_key(kTestRoot); |
53 parent_key.append(&base::FilePath::kSeparators[0], 1); | 53 parent_key.append(&base::FilePath::kSeparators[0], 1); |
54 parent_key.append(L"WriteNewNonOverwrite"); | 54 parent_key.append(L"WriteNewNonOverwrite"); |
55 ASSERT_EQ(ERROR_SUCCESS, | 55 ASSERT_EQ(ERROR_SUCCESS, |
56 key.Create(HKEY_CURRENT_USER, parent_key.c_str(), KEY_READ)); | 56 key.Create(HKEY_CURRENT_USER, parent_key.c_str(), KEY_READ)); |
57 | 57 |
58 std::wstring name_str(kNameStr); | 58 std::wstring name_str(kNameStr); |
59 std::wstring data_str(kDataStr1); | 59 std::wstring data_str(kDataStr1); |
60 scoped_ptr<SetRegValueWorkItem> work_item1( | 60 scoped_ptr<SetRegValueWorkItem> work_item1( |
61 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, parent_key, | 61 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
62 name_str, data_str, false)); | 62 parent_key, |
| 63 WorkItem::kWow64Default, |
| 64 name_str, |
| 65 data_str, |
| 66 false)); |
63 | 67 |
64 std::wstring name_dword(kNameDword); | 68 std::wstring name_dword(kNameDword); |
65 scoped_ptr<SetRegValueWorkItem> work_item2( | 69 scoped_ptr<SetRegValueWorkItem> work_item2( |
66 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, parent_key, | 70 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
67 name_dword, dword1, false)); | 71 parent_key, |
| 72 WorkItem::kWow64Default, |
| 73 name_dword, |
| 74 dword1, |
| 75 false)); |
68 | 76 |
69 EXPECT_TRUE(work_item1->Do()); | 77 EXPECT_TRUE(work_item1->Do()); |
70 EXPECT_TRUE(work_item2->Do()); | 78 EXPECT_TRUE(work_item2->Do()); |
71 | 79 |
72 std::wstring read_out; | 80 std::wstring read_out; |
73 DWORD read_dword; | 81 DWORD read_dword; |
74 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name_str.c_str(), &read_out)); | 82 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name_str.c_str(), &read_out)); |
75 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name_dword.c_str(), &read_dword)); | 83 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name_dword.c_str(), &read_dword)); |
76 EXPECT_EQ(read_out, kDataStr1); | 84 EXPECT_EQ(read_out, kDataStr1); |
77 EXPECT_EQ(read_dword, dword1); | 85 EXPECT_EQ(read_dword, dword1); |
(...skipping 12 matching lines...) Expand all Loading... |
90 | 98 |
91 std::wstring parent_key(kTestRoot); | 99 std::wstring parent_key(kTestRoot); |
92 parent_key.append(&base::FilePath::kSeparators[0], 1); | 100 parent_key.append(&base::FilePath::kSeparators[0], 1); |
93 parent_key.append(L"WriteNewOverwrite"); | 101 parent_key.append(L"WriteNewOverwrite"); |
94 ASSERT_EQ(ERROR_SUCCESS, | 102 ASSERT_EQ(ERROR_SUCCESS, |
95 key.Create(HKEY_CURRENT_USER, parent_key.c_str(), KEY_READ)); | 103 key.Create(HKEY_CURRENT_USER, parent_key.c_str(), KEY_READ)); |
96 | 104 |
97 std::wstring name_str(kNameStr); | 105 std::wstring name_str(kNameStr); |
98 std::wstring data_str(kDataStr1); | 106 std::wstring data_str(kDataStr1); |
99 scoped_ptr<SetRegValueWorkItem> work_item1( | 107 scoped_ptr<SetRegValueWorkItem> work_item1( |
100 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, parent_key, | 108 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
101 name_str, data_str, true)); | 109 parent_key, |
| 110 WorkItem::kWow64Default, |
| 111 name_str, |
| 112 data_str, |
| 113 true)); |
102 | 114 |
103 std::wstring name_dword(kNameDword); | 115 std::wstring name_dword(kNameDword); |
104 scoped_ptr<SetRegValueWorkItem> work_item2( | 116 scoped_ptr<SetRegValueWorkItem> work_item2( |
105 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, parent_key, | 117 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
106 name_dword, dword1, true)); | 118 parent_key, |
| 119 WorkItem::kWow64Default, |
| 120 name_dword, |
| 121 dword1, |
| 122 true)); |
107 | 123 |
108 EXPECT_TRUE(work_item1->Do()); | 124 EXPECT_TRUE(work_item1->Do()); |
109 EXPECT_TRUE(work_item2->Do()); | 125 EXPECT_TRUE(work_item2->Do()); |
110 | 126 |
111 std::wstring read_out; | 127 std::wstring read_out; |
112 DWORD read_dword; | 128 DWORD read_dword; |
113 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name_str.c_str(), &read_out)); | 129 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name_str.c_str(), &read_out)); |
114 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name_dword.c_str(), &read_dword)); | 130 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name_dword.c_str(), &read_dword)); |
115 EXPECT_EQ(read_out, kDataStr1); | 131 EXPECT_EQ(read_out, kDataStr1); |
116 EXPECT_EQ(read_dword, dword1); | 132 EXPECT_EQ(read_dword, dword1); |
(...skipping 18 matching lines...) Expand all Loading... |
135 key.Create(HKEY_CURRENT_USER, parent_key.c_str(), | 151 key.Create(HKEY_CURRENT_USER, parent_key.c_str(), |
136 KEY_READ | KEY_SET_VALUE)); | 152 KEY_READ | KEY_SET_VALUE)); |
137 | 153 |
138 // First test REG_SZ value. | 154 // First test REG_SZ value. |
139 // Write data to the value we are going to set. | 155 // Write data to the value we are going to set. |
140 std::wstring name(kNameStr); | 156 std::wstring name(kNameStr); |
141 ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name.c_str(), kDataStr1)); | 157 ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name.c_str(), kDataStr1)); |
142 | 158 |
143 std::wstring data(kDataStr2); | 159 std::wstring data(kDataStr2); |
144 scoped_ptr<SetRegValueWorkItem> work_item( | 160 scoped_ptr<SetRegValueWorkItem> work_item( |
145 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, parent_key, | 161 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
146 name, data, false)); | 162 parent_key, |
| 163 WorkItem::kWow64Default, |
| 164 name, |
| 165 data, |
| 166 false)); |
147 EXPECT_TRUE(work_item->Do()); | 167 EXPECT_TRUE(work_item->Do()); |
148 | 168 |
149 std::wstring read_out; | 169 std::wstring read_out; |
150 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out)); | 170 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out)); |
151 EXPECT_EQ(0, read_out.compare(kDataStr1)); | 171 EXPECT_EQ(0, read_out.compare(kDataStr1)); |
152 | 172 |
153 work_item->Rollback(); | 173 work_item->Rollback(); |
154 EXPECT_TRUE(key.HasValue(name.c_str())); | 174 EXPECT_TRUE(key.HasValue(name.c_str())); |
155 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out)); | 175 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out)); |
156 EXPECT_EQ(read_out, kDataStr1); | 176 EXPECT_EQ(read_out, kDataStr1); |
157 | 177 |
158 // Now test REG_DWORD value. | 178 // Now test REG_DWORD value. |
159 // Write data to the value we are going to set. | 179 // Write data to the value we are going to set. |
160 name.assign(kNameDword); | 180 name.assign(kNameDword); |
161 ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name.c_str(), dword1)); | 181 ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name.c_str(), dword1)); |
162 work_item.reset(WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, | 182 work_item.reset(WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
163 parent_key, name, dword2, false)); | 183 parent_key, |
| 184 WorkItem::kWow64Default, |
| 185 name, |
| 186 dword2, |
| 187 false)); |
164 EXPECT_TRUE(work_item->Do()); | 188 EXPECT_TRUE(work_item->Do()); |
165 | 189 |
166 DWORD read_dword; | 190 DWORD read_dword; |
167 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name.c_str(), &read_dword)); | 191 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name.c_str(), &read_dword)); |
168 EXPECT_EQ(read_dword, dword1); | 192 EXPECT_EQ(read_dword, dword1); |
169 | 193 |
170 work_item->Rollback(); | 194 work_item->Rollback(); |
171 EXPECT_TRUE(key.HasValue(name.c_str())); | 195 EXPECT_TRUE(key.HasValue(name.c_str())); |
172 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name.c_str(), &read_dword)); | 196 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name.c_str(), &read_dword)); |
173 EXPECT_EQ(read_dword, dword1); | 197 EXPECT_EQ(read_dword, dword1); |
(...skipping 15 matching lines...) Expand all Loading... |
189 // Write data to the value we are going to set. | 213 // Write data to the value we are going to set. |
190 std::wstring name(kNameStr); | 214 std::wstring name(kNameStr); |
191 ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name.c_str(), kDataStr1)); | 215 ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name.c_str(), kDataStr1)); |
192 | 216 |
193 std::wstring name_empty(L"name_empty"); | 217 std::wstring name_empty(L"name_empty"); |
194 ASSERT_EQ(ERROR_SUCCESS, RegSetValueEx(key.Handle(), name_empty.c_str(), NULL, | 218 ASSERT_EQ(ERROR_SUCCESS, RegSetValueEx(key.Handle(), name_empty.c_str(), NULL, |
195 REG_SZ, NULL, 0)); | 219 REG_SZ, NULL, 0)); |
196 | 220 |
197 std::wstring data(kDataStr2); | 221 std::wstring data(kDataStr2); |
198 scoped_ptr<SetRegValueWorkItem> work_item1( | 222 scoped_ptr<SetRegValueWorkItem> work_item1( |
199 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, parent_key, | 223 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
200 name, data, true)); | 224 parent_key, |
| 225 WorkItem::kWow64Default, |
| 226 name, |
| 227 data, |
| 228 true)); |
201 scoped_ptr<SetRegValueWorkItem> work_item2( | 229 scoped_ptr<SetRegValueWorkItem> work_item2( |
202 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, parent_key, | 230 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
203 name_empty, data, true)); | 231 parent_key, |
| 232 WorkItem::kWow64Default, |
| 233 name_empty, |
| 234 data, |
| 235 true)); |
204 | 236 |
205 EXPECT_TRUE(work_item1->Do()); | 237 EXPECT_TRUE(work_item1->Do()); |
206 EXPECT_TRUE(work_item2->Do()); | 238 EXPECT_TRUE(work_item2->Do()); |
207 | 239 |
208 std::wstring read_out; | 240 std::wstring read_out; |
209 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out)); | 241 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out)); |
210 EXPECT_EQ(0, read_out.compare(kDataStr2)); | 242 EXPECT_EQ(0, read_out.compare(kDataStr2)); |
211 | 243 |
212 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name_empty.c_str(), &read_out)); | 244 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name_empty.c_str(), &read_out)); |
213 EXPECT_EQ(0, read_out.compare(kDataStr2)); | 245 EXPECT_EQ(0, read_out.compare(kDataStr2)); |
(...skipping 10 matching lines...) Expand all Loading... |
224 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name_empty.c_str(), NULL, &size, | 256 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name_empty.c_str(), NULL, &size, |
225 &type)); | 257 &type)); |
226 EXPECT_EQ(REG_SZ, type); | 258 EXPECT_EQ(REG_SZ, type); |
227 EXPECT_EQ(0, size); | 259 EXPECT_EQ(0, size); |
228 | 260 |
229 // Now test REG_DWORD value. | 261 // Now test REG_DWORD value. |
230 // Write data to the value we are going to set. | 262 // Write data to the value we are going to set. |
231 name.assign(kNameDword); | 263 name.assign(kNameDword); |
232 ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name.c_str(), dword1)); | 264 ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name.c_str(), dword1)); |
233 scoped_ptr<SetRegValueWorkItem> work_item3( | 265 scoped_ptr<SetRegValueWorkItem> work_item3( |
234 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, parent_key, name, | 266 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
235 dword2, true)); | 267 parent_key, |
| 268 WorkItem::kWow64Default, |
| 269 name, |
| 270 dword2, |
| 271 true)); |
236 EXPECT_TRUE(work_item3->Do()); | 272 EXPECT_TRUE(work_item3->Do()); |
237 | 273 |
238 DWORD read_dword; | 274 DWORD read_dword; |
239 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name.c_str(), &read_dword)); | 275 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name.c_str(), &read_dword)); |
240 EXPECT_EQ(read_dword, dword2); | 276 EXPECT_EQ(read_dword, dword2); |
241 | 277 |
242 work_item3->Rollback(); | 278 work_item3->Rollback(); |
243 EXPECT_TRUE(key.HasValue(name.c_str())); | 279 EXPECT_TRUE(key.HasValue(name.c_str())); |
244 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name.c_str(), &read_dword)); | 280 EXPECT_EQ(ERROR_SUCCESS, key.ReadValueDW(name.c_str(), &read_dword)); |
245 EXPECT_EQ(read_dword, dword1); | 281 EXPECT_EQ(read_dword, dword1); |
246 } | 282 } |
247 | 283 |
248 // Write a value to a non-existing key. This should fail. | 284 // Write a value to a non-existing key. This should fail. |
249 TEST_F(SetRegValueWorkItemTest, WriteNonExistingKey) { | 285 TEST_F(SetRegValueWorkItemTest, WriteNonExistingKey) { |
250 RegKey key; | 286 RegKey key; |
251 | 287 |
252 std::wstring parent_key(kTestRoot); | 288 std::wstring parent_key(kTestRoot); |
253 parent_key.append(&base::FilePath::kSeparators[0], 1); | 289 parent_key.append(&base::FilePath::kSeparators[0], 1); |
254 parent_key.append(L"WriteNonExistingKey"); | 290 parent_key.append(L"WriteNonExistingKey"); |
255 | 291 |
256 std::wstring name(L"name"); | 292 std::wstring name(L"name"); |
257 std::wstring data(kDataStr1); | 293 std::wstring data(kDataStr1); |
258 scoped_ptr<SetRegValueWorkItem> work_item( | 294 scoped_ptr<SetRegValueWorkItem> work_item( |
259 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, parent_key, | 295 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
260 name, data, false)); | 296 parent_key, |
| 297 WorkItem::kWow64Default, |
| 298 name, |
| 299 data, |
| 300 false)); |
261 EXPECT_FALSE(work_item->Do()); | 301 EXPECT_FALSE(work_item->Do()); |
262 | 302 |
263 work_item.reset(WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, | 303 work_item.reset(WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
264 parent_key, name, dword1, false)); | 304 parent_key, |
| 305 WorkItem::kWow64Default, |
| 306 name, |
| 307 dword1, |
| 308 false)); |
265 EXPECT_FALSE(work_item->Do()); | 309 EXPECT_FALSE(work_item->Do()); |
266 } | 310 } |
OLD | NEW |