OLD | NEW |
1 // Copyright (c) 2009 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2009 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 <fstream> | 7 #include <fstream> |
8 #include <iostream> | 8 #include <iostream> |
9 | 9 |
10 #include "base/base_paths.h" | 10 #include "base/base_paths.h" |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
85 return std::wstring(contents); | 85 return std::wstring(contents); |
86 } | 86 } |
87 | 87 |
88 wchar_t text_content_1[] = L"Gooooooooooooooooooooogle"; | 88 wchar_t text_content_1[] = L"Gooooooooooooooooooooogle"; |
89 wchar_t text_content_2[] = L"Overwrite Me"; | 89 wchar_t text_content_2[] = L"Overwrite Me"; |
90 }; | 90 }; |
91 | 91 |
92 // Copy one file from source to destination. | 92 // Copy one file from source to destination. |
93 TEST_F(CopyTreeWorkItemTest, CopyFile) { | 93 TEST_F(CopyTreeWorkItemTest, CopyFile) { |
94 // Create source file | 94 // Create source file |
95 std::wstring file_name_from(test_dir_.ToWStringHack()); | 95 FilePath file_name_from(test_dir_); |
96 file_util::AppendToPath(&file_name_from, L"File_From.txt"); | 96 file_name_from = file_name_from.AppendASCII("File_From.txt"); |
97 CreateTextFile(file_name_from, text_content_1); | 97 CreateTextFile(file_name_from.value(), text_content_1); |
98 ASSERT_TRUE(file_util::PathExists(file_name_from)); | 98 ASSERT_TRUE(file_util::PathExists(file_name_from)); |
99 | 99 |
100 // Create destination path | 100 // Create destination path |
101 std::wstring dir_name_to(test_dir_.ToWStringHack()); | 101 FilePath dir_name_to(test_dir_); |
102 file_util::AppendToPath(&dir_name_to, L"Copy_To_Subdir"); | 102 dir_name_to = dir_name_to.AppendASCII("Copy_To_Subdir"); |
103 CreateDirectory(dir_name_to.c_str(), NULL); | 103 CreateDirectory(dir_name_to.value().c_str(), NULL); |
104 ASSERT_TRUE(file_util::PathExists(dir_name_to)); | 104 ASSERT_TRUE(file_util::PathExists(dir_name_to)); |
105 | 105 |
106 std::wstring file_name_to(dir_name_to); | 106 FilePath file_name_to(dir_name_to); |
107 file_util::AppendToPath(&file_name_to, L"File_To.txt"); | 107 file_name_to = file_name_to.AppendASCII("File_To.txt"); |
108 | 108 |
109 // test Do() | 109 // test Do() |
110 scoped_ptr<CopyTreeWorkItem> work_item( | 110 scoped_ptr<CopyTreeWorkItem> work_item( |
111 WorkItem::CreateCopyTreeWorkItem(file_name_from, file_name_to, | 111 WorkItem::CreateCopyTreeWorkItem(file_name_from.ToWStringHack(), |
| 112 file_name_to.ToWStringHack(), |
112 temp_dir_.ToWStringHack(), | 113 temp_dir_.ToWStringHack(), |
113 WorkItem::ALWAYS)); | 114 WorkItem::ALWAYS)); |
114 | 115 |
115 EXPECT_TRUE(work_item->Do()); | 116 EXPECT_TRUE(work_item->Do()); |
116 | 117 |
117 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 118 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
118 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 119 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
119 EXPECT_TRUE(file_util::ContentsEqual(file_name_from, file_name_to)); | 120 EXPECT_TRUE(file_util::ContentsEqual(file_name_from, file_name_to)); |
120 | 121 |
121 // test rollback() | 122 // test rollback() |
122 work_item->Rollback(); | 123 work_item->Rollback(); |
123 | 124 |
124 EXPECT_FALSE(file_util::PathExists(file_name_to)); | 125 EXPECT_FALSE(file_util::PathExists(file_name_to)); |
125 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 126 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
126 } | 127 } |
127 | 128 |
128 // Copy one file, overwriting the existing one in destination. | 129 // Copy one file, overwriting the existing one in destination. |
129 // Test with always_overwrite being true or false. The file is overwritten | 130 // Test with always_overwrite being true or false. The file is overwritten |
130 // regardless since the content at destination file is different from source. | 131 // regardless since the content at destination file is different from source. |
131 TEST_F(CopyTreeWorkItemTest, CopyFileOverwrite) { | 132 TEST_F(CopyTreeWorkItemTest, CopyFileOverwrite) { |
132 // Create source file | 133 // Create source file |
133 std::wstring file_name_from(test_dir_.ToWStringHack()); | 134 FilePath file_name_from(test_dir_); |
134 file_util::AppendToPath(&file_name_from, L"File_From.txt"); | 135 file_name_from = file_name_from.AppendASCII("File_From.txt"); |
135 CreateTextFile(file_name_from, text_content_1); | 136 CreateTextFile(file_name_from.value(), text_content_1); |
136 ASSERT_TRUE(file_util::PathExists(file_name_from)); | 137 ASSERT_TRUE(file_util::PathExists(file_name_from)); |
137 | 138 |
138 // Create destination file | 139 // Create destination file |
139 std::wstring dir_name_to(test_dir_.ToWStringHack()); | 140 FilePath dir_name_to(test_dir_); |
140 file_util::AppendToPath(&dir_name_to, L"Copy_To_Subdir"); | 141 dir_name_to = dir_name_to.AppendASCII("Copy_To_Subdir"); |
141 CreateDirectory(dir_name_to.c_str(), NULL); | 142 CreateDirectory(dir_name_to.value().c_str(), NULL); |
142 ASSERT_TRUE(file_util::PathExists(dir_name_to)); | 143 ASSERT_TRUE(file_util::PathExists(dir_name_to)); |
143 | 144 |
144 std::wstring file_name_to(dir_name_to); | 145 FilePath file_name_to(dir_name_to); |
145 file_util::AppendToPath(&file_name_to, L"File_To.txt"); | 146 file_name_to = file_name_to.AppendASCII("File_To.txt"); |
146 CreateTextFile(file_name_to, text_content_2); | 147 CreateTextFile(file_name_to.value(), text_content_2); |
147 ASSERT_TRUE(file_util::PathExists(file_name_to)); | 148 ASSERT_TRUE(file_util::PathExists(file_name_to)); |
148 | 149 |
149 // test Do() with always_overwrite being true. | 150 // test Do() with always_overwrite being true. |
150 scoped_ptr<CopyTreeWorkItem> work_item( | 151 scoped_ptr<CopyTreeWorkItem> work_item( |
151 WorkItem::CreateCopyTreeWorkItem(file_name_from, file_name_to, | 152 WorkItem::CreateCopyTreeWorkItem(file_name_from.ToWStringHack(), |
| 153 file_name_to.ToWStringHack(), |
152 temp_dir_.ToWStringHack(), | 154 temp_dir_.ToWStringHack(), |
153 WorkItem::ALWAYS)); | 155 WorkItem::ALWAYS)); |
154 | 156 |
155 EXPECT_TRUE(work_item->Do()); | 157 EXPECT_TRUE(work_item->Do()); |
156 | 158 |
157 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 159 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
158 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 160 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
159 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 161 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
160 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_1)); | 162 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_1)); |
161 | 163 |
162 // test rollback() | 164 // test rollback() |
163 work_item->Rollback(); | 165 work_item->Rollback(); |
164 | 166 |
165 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 167 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
166 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 168 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
167 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 169 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
168 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_2)); | 170 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_2)); |
169 | 171 |
170 // test Do() with always_overwrite being false. | 172 // test Do() with always_overwrite being false. |
171 // the file is still overwritten since the content is different. | 173 // the file is still overwritten since the content is different. |
172 work_item.reset( | 174 work_item.reset( |
173 WorkItem::CreateCopyTreeWorkItem(file_name_from, file_name_to, | 175 WorkItem::CreateCopyTreeWorkItem(file_name_from.ToWStringHack(), |
| 176 file_name_to.ToWStringHack(), |
174 temp_dir_.ToWStringHack(), | 177 temp_dir_.ToWStringHack(), |
175 WorkItem::IF_DIFFERENT)); | 178 WorkItem::IF_DIFFERENT)); |
176 | 179 |
177 EXPECT_TRUE(work_item->Do()); | 180 EXPECT_TRUE(work_item->Do()); |
178 | 181 |
179 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 182 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
180 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 183 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
181 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 184 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
182 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_1)); | 185 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_1)); |
183 | 186 |
184 // test rollback() | 187 // test rollback() |
185 work_item->Rollback(); | 188 work_item->Rollback(); |
186 | 189 |
187 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 190 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
188 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 191 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
189 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 192 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
190 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_2)); | 193 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_2)); |
191 } | 194 } |
192 | 195 |
193 // Copy one file, with the existing one in destination having the same | 196 // Copy one file, with the existing one in destination having the same |
194 // content. | 197 // content. |
195 // If always_overwrite being true, the file is overwritten. | 198 // If always_overwrite being true, the file is overwritten. |
196 // If always_overwrite being false, the file is unchanged. | 199 // If always_overwrite being false, the file is unchanged. |
197 TEST_F(CopyTreeWorkItemTest, CopyFileSameContent) { | 200 TEST_F(CopyTreeWorkItemTest, CopyFileSameContent) { |
198 // Create source file | 201 // Create source file |
199 std::wstring file_name_from(test_dir_.ToWStringHack()); | 202 FilePath file_name_from(test_dir_); |
200 file_util::AppendToPath(&file_name_from, L"File_From.txt"); | 203 file_name_from = file_name_from.AppendASCII("File_From.txt"); |
201 CreateTextFile(file_name_from, text_content_1); | 204 CreateTextFile(file_name_from.value(), text_content_1); |
202 ASSERT_TRUE(file_util::PathExists(file_name_from)); | 205 ASSERT_TRUE(file_util::PathExists(file_name_from)); |
203 | 206 |
204 // Create destination file | 207 // Create destination file |
205 std::wstring dir_name_to(test_dir_.ToWStringHack()); | 208 FilePath dir_name_to(test_dir_); |
206 file_util::AppendToPath(&dir_name_to, L"Copy_To_Subdir"); | 209 dir_name_to = dir_name_to.AppendASCII("Copy_To_Subdir"); |
207 CreateDirectory(dir_name_to.c_str(), NULL); | 210 CreateDirectory(dir_name_to.value().c_str(), NULL); |
208 ASSERT_TRUE(file_util::PathExists(dir_name_to)); | 211 ASSERT_TRUE(file_util::PathExists(dir_name_to)); |
209 | 212 |
210 std::wstring file_name_to(dir_name_to); | 213 FilePath file_name_to(dir_name_to); |
211 file_util::AppendToPath(&file_name_to, L"File_To.txt"); | 214 file_name_to = file_name_to.AppendASCII("File_To.txt"); |
212 CreateTextFile(file_name_to, text_content_1); | 215 CreateTextFile(file_name_to.value(), text_content_1); |
213 ASSERT_TRUE(file_util::PathExists(file_name_to)); | 216 ASSERT_TRUE(file_util::PathExists(file_name_to)); |
214 | 217 |
215 // Get the path of backup file | 218 // Get the path of backup file |
216 std::wstring backup_file(temp_dir_.ToWStringHack()); | 219 FilePath backup_file(temp_dir_); |
217 file_util::AppendToPath(&backup_file, L"File_To.txt"); | 220 backup_file = backup_file.AppendASCII("File_To.txt"); |
218 | 221 |
219 // test Do() with always_overwrite being true. | 222 // test Do() with always_overwrite being true. |
220 scoped_ptr<CopyTreeWorkItem> work_item( | 223 scoped_ptr<CopyTreeWorkItem> work_item( |
221 WorkItem::CreateCopyTreeWorkItem(file_name_from, file_name_to, | 224 WorkItem::CreateCopyTreeWorkItem(file_name_from.ToWStringHack(), |
| 225 file_name_to.ToWStringHack(), |
222 temp_dir_.ToWStringHack(), | 226 temp_dir_.ToWStringHack(), |
223 WorkItem::ALWAYS)); | 227 WorkItem::ALWAYS)); |
224 | 228 |
225 EXPECT_TRUE(work_item->Do()); | 229 EXPECT_TRUE(work_item->Do()); |
226 | 230 |
227 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 231 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
228 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 232 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
229 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 233 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
230 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_1)); | 234 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_1)); |
231 // we verify the file is overwritten by checking the existence of backup | 235 // we verify the file is overwritten by checking the existence of backup |
232 // file. | 236 // file. |
233 EXPECT_TRUE(file_util::PathExists(backup_file)); | 237 EXPECT_TRUE(file_util::PathExists(backup_file)); |
234 EXPECT_EQ(0, ReadTextFile(backup_file).compare(text_content_1)); | 238 EXPECT_EQ(0, ReadTextFile(backup_file.value()).compare(text_content_1)); |
235 | 239 |
236 // test rollback() | 240 // test rollback() |
237 work_item->Rollback(); | 241 work_item->Rollback(); |
238 | 242 |
239 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 243 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
240 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 244 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
241 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 245 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
242 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_1)); | 246 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_1)); |
243 // the backup file should be gone after rollback | 247 // the backup file should be gone after rollback |
244 EXPECT_FALSE(file_util::PathExists(backup_file)); | 248 EXPECT_FALSE(file_util::PathExists(backup_file)); |
245 | 249 |
246 // test Do() with always_overwrite being false. nothing should change. | 250 // test Do() with always_overwrite being false. nothing should change. |
247 work_item.reset( | 251 work_item.reset( |
248 WorkItem::CreateCopyTreeWorkItem(file_name_from, file_name_to, | 252 WorkItem::CreateCopyTreeWorkItem(file_name_from.ToWStringHack(), |
| 253 file_name_to.ToWStringHack(), |
249 temp_dir_.ToWStringHack(), | 254 temp_dir_.ToWStringHack(), |
250 WorkItem::IF_DIFFERENT)); | 255 WorkItem::IF_DIFFERENT)); |
251 | 256 |
252 EXPECT_TRUE(work_item->Do()); | 257 EXPECT_TRUE(work_item->Do()); |
253 | 258 |
254 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 259 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
255 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 260 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
256 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 261 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
257 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_1)); | 262 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_1)); |
258 // we verify the file is not overwritten by checking that the backup | 263 // we verify the file is not overwritten by checking that the backup |
259 // file does not exist. | 264 // file does not exist. |
260 EXPECT_FALSE(file_util::PathExists(backup_file)); | 265 EXPECT_FALSE(file_util::PathExists(backup_file)); |
261 | 266 |
262 // test rollback(). nothing should happen here. | 267 // test rollback(). nothing should happen here. |
263 work_item->Rollback(); | 268 work_item->Rollback(); |
264 | 269 |
265 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 270 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
266 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 271 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
267 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 272 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
268 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_1)); | 273 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_1)); |
269 EXPECT_FALSE(file_util::PathExists(backup_file)); | 274 EXPECT_FALSE(file_util::PathExists(backup_file)); |
270 } | 275 } |
271 | 276 |
272 // Copy one file and without rollback. Verify all temporary files are deleted. | 277 // Copy one file and without rollback. Verify all temporary files are deleted. |
273 TEST_F(CopyTreeWorkItemTest, CopyFileAndCleanup) { | 278 TEST_F(CopyTreeWorkItemTest, CopyFileAndCleanup) { |
274 // Create source file | 279 // Create source file |
275 std::wstring file_name_from(test_dir_.ToWStringHack()); | 280 FilePath file_name_from(test_dir_); |
276 file_util::AppendToPath(&file_name_from, L"File_From.txt"); | 281 file_name_from = file_name_from.AppendASCII("File_From.txt"); |
277 CreateTextFile(file_name_from, text_content_1); | 282 CreateTextFile(file_name_from.value(), text_content_1); |
278 ASSERT_TRUE(file_util::PathExists(file_name_from)); | 283 ASSERT_TRUE(file_util::PathExists(file_name_from)); |
279 | 284 |
280 // Create destination file | 285 // Create destination file |
281 std::wstring dir_name_to(test_dir_.ToWStringHack()); | 286 FilePath dir_name_to(test_dir_); |
282 file_util::AppendToPath(&dir_name_to, L"Copy_To_Subdir"); | 287 dir_name_to = dir_name_to.AppendASCII("Copy_To_Subdir"); |
283 CreateDirectory(dir_name_to.c_str(), NULL); | 288 CreateDirectory(dir_name_to.value().c_str(), NULL); |
284 ASSERT_TRUE(file_util::PathExists(dir_name_to)); | 289 ASSERT_TRUE(file_util::PathExists(dir_name_to)); |
285 | 290 |
286 std::wstring file_name_to(dir_name_to); | 291 FilePath file_name_to(dir_name_to); |
287 file_util::AppendToPath(&file_name_to, L"File_To.txt"); | 292 file_name_to = file_name_to.AppendASCII("File_To.txt"); |
288 CreateTextFile(file_name_to, text_content_2); | 293 CreateTextFile(file_name_to.value(), text_content_2); |
289 ASSERT_TRUE(file_util::PathExists(file_name_to)); | 294 ASSERT_TRUE(file_util::PathExists(file_name_to)); |
290 | 295 |
291 // Get the path of backup file | 296 // Get the path of backup file |
292 std::wstring backup_file(temp_dir_.ToWStringHack()); | 297 FilePath backup_file(temp_dir_); |
293 file_util::AppendToPath(&backup_file, L"File_To.txt"); | 298 backup_file = backup_file.AppendASCII("File_To.txt"); |
294 | 299 |
295 { | 300 { |
296 // test Do(). | 301 // test Do(). |
297 scoped_ptr<CopyTreeWorkItem> work_item( | 302 scoped_ptr<CopyTreeWorkItem> work_item( |
298 WorkItem::CreateCopyTreeWorkItem(file_name_from, file_name_to, | 303 WorkItem::CreateCopyTreeWorkItem(file_name_from.ToWStringHack(), |
| 304 file_name_to.ToWStringHack(), |
299 temp_dir_.ToWStringHack(), | 305 temp_dir_.ToWStringHack(), |
300 WorkItem::IF_DIFFERENT)); | 306 WorkItem::IF_DIFFERENT)); |
301 | 307 |
302 EXPECT_TRUE(work_item->Do()); | 308 EXPECT_TRUE(work_item->Do()); |
303 | 309 |
304 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 310 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
305 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 311 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
306 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 312 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
307 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_1)); | 313 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_1)); |
308 // verify the file is moved to backup place. | 314 // verify the file is moved to backup place. |
309 EXPECT_TRUE(file_util::PathExists(backup_file)); | 315 EXPECT_TRUE(file_util::PathExists(backup_file)); |
310 EXPECT_EQ(0, ReadTextFile(backup_file).compare(text_content_2)); | 316 EXPECT_EQ(0, ReadTextFile(backup_file.value()).compare(text_content_2)); |
311 } | 317 } |
312 | 318 |
313 // verify the backup file is cleaned up as well. | 319 // verify the backup file is cleaned up as well. |
314 EXPECT_FALSE(file_util::PathExists(backup_file)); | 320 EXPECT_FALSE(file_util::PathExists(backup_file)); |
315 } | 321 } |
316 | 322 |
317 // Copy one file, with the existing one in destination being used with | 323 // Copy one file, with the existing one in destination being used with |
318 // overwrite option as IF_DIFFERENT. This destination-file-in-use should | 324 // overwrite option as IF_DIFFERENT. This destination-file-in-use should |
319 // be moved to backup location after Do() and moved back after Rollback(). | 325 // be moved to backup location after Do() and moved back after Rollback(). |
320 TEST_F(CopyTreeWorkItemTest, CopyFileInUse) { | 326 TEST_F(CopyTreeWorkItemTest, CopyFileInUse) { |
321 // Create source file | 327 // Create source file |
322 std::wstring file_name_from(test_dir_.ToWStringHack()); | 328 FilePath file_name_from(test_dir_); |
323 file_util::AppendToPath(&file_name_from, L"File_From"); | 329 file_name_from = file_name_from.AppendASCII("File_From"); |
324 CreateTextFile(file_name_from, text_content_1); | 330 CreateTextFile(file_name_from.value(), text_content_1); |
325 ASSERT_TRUE(file_util::PathExists(file_name_from)); | 331 ASSERT_TRUE(file_util::PathExists(file_name_from)); |
326 | 332 |
327 // Create an executable in destination path by copying ourself to it. | 333 // Create an executable in destination path by copying ourself to it. |
328 wchar_t exe_full_path_str[MAX_PATH]; | 334 wchar_t exe_full_path_str[MAX_PATH]; |
329 ::GetModuleFileName(NULL, exe_full_path_str, MAX_PATH); | 335 ::GetModuleFileName(NULL, exe_full_path_str, MAX_PATH); |
330 std::wstring exe_full_path(exe_full_path_str); | 336 FilePath exe_full_path(exe_full_path_str); |
331 | 337 |
332 std::wstring dir_name_to(test_dir_.ToWStringHack()); | 338 FilePath dir_name_to(test_dir_); |
333 file_util::AppendToPath(&dir_name_to, L"Copy_To_Subdir"); | 339 dir_name_to = dir_name_to.AppendASCII("Copy_To_Subdir"); |
334 CreateDirectory(dir_name_to.c_str(), NULL); | 340 CreateDirectory(dir_name_to.value().c_str(), NULL); |
335 ASSERT_TRUE(file_util::PathExists(dir_name_to)); | 341 ASSERT_TRUE(file_util::PathExists(dir_name_to)); |
336 | 342 |
337 std::wstring file_name_to(dir_name_to); | 343 FilePath file_name_to(dir_name_to); |
338 file_util::AppendToPath(&file_name_to, L"File_To"); | 344 file_name_to = file_name_to.AppendASCII("File_To"); |
339 file_util::CopyFile(exe_full_path, file_name_to); | 345 file_util::CopyFile(exe_full_path, file_name_to); |
340 ASSERT_TRUE(file_util::PathExists(file_name_to)); | 346 ASSERT_TRUE(file_util::PathExists(file_name_to)); |
341 | 347 |
342 LOG(INFO) << "copy ourself from " << exe_full_path << " to " << file_name_to; | 348 LOG(INFO) << "copy ourself from " |
| 349 << exe_full_path.value() << " to " << file_name_to.value(); |
343 | 350 |
344 // Run the executable in destination path | 351 // Run the executable in destination path |
345 STARTUPINFOW si = {sizeof(si)}; | 352 STARTUPINFOW si = {sizeof(si)}; |
346 PROCESS_INFORMATION pi = {0}; | 353 PROCESS_INFORMATION pi = {0}; |
347 ASSERT_TRUE( | 354 ASSERT_TRUE( |
348 ::CreateProcess(NULL, const_cast<wchar_t*>(file_name_to.c_str()), | 355 ::CreateProcess(NULL, const_cast<wchar_t*>(file_name_to.value().c_str()), |
349 NULL, NULL, FALSE, CREATE_NO_WINDOW | CREATE_SUSPENDED, | 356 NULL, NULL, FALSE, CREATE_NO_WINDOW | CREATE_SUSPENDED, |
350 NULL, NULL, &si, &pi)); | 357 NULL, NULL, &si, &pi)); |
351 | 358 |
352 // Get the path of backup file | 359 // Get the path of backup file |
353 std::wstring backup_file(temp_dir_.ToWStringHack()); | 360 FilePath backup_file(temp_dir_); |
354 file_util::AppendToPath(&backup_file, L"File_To"); | 361 backup_file = backup_file.AppendASCII("File_To"); |
355 | 362 |
356 // test Do(). | 363 // test Do(). |
357 scoped_ptr<CopyTreeWorkItem> work_item( | 364 scoped_ptr<CopyTreeWorkItem> work_item( |
358 WorkItem::CreateCopyTreeWorkItem(file_name_from, file_name_to, | 365 WorkItem::CreateCopyTreeWorkItem(file_name_from.ToWStringHack(), |
| 366 file_name_to.ToWStringHack(), |
359 temp_dir_.ToWStringHack(), | 367 temp_dir_.ToWStringHack(), |
360 WorkItem::IF_DIFFERENT)); | 368 WorkItem::IF_DIFFERENT)); |
361 | 369 |
362 EXPECT_TRUE(work_item->Do()); | 370 EXPECT_TRUE(work_item->Do()); |
363 | 371 |
364 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 372 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
365 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 373 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
366 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 374 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
367 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_1)); | 375 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_1)); |
368 // verify the file in used is moved to backup place. | 376 // verify the file in used is moved to backup place. |
369 EXPECT_TRUE(file_util::PathExists(backup_file)); | 377 EXPECT_TRUE(file_util::PathExists(backup_file)); |
370 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, backup_file)); | 378 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, backup_file)); |
371 | 379 |
372 // test rollback() | 380 // test rollback() |
373 work_item->Rollback(); | 381 work_item->Rollback(); |
374 | 382 |
375 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 383 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
376 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 384 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
377 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 385 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
378 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); | 386 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); |
379 // the backup file should be gone after rollback | 387 // the backup file should be gone after rollback |
380 EXPECT_FALSE(file_util::PathExists(backup_file)); | 388 EXPECT_FALSE(file_util::PathExists(backup_file)); |
381 | 389 |
382 TerminateProcess(pi.hProcess, 0); | 390 TerminateProcess(pi.hProcess, 0); |
383 // make sure the handle is closed. | 391 // make sure the handle is closed. |
384 EXPECT_TRUE(WaitForSingleObject(pi.hProcess, 10000) == WAIT_OBJECT_0); | 392 EXPECT_TRUE(WaitForSingleObject(pi.hProcess, 10000) == WAIT_OBJECT_0); |
385 CloseHandle(pi.hProcess); | 393 CloseHandle(pi.hProcess); |
386 CloseHandle(pi.hThread); | 394 CloseHandle(pi.hThread); |
387 } | 395 } |
388 | 396 |
389 // Test overwrite option NEW_NAME_IF_IN_USE: | 397 // Test overwrite option NEW_NAME_IF_IN_USE: |
390 // 1. If destination file is in use, the source should be copied with the | 398 // 1. If destination file is in use, the source should be copied with the |
391 // new name after Do() and this new name file should be deleted | 399 // new name after Do() and this new name file should be deleted |
392 // after rollback. | 400 // after rollback. |
393 // 2. If destination file is not in use, the source should be copied in the | 401 // 2. If destination file is not in use, the source should be copied in the |
394 // destination folder after Do() and should be rolled back after Rollback(). | 402 // destination folder after Do() and should be rolled back after Rollback(). |
395 TEST_F(CopyTreeWorkItemTest, NewNameAndCopyTest) { | 403 TEST_F(CopyTreeWorkItemTest, NewNameAndCopyTest) { |
396 // Create source file | 404 // Create source file |
397 std::wstring file_name_from(test_dir_.ToWStringHack()); | 405 FilePath file_name_from(test_dir_); |
398 file_util::AppendToPath(&file_name_from, L"File_From"); | 406 file_name_from = file_name_from.AppendASCII("File_From"); |
399 CreateTextFile(file_name_from, text_content_1); | 407 CreateTextFile(file_name_from.value(), text_content_1); |
400 ASSERT_TRUE(file_util::PathExists(file_name_from)); | 408 ASSERT_TRUE(file_util::PathExists(file_name_from)); |
401 | 409 |
402 // Create an executable in destination path by copying ourself to it. | 410 // Create an executable in destination path by copying ourself to it. |
403 wchar_t exe_full_path_str[MAX_PATH]; | 411 wchar_t exe_full_path_str[MAX_PATH]; |
404 ::GetModuleFileName(NULL, exe_full_path_str, MAX_PATH); | 412 ::GetModuleFileName(NULL, exe_full_path_str, MAX_PATH); |
405 std::wstring exe_full_path(exe_full_path_str); | 413 FilePath exe_full_path(exe_full_path_str); |
406 | 414 |
407 std::wstring dir_name_to(test_dir_.ToWStringHack()); | 415 FilePath dir_name_to(test_dir_); |
408 file_util::AppendToPath(&dir_name_to, L"Copy_To_Subdir"); | 416 dir_name_to = dir_name_to.AppendASCII("Copy_To_Subdir"); |
409 CreateDirectory(dir_name_to.c_str(), NULL); | 417 CreateDirectory(dir_name_to.value().c_str(), NULL); |
410 ASSERT_TRUE(file_util::PathExists(dir_name_to)); | 418 ASSERT_TRUE(file_util::PathExists(dir_name_to)); |
411 | 419 |
412 std::wstring file_name_to(dir_name_to), alternate_to(dir_name_to); | 420 FilePath file_name_to(dir_name_to), alternate_to(dir_name_to); |
413 file_util::AppendToPath(&file_name_to, L"File_To"); | 421 file_name_to = file_name_to.AppendASCII("File_To"); |
414 file_util::AppendToPath(&alternate_to, L"Alternate_To"); | 422 alternate_to = alternate_to.AppendASCII("Alternate_To"); |
415 file_util::CopyFile(exe_full_path, file_name_to); | 423 file_util::CopyFile(exe_full_path, file_name_to); |
416 ASSERT_TRUE(file_util::PathExists(file_name_to)); | 424 ASSERT_TRUE(file_util::PathExists(file_name_to)); |
417 | 425 |
418 LOG(INFO) << "copy ourself from " << exe_full_path << " to " << file_name_to; | 426 LOG(INFO) << "copy ourself from " |
| 427 << exe_full_path.value() << " to " << file_name_to.value(); |
419 | 428 |
420 // Run the executable in destination path | 429 // Run the executable in destination path |
421 STARTUPINFOW si = {sizeof(si)}; | 430 STARTUPINFOW si = {sizeof(si)}; |
422 PROCESS_INFORMATION pi = {0}; | 431 PROCESS_INFORMATION pi = {0}; |
423 ASSERT_TRUE( | 432 ASSERT_TRUE( |
424 ::CreateProcess(NULL, const_cast<wchar_t*>(file_name_to.c_str()), | 433 ::CreateProcess(NULL, const_cast<wchar_t*>(file_name_to.value().c_str()), |
425 NULL, NULL, FALSE, CREATE_NO_WINDOW | CREATE_SUSPENDED, | 434 NULL, NULL, FALSE, CREATE_NO_WINDOW | CREATE_SUSPENDED, |
426 NULL, NULL, &si, &pi)); | 435 NULL, NULL, &si, &pi)); |
427 | 436 |
428 // Get the path of backup file | 437 // Get the path of backup file |
429 std::wstring backup_file(temp_dir_.ToWStringHack()); | 438 FilePath backup_file(temp_dir_); |
430 file_util::AppendToPath(&backup_file, L"File_To"); | 439 backup_file = backup_file.AppendASCII("File_To"); |
431 | 440 |
432 // test Do(). | 441 // test Do(). |
433 scoped_ptr<CopyTreeWorkItem> work_item( | 442 scoped_ptr<CopyTreeWorkItem> work_item( |
434 WorkItem::CreateCopyTreeWorkItem(file_name_from, file_name_to, | 443 WorkItem::CreateCopyTreeWorkItem(file_name_from.ToWStringHack(), |
| 444 file_name_to.ToWStringHack(), |
435 temp_dir_.ToWStringHack(), | 445 temp_dir_.ToWStringHack(), |
436 WorkItem::NEW_NAME_IF_IN_USE, | 446 WorkItem::NEW_NAME_IF_IN_USE, |
437 alternate_to)); | 447 alternate_to.ToWStringHack())); |
438 | 448 |
439 EXPECT_TRUE(work_item->Do()); | 449 EXPECT_TRUE(work_item->Do()); |
440 | 450 |
441 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 451 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
442 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 452 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
443 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 453 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
444 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); | 454 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); |
445 // verify that the backup path does not exist | 455 // verify that the backup path does not exist |
446 EXPECT_FALSE(file_util::PathExists(backup_file)); | 456 EXPECT_FALSE(file_util::PathExists(backup_file)); |
447 EXPECT_TRUE(file_util::ContentsEqual(file_name_from, alternate_to)); | 457 EXPECT_TRUE(file_util::ContentsEqual(file_name_from, alternate_to)); |
448 | 458 |
449 // test rollback() | 459 // test rollback() |
450 work_item->Rollback(); | 460 work_item->Rollback(); |
451 | 461 |
452 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 462 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
453 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 463 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
454 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 464 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
455 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); | 465 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); |
456 EXPECT_FALSE(file_util::PathExists(backup_file)); | 466 EXPECT_FALSE(file_util::PathExists(backup_file)); |
457 // the alternate file should be gone after rollback | 467 // the alternate file should be gone after rollback |
458 EXPECT_FALSE(file_util::PathExists(alternate_to)); | 468 EXPECT_FALSE(file_util::PathExists(alternate_to)); |
459 | 469 |
460 TerminateProcess(pi.hProcess, 0); | 470 TerminateProcess(pi.hProcess, 0); |
461 // make sure the handle is closed. | 471 // make sure the handle is closed. |
462 EXPECT_TRUE(WaitForSingleObject(pi.hProcess, 10000) == WAIT_OBJECT_0); | 472 EXPECT_TRUE(WaitForSingleObject(pi.hProcess, 10000) == WAIT_OBJECT_0); |
463 CloseHandle(pi.hProcess); | 473 CloseHandle(pi.hProcess); |
464 CloseHandle(pi.hThread); | 474 CloseHandle(pi.hThread); |
465 | 475 |
466 // Now the process has terminated, lets try overwriting the file again | 476 // Now the process has terminated, lets try overwriting the file again |
467 work_item.reset(WorkItem::CreateCopyTreeWorkItem(file_name_from, | 477 work_item.reset(WorkItem::CreateCopyTreeWorkItem( |
468 file_name_to, temp_dir_.ToWStringHack(), WorkItem::NEW_NAME_IF_IN_USE, | 478 file_name_from.ToWStringHack(), file_name_to.ToWStringHack(), |
469 alternate_to)); | 479 temp_dir_.ToWStringHack(), WorkItem::NEW_NAME_IF_IN_USE, |
470 if (IsFileInUse(file_name_to)) | 480 alternate_to.ToWStringHack())); |
| 481 if (IsFileInUse(file_name_to.value())) |
471 PlatformThread::Sleep(2000); | 482 PlatformThread::Sleep(2000); |
472 // If file is still in use, the rest of the test will fail. | 483 // If file is still in use, the rest of the test will fail. |
473 ASSERT_FALSE(IsFileInUse(file_name_to)); | 484 ASSERT_FALSE(IsFileInUse(file_name_to.value())); |
474 EXPECT_TRUE(work_item->Do()); | 485 EXPECT_TRUE(work_item->Do()); |
475 | 486 |
476 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 487 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
477 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 488 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
478 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 489 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
479 EXPECT_TRUE(file_util::ContentsEqual(file_name_from, file_name_to)); | 490 EXPECT_TRUE(file_util::ContentsEqual(file_name_from, file_name_to)); |
480 // verify that the backup path does exist | 491 // verify that the backup path does exist |
481 EXPECT_TRUE(file_util::PathExists(backup_file)); | 492 EXPECT_TRUE(file_util::PathExists(backup_file)); |
482 EXPECT_FALSE(file_util::PathExists(alternate_to)); | 493 EXPECT_FALSE(file_util::PathExists(alternate_to)); |
483 | 494 |
484 // test rollback() | 495 // test rollback() |
485 work_item->Rollback(); | 496 work_item->Rollback(); |
486 | 497 |
487 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 498 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
488 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 499 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
489 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 500 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
490 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); | 501 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); |
491 // the backup file should be gone after rollback | 502 // the backup file should be gone after rollback |
492 EXPECT_FALSE(file_util::PathExists(backup_file)); | 503 EXPECT_FALSE(file_util::PathExists(backup_file)); |
493 EXPECT_FALSE(file_util::PathExists(alternate_to)); | 504 EXPECT_FALSE(file_util::PathExists(alternate_to)); |
494 } | 505 } |
495 | 506 |
496 // Test overwrite option IF_NOT_PRESENT: | 507 // Test overwrite option IF_NOT_PRESENT: |
497 // 1. If destination file/directory exist, the source should not be copied | 508 // 1. If destination file/directory exist, the source should not be copied |
498 // 2. If destination file/directory do not exist, the source should be copied | 509 // 2. If destination file/directory do not exist, the source should be copied |
499 // in the destination folder after Do() and should be rolled back after | 510 // in the destination folder after Do() and should be rolled back after |
500 // Rollback(). | 511 // Rollback(). |
501 TEST_F(CopyTreeWorkItemTest, IfNotPresentTest) { | 512 TEST_F(CopyTreeWorkItemTest, IfNotPresentTest) { |
502 // Create source file | 513 // Create source file |
503 std::wstring file_name_from(test_dir_.ToWStringHack()); | 514 FilePath file_name_from(test_dir_); |
504 file_util::AppendToPath(&file_name_from, L"File_From"); | 515 file_name_from = file_name_from.AppendASCII("File_From"); |
505 CreateTextFile(file_name_from, text_content_1); | 516 CreateTextFile(file_name_from.value(), text_content_1); |
506 ASSERT_TRUE(file_util::PathExists(file_name_from)); | 517 ASSERT_TRUE(file_util::PathExists(file_name_from)); |
507 | 518 |
508 // Create an executable in destination path by copying ourself to it. | 519 // Create an executable in destination path by copying ourself to it. |
509 wchar_t exe_full_path_str[MAX_PATH]; | 520 wchar_t exe_full_path_str[MAX_PATH]; |
510 ::GetModuleFileName(NULL, exe_full_path_str, MAX_PATH); | 521 ::GetModuleFileName(NULL, exe_full_path_str, MAX_PATH); |
511 std::wstring exe_full_path(exe_full_path_str); | 522 FilePath exe_full_path(exe_full_path_str); |
512 std::wstring dir_name_to(test_dir_.ToWStringHack()); | 523 |
513 file_util::AppendToPath(&dir_name_to, L"Copy_To_Subdir"); | 524 FilePath dir_name_to(test_dir_); |
514 CreateDirectory(dir_name_to.c_str(), NULL); | 525 dir_name_to = dir_name_to.AppendASCII("Copy_To_Subdir"); |
| 526 CreateDirectory(dir_name_to.value().c_str(), NULL); |
515 ASSERT_TRUE(file_util::PathExists(dir_name_to)); | 527 ASSERT_TRUE(file_util::PathExists(dir_name_to)); |
516 std::wstring file_name_to(dir_name_to); | 528 FilePath file_name_to(dir_name_to); |
517 file_util::AppendToPath(&file_name_to, L"File_To"); | 529 file_name_to = file_name_to.AppendASCII("File_To"); |
518 file_util::CopyFile(exe_full_path, file_name_to); | 530 file_util::CopyFile(exe_full_path, file_name_to); |
519 ASSERT_TRUE(file_util::PathExists(file_name_to)); | 531 ASSERT_TRUE(file_util::PathExists(file_name_to)); |
520 | 532 |
521 // Get the path of backup file | 533 // Get the path of backup file |
522 std::wstring backup_file(temp_dir_.ToWStringHack()); | 534 FilePath backup_file(temp_dir_); |
523 file_util::AppendToPath(&backup_file, L"File_To"); | 535 backup_file = backup_file.AppendASCII("File_To"); |
524 | 536 |
525 // test Do(). | 537 // test Do(). |
526 scoped_ptr<CopyTreeWorkItem> work_item( | 538 scoped_ptr<CopyTreeWorkItem> work_item( |
527 WorkItem::CreateCopyTreeWorkItem(file_name_from, file_name_to, | 539 WorkItem::CreateCopyTreeWorkItem(file_name_from.ToWStringHack(), |
528 temp_dir_.ToWStringHack(), WorkItem::IF_NOT_PRESENT, L"")); | 540 file_name_to.ToWStringHack(), temp_dir_.ToWStringHack(), |
| 541 WorkItem::IF_NOT_PRESENT, L"")); |
529 EXPECT_TRUE(work_item->Do()); | 542 EXPECT_TRUE(work_item->Do()); |
530 | 543 |
531 // verify that the source, destination have not changed and backup path | 544 // verify that the source, destination have not changed and backup path |
532 // does not exist | 545 // does not exist |
533 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 546 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
534 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 547 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
535 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 548 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
536 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); | 549 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); |
537 EXPECT_FALSE(file_util::PathExists(backup_file)); | 550 EXPECT_FALSE(file_util::PathExists(backup_file)); |
538 | 551 |
539 // test rollback() | 552 // test rollback() |
540 work_item->Rollback(); | 553 work_item->Rollback(); |
541 | 554 |
542 // verify that the source, destination have not changed and backup path | 555 // verify that the source, destination have not changed and backup path |
543 // does not exist after rollback also | 556 // does not exist after rollback also |
544 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 557 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
545 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 558 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
546 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 559 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
547 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); | 560 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, file_name_to)); |
548 EXPECT_FALSE(file_util::PathExists(backup_file)); | 561 EXPECT_FALSE(file_util::PathExists(backup_file)); |
549 | 562 |
550 // Now delete the destination and try copying the file again. | 563 // Now delete the destination and try copying the file again. |
551 file_util::Delete(file_name_to, true); | 564 file_util::Delete(file_name_to, true); |
552 work_item.reset(WorkItem::CreateCopyTreeWorkItem( | 565 work_item.reset(WorkItem::CreateCopyTreeWorkItem( |
553 file_name_from, file_name_to, temp_dir_.ToWStringHack(), | 566 file_name_from.ToWStringHack(), file_name_to.ToWStringHack(), |
554 WorkItem::IF_NOT_PRESENT, L"")); | 567 temp_dir_.ToWStringHack(), WorkItem::IF_NOT_PRESENT, L"")); |
555 EXPECT_TRUE(work_item->Do()); | 568 EXPECT_TRUE(work_item->Do()); |
556 | 569 |
557 // verify that the source, destination are the same and backup path | 570 // verify that the source, destination are the same and backup path |
558 // does not exist | 571 // does not exist |
559 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 572 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
560 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 573 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
561 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 574 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
562 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_1)); | 575 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_1)); |
563 EXPECT_FALSE(file_util::PathExists(backup_file)); | 576 EXPECT_FALSE(file_util::PathExists(backup_file)); |
564 | 577 |
565 // test rollback() | 578 // test rollback() |
566 work_item->Rollback(); | 579 work_item->Rollback(); |
567 | 580 |
568 // verify that the destination does not exist anymore | 581 // verify that the destination does not exist anymore |
569 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 582 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
570 EXPECT_FALSE(file_util::PathExists(file_name_to)); | 583 EXPECT_FALSE(file_util::PathExists(file_name_to)); |
571 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 584 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
572 EXPECT_FALSE(file_util::PathExists(backup_file)); | 585 EXPECT_FALSE(file_util::PathExists(backup_file)); |
573 } | 586 } |
574 | 587 |
575 // Copy one file without rollback. The existing one in destination is in use. | 588 // Copy one file without rollback. The existing one in destination is in use. |
576 // Verify it is moved to backup location and stays there. | 589 // Verify it is moved to backup location and stays there. |
577 TEST_F(CopyTreeWorkItemTest, CopyFileInUseAndCleanup) { | 590 TEST_F(CopyTreeWorkItemTest, CopyFileInUseAndCleanup) { |
578 // Create source file | 591 // Create source file |
579 std::wstring file_name_from(test_dir_.ToWStringHack()); | 592 FilePath file_name_from(test_dir_); |
580 file_util::AppendToPath(&file_name_from, L"File_From"); | 593 file_name_from = file_name_from.AppendASCII("File_From"); |
581 CreateTextFile(file_name_from, text_content_1); | 594 CreateTextFile(file_name_from.value(), text_content_1); |
582 ASSERT_TRUE(file_util::PathExists(file_name_from)); | 595 ASSERT_TRUE(file_util::PathExists(file_name_from)); |
583 | 596 |
584 // Create an executable in destination path by copying ourself to it. | 597 // Create an executable in destination path by copying ourself to it. |
585 wchar_t exe_full_path_str[MAX_PATH]; | 598 wchar_t exe_full_path_str[MAX_PATH]; |
586 ::GetModuleFileName(NULL, exe_full_path_str, MAX_PATH); | 599 ::GetModuleFileName(NULL, exe_full_path_str, MAX_PATH); |
587 std::wstring exe_full_path(exe_full_path_str); | 600 FilePath exe_full_path(exe_full_path_str); |
588 | 601 |
589 std::wstring dir_name_to(test_dir_.ToWStringHack()); | 602 FilePath dir_name_to(test_dir_); |
590 file_util::AppendToPath(&dir_name_to, L"Copy_To_Subdir"); | 603 dir_name_to = dir_name_to.AppendASCII("Copy_To_Subdir"); |
591 CreateDirectory(dir_name_to.c_str(), NULL); | 604 CreateDirectory(dir_name_to.value().c_str(), NULL); |
592 ASSERT_TRUE(file_util::PathExists(dir_name_to)); | 605 ASSERT_TRUE(file_util::PathExists(dir_name_to)); |
593 | 606 |
594 std::wstring file_name_to(dir_name_to); | 607 FilePath file_name_to(dir_name_to); |
595 file_util::AppendToPath(&file_name_to, L"File_To"); | 608 file_name_to = file_name_to.AppendASCII("File_To"); |
596 file_util::CopyFile(exe_full_path, file_name_to); | 609 file_util::CopyFile(exe_full_path, file_name_to); |
597 ASSERT_TRUE(file_util::PathExists(file_name_to)); | 610 ASSERT_TRUE(file_util::PathExists(file_name_to)); |
598 | 611 |
599 LOG(INFO) << "copy ourself from " << exe_full_path << " to " << file_name_to; | 612 LOG(INFO) << "copy ourself from " |
| 613 << exe_full_path.value() << " to " << file_name_to.value(); |
600 | 614 |
601 // Run the executable in destination path | 615 // Run the executable in destination path |
602 STARTUPINFOW si = {sizeof(si)}; | 616 STARTUPINFOW si = {sizeof(si)}; |
603 PROCESS_INFORMATION pi = {0}; | 617 PROCESS_INFORMATION pi = {0}; |
604 ASSERT_TRUE( | 618 ASSERT_TRUE( |
605 ::CreateProcess(NULL, const_cast<wchar_t*>(file_name_to.c_str()), | 619 ::CreateProcess(NULL, const_cast<wchar_t*>(file_name_to.value().c_str()), |
606 NULL, NULL, FALSE, CREATE_NO_WINDOW | CREATE_SUSPENDED, | 620 NULL, NULL, FALSE, CREATE_NO_WINDOW | CREATE_SUSPENDED, |
607 NULL, NULL, &si, &pi)); | 621 NULL, NULL, &si, &pi)); |
608 | 622 |
609 // Get the path of backup file | 623 // Get the path of backup file |
610 std::wstring backup_file(temp_dir_.ToWStringHack()); | 624 FilePath backup_file(temp_dir_); |
611 file_util::AppendToPath(&backup_file, L"File_To"); | 625 backup_file = backup_file.AppendASCII("File_To"); |
612 | 626 |
613 // test Do(). | 627 // test Do(). |
614 { | 628 { |
615 scoped_ptr<CopyTreeWorkItem> work_item( | 629 scoped_ptr<CopyTreeWorkItem> work_item( |
616 WorkItem::CreateCopyTreeWorkItem(file_name_from, file_name_to, | 630 WorkItem::CreateCopyTreeWorkItem(file_name_from.ToWStringHack(), |
| 631 file_name_to.ToWStringHack(), |
617 temp_dir_.ToWStringHack(), | 632 temp_dir_.ToWStringHack(), |
618 WorkItem::IF_DIFFERENT)); | 633 WorkItem::IF_DIFFERENT)); |
619 | 634 |
620 EXPECT_TRUE(work_item->Do()); | 635 EXPECT_TRUE(work_item->Do()); |
621 | 636 |
622 EXPECT_TRUE(file_util::PathExists(file_name_from)); | 637 EXPECT_TRUE(file_util::PathExists(file_name_from)); |
623 EXPECT_TRUE(file_util::PathExists(file_name_to)); | 638 EXPECT_TRUE(file_util::PathExists(file_name_to)); |
624 EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1)); | 639 EXPECT_EQ(0, ReadTextFile(file_name_from.value()).compare(text_content_1)); |
625 EXPECT_EQ(0, ReadTextFile(file_name_to).compare(text_content_1)); | 640 EXPECT_EQ(0, ReadTextFile(file_name_to.value()).compare(text_content_1)); |
626 // verify the file in used is moved to backup place. | 641 // verify the file in used is moved to backup place. |
627 EXPECT_TRUE(file_util::PathExists(backup_file)); | 642 EXPECT_TRUE(file_util::PathExists(backup_file)); |
628 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, backup_file)); | 643 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, backup_file)); |
629 } | 644 } |
630 | 645 |
631 // verify the file in used should be still at the backup place. | 646 // verify the file in used should be still at the backup place. |
632 EXPECT_TRUE(file_util::PathExists(backup_file)); | 647 EXPECT_TRUE(file_util::PathExists(backup_file)); |
633 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, backup_file)); | 648 EXPECT_TRUE(file_util::ContentsEqual(exe_full_path, backup_file)); |
634 | 649 |
635 TerminateProcess(pi.hProcess, 0); | 650 TerminateProcess(pi.hProcess, 0); |
636 // make sure the handle is closed. | 651 // make sure the handle is closed. |
637 EXPECT_TRUE(WaitForSingleObject(pi.hProcess, 10000) == WAIT_OBJECT_0); | 652 EXPECT_TRUE(WaitForSingleObject(pi.hProcess, 10000) == WAIT_OBJECT_0); |
638 CloseHandle(pi.hProcess); | 653 CloseHandle(pi.hProcess); |
639 CloseHandle(pi.hThread); | 654 CloseHandle(pi.hThread); |
640 } | 655 } |
641 | 656 |
642 // Copy a tree from source to destination. | 657 // Copy a tree from source to destination. |
643 TEST_F(CopyTreeWorkItemTest, CopyTree) { | 658 TEST_F(CopyTreeWorkItemTest, CopyTree) { |
644 // Create source tree | 659 // Create source tree |
645 std::wstring dir_name_from(test_dir_.ToWStringHack()); | 660 FilePath dir_name_from(test_dir_); |
646 file_util::AppendToPath(&dir_name_from, L"from"); | 661 dir_name_from = dir_name_from.AppendASCII("from"); |
647 CreateDirectory(dir_name_from.c_str(), NULL); | 662 CreateDirectory(dir_name_from.value().c_str(), NULL); |
648 ASSERT_TRUE(file_util::PathExists(dir_name_from)); | 663 ASSERT_TRUE(file_util::PathExists(dir_name_from)); |
649 | 664 |
650 std::wstring dir_name_from_1(dir_name_from); | 665 FilePath dir_name_from_1(dir_name_from); |
651 file_util::AppendToPath(&dir_name_from_1, L"1"); | 666 dir_name_from_1 = dir_name_from_1.AppendASCII("1"); |
652 CreateDirectory(dir_name_from_1.c_str(), NULL); | 667 CreateDirectory(dir_name_from_1.value().c_str(), NULL); |
653 ASSERT_TRUE(file_util::PathExists(dir_name_from_1)); | 668 ASSERT_TRUE(file_util::PathExists(dir_name_from_1)); |
654 | 669 |
655 std::wstring dir_name_from_2(dir_name_from); | 670 FilePath dir_name_from_2(dir_name_from); |
656 file_util::AppendToPath(&dir_name_from_2, L"2"); | 671 dir_name_from_2 = dir_name_from_2.AppendASCII("2"); |
657 CreateDirectory(dir_name_from_2.c_str(), NULL); | 672 CreateDirectory(dir_name_from_2.value().c_str(), NULL); |
658 ASSERT_TRUE(file_util::PathExists(dir_name_from_2)); | 673 ASSERT_TRUE(file_util::PathExists(dir_name_from_2)); |
659 | 674 |
660 std::wstring file_name_from_1(dir_name_from_1); | 675 FilePath file_name_from_1(dir_name_from_1); |
661 file_util::AppendToPath(&file_name_from_1, L"File_1.txt"); | 676 file_name_from_1 = file_name_from_1.AppendASCII("File_1.txt"); |
662 CreateTextFile(file_name_from_1, text_content_1); | 677 CreateTextFile(file_name_from_1.value(), text_content_1); |
663 ASSERT_TRUE(file_util::PathExists(file_name_from_1)); | 678 ASSERT_TRUE(file_util::PathExists(file_name_from_1)); |
664 | 679 |
665 std::wstring file_name_from_2(dir_name_from_2); | 680 FilePath file_name_from_2(dir_name_from_2); |
666 file_util::AppendToPath(&file_name_from_2, L"File_2.txt"); | 681 file_name_from_2 = file_name_from_2.AppendASCII("File_2.txt"); |
667 CreateTextFile(file_name_from_2, text_content_1); | 682 CreateTextFile(file_name_from_2.value(), text_content_1); |
668 ASSERT_TRUE(file_util::PathExists(file_name_from_2)); | 683 ASSERT_TRUE(file_util::PathExists(file_name_from_2)); |
669 | 684 |
670 std::wstring dir_name_to(test_dir_.ToWStringHack()); | 685 FilePath dir_name_to(test_dir_); |
671 file_util::AppendToPath(&dir_name_to, L"to"); | 686 dir_name_to = dir_name_to.AppendASCII("to"); |
672 | 687 |
673 // test Do() | 688 // test Do() |
674 { | 689 { |
675 scoped_ptr<CopyTreeWorkItem> work_item( | 690 scoped_ptr<CopyTreeWorkItem> work_item( |
676 WorkItem::CreateCopyTreeWorkItem(dir_name_from, dir_name_to, | 691 WorkItem::CreateCopyTreeWorkItem(dir_name_from.ToWStringHack(), |
| 692 dir_name_to.ToWStringHack(), |
677 temp_dir_.ToWStringHack(), | 693 temp_dir_.ToWStringHack(), |
678 WorkItem::ALWAYS)); | 694 WorkItem::ALWAYS)); |
679 | 695 |
680 EXPECT_TRUE(work_item->Do()); | 696 EXPECT_TRUE(work_item->Do()); |
681 } | 697 } |
682 | 698 |
683 std::wstring file_name_to_1(dir_name_to); | 699 FilePath file_name_to_1(dir_name_to); |
684 file_util::AppendToPath(&file_name_to_1, L"1"); | 700 file_name_to_1 = file_name_to_1.AppendASCII("1"); |
685 file_util::AppendToPath(&file_name_to_1, L"File_1.txt"); | 701 file_name_to_1 = file_name_to_1.AppendASCII("File_1.txt"); |
686 EXPECT_TRUE(file_util::PathExists(file_name_to_1)); | 702 EXPECT_TRUE(file_util::PathExists(file_name_to_1)); |
687 LOG(INFO) << "compare " << file_name_from_1 << " and " << file_name_to_1; | 703 LOG(INFO) << "compare " |
| 704 << file_name_from_1.value() << " and " << file_name_to_1.value(); |
688 EXPECT_TRUE(file_util::ContentsEqual(file_name_from_1, file_name_to_1)); | 705 EXPECT_TRUE(file_util::ContentsEqual(file_name_from_1, file_name_to_1)); |
689 | 706 |
690 std::wstring file_name_to_2(dir_name_to); | 707 FilePath file_name_to_2(dir_name_to); |
691 file_util::AppendToPath(&file_name_to_2, L"2"); | 708 file_name_to_2 = file_name_to_2.AppendASCII("2"); |
692 file_util::AppendToPath(&file_name_to_2, L"File_2.txt"); | 709 file_name_to_2 = file_name_to_2.AppendASCII("File_2.txt"); |
693 EXPECT_TRUE(file_util::PathExists(file_name_to_2)); | 710 EXPECT_TRUE(file_util::PathExists(file_name_to_2)); |
694 LOG(INFO) << "compare " << file_name_from_2 << " and " << file_name_to_2; | 711 LOG(INFO) << "compare " |
| 712 << file_name_from_2.value() << " and " << file_name_to_2.value(); |
695 EXPECT_TRUE(file_util::ContentsEqual(file_name_from_2, file_name_to_2)); | 713 EXPECT_TRUE(file_util::ContentsEqual(file_name_from_2, file_name_to_2)); |
696 } | 714 } |
OLD | NEW |