1 use std::path::Path;
2 use std::thread;
3 use std::sync::mpsc::{self, TryRecvError};
4 use std::fs::read_dir;
5
6 extern crate fs_extra;
7 use fs_extra::*;
8 use fs_extra::error::*;
9
10
files_eq<P, Q>(file1: P, file2: Q) -> bool where P: AsRef<Path>, Q: AsRef<Path>,11 fn files_eq<P, Q>(file1: P, file2: Q) -> bool
12 where
13 P: AsRef<Path>,
14 Q: AsRef<Path>,
15 {
16 let content1 = fs_extra::file::read_to_string(file1).unwrap();
17 let content2 = fs_extra::file::read_to_string(file2).unwrap();
18 content1 == content2
19
20 }
21
22
compare_dir<P, Q>(path_from: P, path_to: Q) -> bool where P: AsRef<Path>, Q: AsRef<Path>,23 fn compare_dir<P, Q>(path_from: P, path_to: Q) -> bool
24 where
25 P: AsRef<Path>,
26 Q: AsRef<Path>,
27 {
28 let mut path_to = path_to.as_ref().to_path_buf();
29 match path_from.as_ref().components().last() {
30 None => panic!("Invalid folder from"),
31 Some(dir_name) => {
32 path_to.push(dir_name.as_os_str());
33 if !path_to.exists() {
34 return false;
35 }
36 }
37 }
38
39 for entry in read_dir(&path_from).unwrap() {
40 let entry = entry.unwrap();
41 let path = entry.path();
42 if path.is_dir() {
43 if !compare_dir(path, &path_to) {
44 return false;
45 }
46 } else {
47 let mut path_to = path_to.to_path_buf();
48 match path.file_name() {
49 None => panic!("No file name"),
50 Some(file_name) => {
51 path_to.push(file_name);
52 if !path_to.exists() {
53 return false;
54 } else if !files_eq(&path, path_to.clone()) {
55 return false;
56 }
57 }
58 }
59 }
60 }
61
62 true
63 }
64
65
66 const TEST_FOLDER: &'static str = "./tests/temp/lib";
67
68 #[test]
it_copy_work()69 fn it_copy_work() {
70
71 let test_dir = Path::new(TEST_FOLDER).join("it_copy_work");
72 let path_to = test_dir.join("out");
73 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
74 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
75 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
76 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
77 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
78 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
79 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
80 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
81
82 match dir::create_all(&path_to, true) {
83 Ok(_) => {}
84 Err(_) => {}
85 };
86 dir::create_all(&dir1.0, true).unwrap();
87 dir::create_all(&dir2.0, true).unwrap();
88 dir::create_all(&sub.0, true).unwrap();
89
90 assert!(dir1.0.exists());
91 assert!(!dir1.1.exists());
92 assert!(dir2.0.exists());
93 assert!(!dir2.1.exists());
94 assert!(sub.0.exists());
95 assert!(!sub.1.exists());
96
97 file::write_all(&file1.0, "content1").unwrap();
98 file::write_all(&file2.0, "content2").unwrap();
99 file::write_all(&file3.0, "content3").unwrap();
100 file::write_all(&file4.0, "content4").unwrap();
101 file::write_all(&file5.0, "content5").unwrap();
102
103 assert!(file1.0.exists());
104 assert!(file2.0.exists());
105 assert!(file3.0.exists());
106 assert!(file4.0.exists());
107 assert!(file5.0.exists());
108 assert!(!file1.1.exists());
109 assert!(!file2.1.exists());
110 assert!(!file3.1.exists());
111 assert!(!file4.1.exists());
112 assert!(!file5.1.exists());
113
114
115
116 let mut from_paths = Vec::new();
117 from_paths.push(dir1.0.as_path());
118 from_paths.push(dir2.0.as_path());
119 from_paths.push(file1.0.as_path());
120 from_paths.push(file2.0.as_path());
121
122 let options = dir::CopyOptions::new();
123 let result = copy_items(&from_paths, &path_to, &options).unwrap();
124
125 assert_eq!(40, result);
126 assert!(compare_dir(&dir1.0, &path_to));
127 assert!(compare_dir(&dir2.0, &path_to));
128 assert!(files_eq(&file1.0, &file1.1));
129 assert!(files_eq(&file2.0, &file2.1));
130
131 }
132
133
134 #[test]
it_copy_source_not_exist()135 fn it_copy_source_not_exist() {
136 let test_dir = Path::new(TEST_FOLDER).join("it_copy_source_not_exist");
137 let path_to = test_dir.join("out");
138 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
139 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
140 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
141 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
142
143 match dir::create_all(&path_to, true) {
144 Ok(_) => {}
145 Err(_) => {}
146 };
147
148 assert!(!dir1.0.exists());
149 assert!(!dir1.1.exists());
150 assert!(!dir2.0.exists());
151 assert!(!dir2.1.exists());
152 assert!(!sub.0.exists());
153 assert!(!sub.1.exists());
154
155
156 assert!(!file1.0.exists());
157 assert!(!file1.1.exists());
158
159
160 let mut from_paths = Vec::new();
161 from_paths.push(dir1.0.as_path());
162 from_paths.push(dir2.0.as_path());
163 from_paths.push(file1.0.as_path());
164
165 let options = dir::CopyOptions::new();
166 match copy_items(&from_paths, &path_to, &options) {
167 Ok(_) => panic!("Should be a error!"),
168 Err(err) => {
169 match err.kind {
170 ErrorKind::NotFound => {}
171 _ => {}
172 }
173 }
174 };
175 }
176
177
178 #[test]
it_copy_exist_overwrite()179 fn it_copy_exist_overwrite() {
180
181 let test_dir = Path::new(TEST_FOLDER).join("it_copy_exist_overwrite");
182 let path_to = test_dir.join("out");
183 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
184 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
185 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
186 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
187 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
188 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
189 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
190 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
191
192 match dir::create_all(&path_to, true) {
193 Ok(_) => {}
194 Err(_) => {}
195 };
196
197 dir::create_all(&dir1.0, true).unwrap();
198 dir::create_all(&dir2.0, true).unwrap();
199 dir::create_all(&sub.0, true).unwrap();
200 dir::create_all(&sub.1, true).unwrap();
201
202
203 assert!(dir1.0.exists());
204 assert!(dir1.1.exists());
205 assert!(dir2.0.exists());
206 assert!(!dir2.1.exists());
207 assert!(sub.0.exists());
208 assert!(sub.1.exists());
209
210 file::write_all(&file1.0, "content1").unwrap();
211 file::write_all(&file2.0, "content2").unwrap();
212 file::write_all(&file3.0, "content3").unwrap();
213 file::write_all(&file4.0, "content4").unwrap();
214 file::write_all(&file5.0, "content5").unwrap();
215
216 file::write_all(&file1.1, "old content1").unwrap();
217 file::write_all(&file3.1, "old content3").unwrap();
218 file::write_all(&file4.1, "old content4").unwrap();
219
220 assert!(file1.0.exists());
221 assert!(file2.0.exists());
222 assert!(file3.0.exists());
223 assert!(file4.0.exists());
224 assert!(file5.0.exists());
225 assert!(file1.1.exists());
226 assert!(!file2.1.exists());
227 assert!(file3.1.exists());
228 assert!(file4.1.exists());
229 assert!(!file5.1.exists());
230
231
232 let mut from_paths = Vec::new();
233 from_paths.push(dir1.0.as_path());
234 from_paths.push(dir2.0.as_path());
235 from_paths.push(file1.0.as_path());
236 from_paths.push(file2.0.as_path());
237
238 let mut options = dir::CopyOptions::new();
239 options.overwrite = true;
240 let result = copy_items(&from_paths, &path_to, &options).unwrap();
241
242 assert_eq!(40, result);
243 assert!(compare_dir(&dir1.0, &path_to));
244 assert!(compare_dir(&dir2.0, &path_to));
245 assert!(files_eq(&file1.0, &file1.1));
246 assert!(files_eq(&file2.0, &file2.1));
247
248 }
249
250 #[test]
it_copy_exist_not_overwrite()251 fn it_copy_exist_not_overwrite() {
252
253 let test_dir = Path::new(TEST_FOLDER).join("it_copy_exist_not_overwrite");
254 let path_to = test_dir.join("out");
255 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
256 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
257 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
258 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
259 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
260 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
261 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
262 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
263
264 match dir::create_all(&path_to, true) {
265 Ok(_) => {}
266 Err(_) => {}
267 };
268
269 dir::create_all(&dir1.0, true).unwrap();
270 dir::create_all(&dir2.0, true).unwrap();
271 dir::create_all(&sub.0, true).unwrap();
272 dir::create_all(&sub.1, true).unwrap();
273
274
275 assert!(dir1.0.exists());
276 assert!(dir1.1.exists());
277 assert!(dir2.0.exists());
278 assert!(!dir2.1.exists());
279 assert!(sub.0.exists());
280 assert!(sub.1.exists());
281
282 file::write_all(&file1.0, "content1").unwrap();
283 file::write_all(&file2.0, "content2").unwrap();
284 file::write_all(&file3.0, "content3").unwrap();
285 file::write_all(&file4.0, "content4").unwrap();
286 file::write_all(&file5.0, "content5").unwrap();
287
288 file::write_all(&file1.1, "old content1").unwrap();
289 file::write_all(&file3.1, "old content3").unwrap();
290 file::write_all(&file4.1, "old content4").unwrap();
291
292 assert!(file1.0.exists());
293 assert!(file2.0.exists());
294 assert!(file3.0.exists());
295 assert!(file4.0.exists());
296 assert!(file5.0.exists());
297 assert!(file1.1.exists());
298 assert!(!file2.1.exists());
299 assert!(file3.1.exists());
300 assert!(file4.1.exists());
301 assert!(!file5.1.exists());
302
303
304 let mut from_paths = Vec::new();
305 from_paths.push(dir1.0.as_path());
306 from_paths.push(dir2.0.as_path());
307 from_paths.push(file1.0.as_path());
308 from_paths.push(file2.0.as_path());
309
310 let options = dir::CopyOptions::new();
311 match copy_items(&from_paths, &path_to, &options) {
312 Ok(_) => panic!("Should be a error!"),
313 Err(err) => {
314 match err.kind {
315 ErrorKind::AlreadyExists => {}
316 _ => panic!(format!("{}", err.to_string())),
317 }
318 }
319 };
320
321
322 }
323
324
325 #[test]
it_copy_exist_skip()326 fn it_copy_exist_skip() {
327
328 let test_dir = Path::new(TEST_FOLDER).join("it_copy_exist_skip");
329 let path_to = test_dir.join("out");
330 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
331 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
332 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
333 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
334 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
335 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
336 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
337 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
338
339 match dir::create_all(&path_to, true) {
340 Ok(_) => {}
341 Err(_) => {}
342 };
343
344 dir::create_all(&dir1.0, true).unwrap();
345 dir::create_all(&dir2.0, true).unwrap();
346 dir::create_all(&sub.0, true).unwrap();
347 dir::create_all(&sub.1, true).unwrap();
348
349
350 assert!(dir1.0.exists());
351 assert!(dir1.1.exists());
352 assert!(dir2.0.exists());
353 assert!(!dir2.1.exists());
354 assert!(sub.0.exists());
355 assert!(sub.1.exists());
356
357 file::write_all(&file1.0, "content1").unwrap();
358 file::write_all(&file2.0, "content2").unwrap();
359 file::write_all(&file3.0, "content3").unwrap();
360 file::write_all(&file4.0, "content4").unwrap();
361 file::write_all(&file5.0, "content5").unwrap();
362
363 file::write_all(&file1.1, "old content1").unwrap();
364 file::write_all(&file3.1, "old content3").unwrap();
365 file::write_all(&file4.1, "old content4").unwrap();
366
367 assert!(file1.0.exists());
368 assert!(file2.0.exists());
369 assert!(file3.0.exists());
370 assert!(file4.0.exists());
371 assert!(file5.0.exists());
372 assert!(file1.1.exists());
373 assert!(!file2.1.exists());
374 assert!(file3.1.exists());
375 assert!(file4.1.exists());
376 assert!(!file5.1.exists());
377
378
379 let mut from_paths = Vec::new();
380 from_paths.push(dir1.0.as_path());
381 from_paths.push(dir2.0.as_path());
382 from_paths.push(file1.0.as_path());
383 from_paths.push(file2.0.as_path());
384
385 let mut options = dir::CopyOptions::new();
386 options.skip_exist = true;
387 let result = copy_items(&from_paths, &path_to, &options).unwrap();
388
389 assert_eq!(16, result);
390 assert!(!compare_dir(&dir1.0, &path_to));
391 assert!(compare_dir(&dir2.0, &path_to));
392 assert!(!files_eq(&file1.0, &file1.1));
393 assert!(files_eq(&file2.0, &file2.1));
394
395 }
396
397 #[test]
it_copy_exist_overwrite_and_skip_exist()398 fn it_copy_exist_overwrite_and_skip_exist() {
399
400 let test_dir = Path::new(TEST_FOLDER).join("it_copy_exist_overwrite_and_skip_exist");
401 let path_to = test_dir.join("out");
402 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
403 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
404 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
405 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
406 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
407 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
408 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
409 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
410
411 match dir::create_all(&path_to, true) {
412 Ok(_) => {}
413 Err(_) => {}
414 };
415
416 dir::create_all(&dir1.0, true).unwrap();
417 dir::create_all(&dir2.0, true).unwrap();
418 dir::create_all(&sub.0, true).unwrap();
419 dir::create_all(&sub.1, true).unwrap();
420
421
422 assert!(dir1.0.exists());
423 assert!(dir1.1.exists());
424 assert!(dir2.0.exists());
425 assert!(!dir2.1.exists());
426 assert!(sub.0.exists());
427 assert!(sub.1.exists());
428
429 file::write_all(&file1.0, "content1").unwrap();
430 file::write_all(&file2.0, "content2").unwrap();
431 file::write_all(&file3.0, "content3").unwrap();
432 file::write_all(&file4.0, "content4").unwrap();
433 file::write_all(&file5.0, "content5").unwrap();
434
435 file::write_all(&file1.1, "old content1").unwrap();
436 file::write_all(&file3.1, "old content3").unwrap();
437 file::write_all(&file4.1, "old content4").unwrap();
438
439 assert!(file1.0.exists());
440 assert!(file2.0.exists());
441 assert!(file3.0.exists());
442 assert!(file4.0.exists());
443 assert!(file5.0.exists());
444 assert!(file1.1.exists());
445 assert!(!file2.1.exists());
446 assert!(file3.1.exists());
447 assert!(file4.1.exists());
448 assert!(!file5.1.exists());
449
450
451 let mut from_paths = Vec::new();
452 from_paths.push(dir1.0.as_path());
453 from_paths.push(dir2.0.as_path());
454 from_paths.push(file1.0.as_path());
455 from_paths.push(file2.0.as_path());
456
457 let mut options = dir::CopyOptions::new();
458 options.overwrite = true;
459 options.skip_exist = true;
460 let result = copy_items(&from_paths, &path_to, &options).unwrap();
461
462 assert_eq!(40, result);
463 assert!(compare_dir(&dir1.0, &path_to));
464 assert!(compare_dir(&dir2.0, &path_to));
465 assert!(files_eq(&file1.0, &file1.1));
466 assert!(files_eq(&file2.0, &file2.1));
467
468 }
469
470 #[test]
it_copy_using_first_levels()471 fn it_copy_using_first_levels() {
472
473 let test_dir = Path::new(TEST_FOLDER).join("it_copy_using_first_levels");
474 let path_to = test_dir.join("out");
475 let d_level_1 = (test_dir.join("d_level_1"), path_to.join("d_level_1"));
476 let d_level_2 = (d_level_1.0.join("d_level_2"), d_level_1.1.join("d_level_2"));
477 let d_level_3 = (d_level_2.0.join("d_level_3"), d_level_2.1.join("d_level_3"));
478 let d_level_4 = (d_level_3.0.join("d_level_4"), d_level_3.1.join("d_level_4"));
479 let d_level_5 = (d_level_4.0.join("d_level_5"), d_level_4.1.join("d_level_5"));
480
481 let d2_level_1 = (test_dir.join("d2_level_1"), path_to.join("d2_level_1"));
482 let d2_level_2 = (d_level_1.0.join("d2_level_2"), d_level_1.1.join("d2_level_2"));
483 let d2_level_3 = (d_level_2.0.join("d2_level_3"), d_level_2.1.join("d2_level_3"));
484 let d2_level_4 = (d_level_3.0.join("d2_level_4"), d_level_3.1.join("d2_level_4"));
485 let d2_level_5 = (d_level_4.0.join("d2_level_5"), d_level_4.1.join("d2_level_5"));
486
487 let d3_level_1 = (test_dir.join("d3_level_1"), path_to.join("d3_level_1"));
488
489 let file1 = (d_level_1.0.join("file1.txt"),d_level_1.1.join("file1.txt"));
490 let file2 = (d_level_2.0.join("file2.txt"),d_level_2.1.join("file2.txt"));
491 let file3 = (d_level_3.0.join("file3.txt"),d_level_3.1.join("file3.txt"));
492 let file4 = (d_level_4.0.join("file4.txt"),d_level_4.1.join("file4.txt"));
493 let file5 = (d_level_5.0.join("file5.txt"),d_level_5.1.join("file5.txt"));
494
495 let file21 = (d2_level_1.0.join("file21.txt"),d2_level_1.1.join("file21.txt"));
496 let file22 = (d2_level_2.0.join("file22.txt"),d2_level_2.1.join("file22.txt"));
497 let file23 = (d2_level_3.0.join("file23.txt"),d2_level_3.1.join("file23.txt"));
498 let file24 = (d2_level_4.0.join("file24.txt"),d2_level_4.1.join("file24.txt"));
499 let file25 = (d2_level_5.0.join("file25.txt"),d2_level_5.1.join("file25.txt"));
500
501 let file31 = (d3_level_1.0.join("file31.txt"),d3_level_1.1.join("file31.txt"));
502
503 dir::create_all(&d_level_1.0, true).unwrap();
504 dir::create_all(&d_level_2.0, true).unwrap();
505 dir::create_all(&d_level_3.0, true).unwrap();
506 dir::create_all(&d_level_4.0, true).unwrap();
507 dir::create_all(&d_level_5.0, true).unwrap();
508 dir::create_all(&path_to, true).unwrap();
509
510 dir::create_all(&d2_level_1.0, true).unwrap();
511 dir::create_all(&d2_level_2.0, true).unwrap();
512 dir::create_all(&d2_level_3.0, true).unwrap();
513 dir::create_all(&d2_level_4.0, true).unwrap();
514 dir::create_all(&d2_level_5.0, true).unwrap();
515
516 dir::create_all(&d3_level_1.0, true).unwrap();
517
518 assert!(path_to.exists());
519 assert!(d_level_1.0.exists());
520 assert!(d_level_2.0.exists());
521 assert!(d_level_3.0.exists());
522 assert!(d_level_4.0.exists());
523 assert!(d_level_5.0.exists());
524
525 assert!(d2_level_1.0.exists());
526 assert!(d2_level_2.0.exists());
527 assert!(d2_level_3.0.exists());
528 assert!(d2_level_4.0.exists());
529 assert!(d2_level_5.0.exists());
530
531 assert!(d3_level_1.0.exists());
532
533 assert!(!d_level_1.1.exists());
534 assert!(!d_level_2.1.exists());
535 assert!(!d_level_3.1.exists());
536 assert!(!d_level_4.1.exists());
537 assert!(!d_level_5.1.exists());
538
539 assert!(!d2_level_1.1.exists());
540 assert!(!d2_level_2.1.exists());
541 assert!(!d2_level_3.1.exists());
542 assert!(!d2_level_4.1.exists());
543 assert!(!d2_level_5.1.exists());
544
545 assert!(!d3_level_1.1.exists());
546
547 fs_extra::file::write_all(&file1.0, "content1").unwrap();
548 fs_extra::file::write_all(&file2.0, "content2").unwrap();
549 fs_extra::file::write_all(&file3.0, "content3").unwrap();
550 fs_extra::file::write_all(&file4.0, "content4").unwrap();
551 fs_extra::file::write_all(&file5.0, "content5").unwrap();
552
553 fs_extra::file::write_all(&file21.0, "2content1").unwrap();
554 fs_extra::file::write_all(&file22.0, "2content2").unwrap();
555 fs_extra::file::write_all(&file23.0, "2content3").unwrap();
556 fs_extra::file::write_all(&file24.0, "2content4").unwrap();
557 fs_extra::file::write_all(&file25.0, "2content5").unwrap();
558
559 fs_extra::file::write_all(&file31.0, "3content1").unwrap();
560
561 assert!(file1.0.exists());
562 assert!(file2.0.exists());
563 assert!(file3.0.exists());
564 assert!(file4.0.exists());
565 assert!(file5.0.exists());
566
567 assert!(file21.0.exists());
568 assert!(file22.0.exists());
569 assert!(file23.0.exists());
570 assert!(file24.0.exists());
571 assert!(file25.0.exists());
572
573 assert!(file31.0.exists());
574
575 assert!(!file1.1.exists());
576 assert!(!file2.1.exists());
577 assert!(!file3.1.exists());
578 assert!(!file4.1.exists());
579 assert!(!file5.1.exists());
580
581 assert!(!file21.1.exists());
582 assert!(!file22.1.exists());
583 assert!(!file23.1.exists());
584 assert!(!file24.1.exists());
585 assert!(!file25.1.exists());
586
587 assert!(!file31.1.exists());
588
589
590 let mut from_paths = Vec::new();
591 from_paths.push(d_level_1.0.as_path());
592 from_paths.push(d2_level_1.0.as_path());
593 from_paths.push(d3_level_1.0.as_path());
594
595 let mut options = dir::CopyOptions::new();
596 options.depth = 1;
597 let result = copy_items(&from_paths, path_to, &options).unwrap();
598
599 assert_eq!(26, result);
600
601 assert!(file1.0.exists());
602 assert!(file2.0.exists());
603 assert!(file3.0.exists());
604 assert!(file4.0.exists());
605 assert!(file5.0.exists());
606
607 assert!(file21.0.exists());
608 assert!(file22.0.exists());
609 assert!(file23.0.exists());
610 assert!(file24.0.exists());
611 assert!(file25.0.exists());
612
613 assert!(file31.0.exists());
614
615 assert!(file1.1.exists());
616 assert!(!file2.1.exists());
617 assert!(!file3.1.exists());
618 assert!(!file4.1.exists());
619 assert!(!file5.1.exists());
620
621 assert!(file21.1.exists());
622 assert!(!file22.1.exists());
623 assert!(!file23.1.exists());
624 assert!(!file24.1.exists());
625 assert!(!file25.1.exists());
626
627 assert!(file31.1.exists());
628 assert!(files_eq(&file1.0, &file1.1));
629 assert!(files_eq(&file21.0, &file21.1));
630 assert!(files_eq(&file31.0, &file31.1));
631 }
632
633
634 #[test]
it_copy_using_four_levels()635 fn it_copy_using_four_levels() {
636
637 let test_dir = Path::new(TEST_FOLDER).join("it_copy_using_four_levels");
638 let path_to = test_dir.join("out");
639 let d_level_1 = (test_dir.join("d_level_1"), path_to.join("d_level_1"));
640 let d_level_2 = (d_level_1.0.join("d_level_2"), d_level_1.1.join("d_level_2"));
641 let d_level_3 = (d_level_2.0.join("d_level_3"), d_level_2.1.join("d_level_3"));
642 let d_level_4 = (d_level_3.0.join("d_level_4"), d_level_3.1.join("d_level_4"));
643 let d_level_5 = (d_level_4.0.join("d_level_5"), d_level_4.1.join("d_level_5"));
644
645 let d2_level_1 = (test_dir.join("d2_level_1"), path_to.join("d2_level_1"));
646 let d2_level_2 = (d_level_1.0.join("d2_level_2"), d_level_1.1.join("d2_level_2"));
647 let d2_level_3 = (d_level_2.0.join("d2_level_3"), d_level_2.1.join("d2_level_3"));
648 let d2_level_4 = (d_level_3.0.join("d2_level_4"), d_level_3.1.join("d2_level_4"));
649 let d2_level_5 = (d_level_4.0.join("d2_level_5"), d_level_4.1.join("d2_level_5"));
650
651 let d3_level_1 = (test_dir.join("d3_level_1"), path_to.join("d3_level_1"));
652
653 let file1 = (d_level_1.0.join("file1.txt"),d_level_1.1.join("file1.txt"));
654 let file2 = (d_level_2.0.join("file2.txt"),d_level_2.1.join("file2.txt"));
655 let file3 = (d_level_3.0.join("file3.txt"),d_level_3.1.join("file3.txt"));
656 let file4 = (d_level_4.0.join("file4.txt"),d_level_4.1.join("file4.txt"));
657 let file5 = (d_level_5.0.join("file5.txt"),d_level_5.1.join("file5.txt"));
658
659 let file21 = (d2_level_1.0.join("file21.txt"),d2_level_1.1.join("file21.txt"));
660 let file22 = (d2_level_2.0.join("file22.txt"),d2_level_2.1.join("file22.txt"));
661 let file23 = (d2_level_3.0.join("file23.txt"),d2_level_3.1.join("file23.txt"));
662 let file24 = (d2_level_4.0.join("file24.txt"),d2_level_4.1.join("file24.txt"));
663 let file25 = (d2_level_5.0.join("file25.txt"),d2_level_5.1.join("file25.txt"));
664
665 let file31 = (d3_level_1.0.join("file31.txt"),d3_level_1.1.join("file31.txt"));
666
667 dir::create_all(&d_level_1.0, true).unwrap();
668 dir::create_all(&d_level_2.0, true).unwrap();
669 dir::create_all(&d_level_3.0, true).unwrap();
670 dir::create_all(&d_level_4.0, true).unwrap();
671 dir::create_all(&d_level_5.0, true).unwrap();
672 dir::create_all(&path_to, true).unwrap();
673
674 dir::create_all(&d2_level_1.0, true).unwrap();
675 dir::create_all(&d2_level_2.0, true).unwrap();
676 dir::create_all(&d2_level_3.0, true).unwrap();
677 dir::create_all(&d2_level_4.0, true).unwrap();
678 dir::create_all(&d2_level_5.0, true).unwrap();
679
680 dir::create_all(&d3_level_1.0, true).unwrap();
681
682 assert!(path_to.exists());
683 assert!(d_level_1.0.exists());
684 assert!(d_level_2.0.exists());
685 assert!(d_level_3.0.exists());
686 assert!(d_level_4.0.exists());
687 assert!(d_level_5.0.exists());
688
689 assert!(d2_level_1.0.exists());
690 assert!(d2_level_2.0.exists());
691 assert!(d2_level_3.0.exists());
692 assert!(d2_level_4.0.exists());
693 assert!(d2_level_5.0.exists());
694
695 assert!(d3_level_1.0.exists());
696
697 assert!(!d_level_1.1.exists());
698 assert!(!d_level_2.1.exists());
699 assert!(!d_level_3.1.exists());
700 assert!(!d_level_4.1.exists());
701 assert!(!d_level_5.1.exists());
702
703 assert!(!d2_level_1.1.exists());
704 assert!(!d2_level_2.1.exists());
705 assert!(!d2_level_3.1.exists());
706 assert!(!d2_level_4.1.exists());
707 assert!(!d2_level_5.1.exists());
708
709 assert!(!d3_level_1.1.exists());
710
711 fs_extra::file::write_all(&file1.0, "content1").unwrap();
712 fs_extra::file::write_all(&file2.0, "content2").unwrap();
713 fs_extra::file::write_all(&file3.0, "content3").unwrap();
714 fs_extra::file::write_all(&file4.0, "content4").unwrap();
715 fs_extra::file::write_all(&file5.0, "content5").unwrap();
716
717 fs_extra::file::write_all(&file21.0, "2content1").unwrap();
718 fs_extra::file::write_all(&file22.0, "2content2").unwrap();
719 fs_extra::file::write_all(&file23.0, "2content3").unwrap();
720 fs_extra::file::write_all(&file24.0, "2content4").unwrap();
721 fs_extra::file::write_all(&file25.0, "2content5").unwrap();
722
723 fs_extra::file::write_all(&file31.0, "3content1").unwrap();
724
725 assert!(file1.0.exists());
726 assert!(file2.0.exists());
727 assert!(file3.0.exists());
728 assert!(file4.0.exists());
729 assert!(file5.0.exists());
730
731 assert!(file21.0.exists());
732 assert!(file22.0.exists());
733 assert!(file23.0.exists());
734 assert!(file24.0.exists());
735 assert!(file25.0.exists());
736
737 assert!(file31.0.exists());
738
739 assert!(!file1.1.exists());
740 assert!(!file2.1.exists());
741 assert!(!file3.1.exists());
742 assert!(!file4.1.exists());
743 assert!(!file5.1.exists());
744
745 assert!(!file21.1.exists());
746 assert!(!file22.1.exists());
747 assert!(!file23.1.exists());
748 assert!(!file24.1.exists());
749 assert!(!file25.1.exists());
750
751 assert!(!file31.1.exists());
752
753
754 let mut from_paths = Vec::new();
755 from_paths.push(d_level_1.0.as_path());
756 from_paths.push(d2_level_1.0.as_path());
757 from_paths.push(d3_level_1.0.as_path());
758
759 let mut options = dir::CopyOptions::new();
760 options.depth = 4;
761 let result = copy_items(&from_paths, path_to, &options).unwrap();
762
763 assert_eq!(77, result);
764
765 assert!(file1.0.exists());
766 assert!(file2.0.exists());
767 assert!(file3.0.exists());
768 assert!(file4.0.exists());
769 assert!(file5.0.exists());
770
771 assert!(file21.0.exists());
772 assert!(file22.0.exists());
773 assert!(file23.0.exists());
774 assert!(file24.0.exists());
775 assert!(file25.0.exists());
776
777 assert!(file31.0.exists());
778
779 assert!(file1.1.exists());
780 assert!(file2.1.exists());
781 assert!(file3.1.exists());
782 assert!(file4.1.exists());
783 assert!(!file5.1.exists());
784
785 assert!(file21.1.exists());
786 assert!(file22.1.exists());
787 assert!(file23.1.exists());
788 assert!(file24.1.exists());
789 assert!(!file25.1.exists());
790
791 assert!(file31.1.exists());
792 assert!(files_eq(&file1.0, &file1.1));
793 assert!(files_eq(&file21.0, &file21.1));
794 assert!(files_eq(&file31.0, &file31.1));
795 }
796
797
798 #[test]
it_copy_progress_work()799 fn it_copy_progress_work() {
800
801 let test_dir = Path::new(TEST_FOLDER).join("it_copy_progress_work");
802 let path_to = test_dir.join("out");
803 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
804 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
805 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
806 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
807 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
808 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
809 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
810 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
811
812 match dir::create_all(&path_to, true) {
813 Ok(_) => {}
814 Err(_) => {}
815 };
816 dir::create_all(&dir1.0, true).unwrap();
817 dir::create_all(&dir2.0, true).unwrap();
818 dir::create_all(&sub.0, true).unwrap();
819
820 assert!(dir1.0.exists());
821 assert!(!dir1.1.exists());
822 assert!(dir2.0.exists());
823 assert!(!dir2.1.exists());
824 assert!(sub.0.exists());
825 assert!(!sub.1.exists());
826
827 file::write_all(&file1.0, "content1").unwrap();
828 file::write_all(&file2.0, "content22").unwrap();
829 file::write_all(&file3.0, "content3").unwrap();
830 file::write_all(&file4.0, "content4").unwrap();
831 file::write_all(&file5.0, "content5").unwrap();
832
833 assert!(file1.0.exists());
834 assert!(file2.0.exists());
835 assert!(file3.0.exists());
836 assert!(file4.0.exists());
837 assert!(file5.0.exists());
838 assert!(!file1.1.exists());
839 assert!(!file2.1.exists());
840 assert!(!file3.1.exists());
841 assert!(!file4.1.exists());
842 assert!(!file5.1.exists());
843
844
845 let options = dir::CopyOptions::new();
846 let (tx, rx) = mpsc::channel();
847 let result = thread::spawn(move || {
848 let mut from_paths = Vec::new();
849 from_paths.push(dir1.0.as_path());
850 from_paths.push(dir2.0.as_path());
851 from_paths.push(file1.0.as_path());
852 from_paths.push(file2.0.as_path());
853
854 let func_test = |process_info: TransitProcess| {
855 tx.send(process_info).unwrap();
856 dir::TransitProcessResult::ContinueOrAbort
857 };
858 let result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
859
860 assert_eq!(41, result);
861 assert!(compare_dir(&dir1.0, &path_to));
862 assert!(compare_dir(&dir2.0, &path_to));
863 assert!(files_eq(&file1.0, &file1.1));
864 assert!(files_eq(&file2.0, &file2.1));
865
866 }).join();
867
868 loop {
869 match rx.try_recv() {
870 Ok(process_info) => {
871 if process_info.file_name == "file2.txt" {
872 assert_eq!(9, process_info.file_total_bytes);
873 assert_eq!(41, process_info.total_bytes);
874 } else if process_info.file_name == "file1.txt" {
875 assert_eq!(8, process_info.file_total_bytes);
876 assert_eq!(41, process_info.total_bytes);
877 }
878 }
879 Err(TryRecvError::Disconnected) => {
880 break;
881 }
882 Err(TryRecvError::Empty) => {}
883 }
884 }
885
886 match result {
887 Ok(_) => {}
888 Err(err) => panic!(err),
889 }
890
891 }
892
893 #[test]
it_copy_with_progress_work_dif_buf_size()894 fn it_copy_with_progress_work_dif_buf_size() {
895
896 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_work_dif_buf_size");
897 let path_to = test_dir.join("out");
898 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
899 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
900 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
901 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
902 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
903 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
904 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
905 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
906
907 match dir::create_all(&path_to, true) {
908 Ok(_) => {}
909 Err(_) => {}
910 };
911 dir::create_all(&dir1.0, true).unwrap();
912 dir::create_all(&dir2.0, true).unwrap();
913 dir::create_all(&sub.0, true).unwrap();
914
915 assert!(dir1.0.exists());
916 assert!(!dir1.1.exists());
917 assert!(dir2.0.exists());
918 assert!(!dir2.1.exists());
919 assert!(sub.0.exists());
920 assert!(!sub.1.exists());
921
922 file::write_all(&file1.0, "content1").unwrap();
923 file::write_all(&file2.0, "content2").unwrap();
924 file::write_all(&file3.0, "content3").unwrap();
925 file::write_all(&file4.0, "content4").unwrap();
926 file::write_all(&file5.0, "content5").unwrap();
927
928 assert!(file1.0.exists());
929 assert!(file2.0.exists());
930 assert!(file3.0.exists());
931 assert!(file4.0.exists());
932 assert!(file5.0.exists());
933 assert!(!file1.1.exists());
934 assert!(!file2.1.exists());
935 assert!(!file3.1.exists());
936 assert!(!file4.1.exists());
937 assert!(!file5.1.exists());
938
939
940 let mut options = dir::CopyOptions::new();
941 options.buffer_size = 1;
942 let (tx, rx) = mpsc::channel();
943 let result = thread::spawn(move || {
944 let mut from_paths = Vec::new();
945 from_paths.push(file1.0.as_path().to_str().unwrap().to_string());
946 from_paths.push(file2.0.as_path().to_str().unwrap().to_string());
947 from_paths.push(dir1.0.as_path().to_str().unwrap().to_string());
948 from_paths.push(dir2.0.as_path().to_str().unwrap().to_string());
949
950 let func_test = |process_info: TransitProcess| {
951 tx.send(process_info).unwrap();
952 dir::TransitProcessResult::ContinueOrAbort
953 };
954
955 let result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
956
957 assert_eq!(40, result);
958 assert!(compare_dir(&dir1.0, &path_to));
959 assert!(compare_dir(&dir2.0, &path_to));
960 assert!(files_eq(&file1.0, &file1.1));
961 assert!(files_eq(&file2.0, &file2.1));
962
963 let mut options = dir::CopyOptions::new();
964 options.buffer_size = 2;
965 options.overwrite = true;
966 let (tx, rx) = mpsc::channel();
967 let result = thread::spawn(move || {
968
969 let func_test = |process_info: TransitProcess| {
970 tx.send(process_info).unwrap();
971 dir::TransitProcessResult::ContinueOrAbort
972 };
973 let result = copy_items_with_progress(&from_paths, &path_to, &options, func_test)
974 .unwrap();
975
976 assert_eq!(40, result);
977 assert!(compare_dir(&dir1.0, &path_to));
978 assert!(compare_dir(&dir2.0, &path_to));
979 assert!(files_eq(&file1.0, &file1.1));
980 assert!(files_eq(&file2.0, &file2.1));
981 }).join();
982 for i in 1..5 {
983 let process_info: TransitProcess = rx.recv().unwrap();
984 assert_eq!(i * 2, process_info.file_bytes_copied);
985 assert_eq!(i * 2, process_info.copied_bytes);
986 assert_eq!(8, process_info.file_total_bytes);
987 assert_eq!(40, process_info.total_bytes);
988 }
989 for i in 1..5 {
990 let process_info: TransitProcess = rx.recv().unwrap();
991 assert_eq!(i * 2 + 8, process_info.copied_bytes);
992 assert_eq!(i * 2, process_info.file_bytes_copied);
993 assert_eq!(8, process_info.file_total_bytes);
994 assert_eq!(40, process_info.total_bytes);
995 }
996
997 match result {
998 Ok(_) => {}
999 Err(err) => panic!(err),
1000 }
1001
1002 }).join();
1003
1004 for i in 1..9 {
1005 let process_info: TransitProcess = rx.recv().unwrap();
1006 assert_eq!(i, process_info.file_bytes_copied);
1007 assert_eq!(i, process_info.copied_bytes);
1008 assert_eq!(8, process_info.file_total_bytes);
1009 assert_eq!(40, process_info.total_bytes);
1010 }
1011 for i in 1..9 {
1012 let process_info: TransitProcess = rx.recv().unwrap();
1013 assert_eq!(i + 8, process_info.copied_bytes);
1014 assert_eq!(i, process_info.file_bytes_copied);
1015 assert_eq!(8, process_info.file_total_bytes);
1016 assert_eq!(40, process_info.total_bytes);
1017 }
1018
1019 match result {
1020 Ok(_) => {}
1021 Err(err) => panic!(err),
1022 }
1023
1024
1025 }
1026
1027
1028
1029 #[test]
it_copy_with_progress_source_not_exist()1030 fn it_copy_with_progress_source_not_exist() {
1031 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_source_not_exist");
1032 let path_to = test_dir.join("out");
1033 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
1034 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
1035 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
1036 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
1037
1038 match dir::create_all(&path_to, true) {
1039 Ok(_) => {}
1040 Err(_) => {}
1041 };
1042
1043 assert!(!dir1.0.exists());
1044 assert!(!dir1.1.exists());
1045 assert!(!dir2.0.exists());
1046 assert!(!dir2.1.exists());
1047 assert!(!sub.0.exists());
1048 assert!(!sub.1.exists());
1049
1050
1051 assert!(!file1.0.exists());
1052 assert!(!file1.1.exists());
1053
1054
1055 let mut from_paths = Vec::new();
1056 from_paths.push(dir1.0.as_path());
1057 from_paths.push(dir2.0.as_path());
1058 from_paths.push(file1.0.as_path());
1059
1060
1061 let func_test = |process_info: TransitProcess| {
1062 println!("{}", process_info.total_bytes);
1063 dir::TransitProcessResult::ContinueOrAbort
1064 };
1065
1066
1067 let options = dir::CopyOptions::new();
1068 match copy_items_with_progress(&from_paths, &path_to, &options, func_test) {
1069 Ok(_) => panic!("Should be a error!"),
1070 Err(err) => {
1071 match err.kind {
1072 ErrorKind::NotFound => {}
1073 _ => {}
1074 }
1075 }
1076 };
1077 }
1078
1079
1080 #[test]
it_copy_with_progress_exist_overwrite()1081 fn it_copy_with_progress_exist_overwrite() {
1082
1083 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_exist_overwrite");
1084 let path_to = test_dir.join("out");
1085 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
1086 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
1087 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
1088 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
1089 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
1090 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
1091 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
1092 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
1093
1094 match dir::create_all(&path_to, true) {
1095 Ok(_) => {}
1096 Err(_) => {}
1097 };
1098
1099 dir::create_all(&dir1.0, true).unwrap();
1100 dir::create_all(&dir2.0, true).unwrap();
1101 dir::create_all(&sub.0, true).unwrap();
1102 dir::create_all(&sub.1, true).unwrap();
1103
1104
1105 assert!(dir1.0.exists());
1106 assert!(dir1.1.exists());
1107 assert!(dir2.0.exists());
1108 assert!(!dir2.1.exists());
1109 assert!(sub.0.exists());
1110 assert!(sub.1.exists());
1111
1112 file::write_all(&file1.0, "content1").unwrap();
1113 file::write_all(&file2.0, "content2").unwrap();
1114 file::write_all(&file3.0, "content3").unwrap();
1115 file::write_all(&file4.0, "content4").unwrap();
1116 file::write_all(&file5.0, "content5").unwrap();
1117
1118 file::write_all(&file1.1, "old content1").unwrap();
1119 file::write_all(&file3.1, "old content3").unwrap();
1120 file::write_all(&file4.1, "old content4").unwrap();
1121
1122 assert!(file1.0.exists());
1123 assert!(file2.0.exists());
1124 assert!(file3.0.exists());
1125 assert!(file4.0.exists());
1126 assert!(file5.0.exists());
1127 assert!(file1.1.exists());
1128 assert!(!file2.1.exists());
1129 assert!(file3.1.exists());
1130 assert!(file4.1.exists());
1131 assert!(!file5.1.exists());
1132
1133 let mut options = dir::CopyOptions::new();
1134 options.overwrite = true;
1135 let (tx, rx) = mpsc::channel();
1136 let result = thread::spawn(move || {
1137 let mut from_paths = Vec::new();
1138 from_paths.push(dir1.0.as_path());
1139 from_paths.push(dir2.0.as_path());
1140 from_paths.push(file1.0.as_path());
1141 from_paths.push(file2.0.as_path());
1142
1143 let func_test = |process_info: TransitProcess| {
1144 tx.send(process_info).unwrap();
1145 dir::TransitProcessResult::ContinueOrAbort
1146 };
1147
1148 let result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
1149
1150 assert_eq!(40, result);
1151 assert!(compare_dir(&dir1.0, &path_to));
1152 assert!(compare_dir(&dir2.0, &path_to));
1153 assert!(files_eq(&file1.0, &file1.1));
1154 assert!(files_eq(&file2.0, &file2.1));
1155
1156 }).join();
1157
1158 match result {
1159 Ok(_) => {}
1160 Err(err) => panic!(err),
1161 }
1162
1163 match rx.recv() {
1164 Err(_) => panic!("Errors should not be!"),
1165 _ => {}
1166
1167 }
1168
1169 }
1170
1171 #[test]
it_copy_with_progress_exist_not_overwrite()1172 fn it_copy_with_progress_exist_not_overwrite() {
1173
1174 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_exist_not_overwrite");
1175 let path_to = test_dir.join("out");
1176 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
1177 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
1178 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
1179 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
1180 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
1181 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
1182 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
1183 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
1184
1185 match dir::create_all(&path_to, true) {
1186 Ok(_) => {}
1187 Err(_) => {}
1188 };
1189
1190 dir::create_all(&dir1.0, true).unwrap();
1191 dir::create_all(&dir2.0, true).unwrap();
1192 dir::create_all(&sub.0, true).unwrap();
1193 dir::create_all(&sub.1, true).unwrap();
1194
1195
1196 assert!(dir1.0.exists());
1197 assert!(dir1.1.exists());
1198 assert!(dir2.0.exists());
1199 assert!(!dir2.1.exists());
1200 assert!(sub.0.exists());
1201 assert!(sub.1.exists());
1202
1203 file::write_all(&file1.0, "content1").unwrap();
1204 file::write_all(&file2.0, "content2").unwrap();
1205 file::write_all(&file3.0, "content3").unwrap();
1206 file::write_all(&file4.0, "content4").unwrap();
1207 file::write_all(&file5.0, "content5").unwrap();
1208
1209 file::write_all(&file1.1, "old content1").unwrap();
1210 file::write_all(&file3.1, "old content3").unwrap();
1211 file::write_all(&file4.1, "old content4").unwrap();
1212
1213 assert!(file1.0.exists());
1214 assert!(file2.0.exists());
1215 assert!(file3.0.exists());
1216 assert!(file4.0.exists());
1217 assert!(file5.0.exists());
1218 assert!(file1.1.exists());
1219 assert!(!file2.1.exists());
1220 assert!(file3.1.exists());
1221 assert!(file4.1.exists());
1222 assert!(!file5.1.exists());
1223
1224
1225 let mut from_paths = Vec::new();
1226 from_paths.push(dir1.0.as_path());
1227 from_paths.push(dir2.0.as_path());
1228 from_paths.push(file1.0.as_path());
1229 from_paths.push(file2.0.as_path());
1230
1231 let options = dir::CopyOptions::new();
1232 let func_test = |process_info: TransitProcess| {
1233 println!("{}", process_info.total_bytes);
1234 dir::TransitProcessResult::ContinueOrAbort
1235 };
1236
1237
1238 match copy_items_with_progress(&from_paths, &path_to, &options, func_test) {
1239 Ok(_) => panic!("Should be a error!"),
1240 Err(err) => {
1241 match err.kind {
1242 ErrorKind::AlreadyExists => {}
1243 _ => panic!(format!("{}", err.to_string())),
1244 }
1245 }
1246 };
1247
1248
1249 }
1250
1251
1252 #[test]
it_copy_with_progress_exist_skip_exist()1253 fn it_copy_with_progress_exist_skip_exist() {
1254
1255 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_exist_skip_exist");
1256 let path_to = test_dir.join("out");
1257 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
1258 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
1259 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
1260 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
1261 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
1262 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
1263 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
1264 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
1265
1266 match dir::create_all(&path_to, true) {
1267 Ok(_) => {}
1268 Err(_) => {}
1269 };
1270
1271 dir::create_all(&dir1.0, true).unwrap();
1272 dir::create_all(&dir2.0, true).unwrap();
1273 dir::create_all(&sub.0, true).unwrap();
1274 dir::create_all(&sub.1, true).unwrap();
1275
1276
1277 assert!(dir1.0.exists());
1278 assert!(dir1.1.exists());
1279 assert!(dir2.0.exists());
1280 assert!(!dir2.1.exists());
1281 assert!(sub.0.exists());
1282 assert!(sub.1.exists());
1283
1284 file::write_all(&file1.0, "content1").unwrap();
1285 file::write_all(&file2.0, "content2").unwrap();
1286 file::write_all(&file3.0, "content3").unwrap();
1287 file::write_all(&file4.0, "content4").unwrap();
1288 file::write_all(&file5.0, "content5").unwrap();
1289
1290 file::write_all(&file1.1, "old content1").unwrap();
1291 file::write_all(&file3.1, "old content3").unwrap();
1292 file::write_all(&file4.1, "old content4").unwrap();
1293
1294 assert!(file1.0.exists());
1295 assert!(file2.0.exists());
1296 assert!(file3.0.exists());
1297 assert!(file4.0.exists());
1298 assert!(file5.0.exists());
1299 assert!(file1.1.exists());
1300 assert!(!file2.1.exists());
1301 assert!(file3.1.exists());
1302 assert!(file4.1.exists());
1303 assert!(!file5.1.exists());
1304
1305
1306
1307 let mut options = dir::CopyOptions::new();
1308 options.skip_exist = true;
1309 let (tx, rx) = mpsc::channel();
1310 let result = thread::spawn(move || {
1311 let mut from_paths = Vec::new();
1312 from_paths.push(dir1.0.as_path());
1313 from_paths.push(dir2.0.as_path());
1314 from_paths.push(file1.0.as_path());
1315 from_paths.push(file2.0.as_path());
1316
1317 let func_test = |process_info: TransitProcess| {
1318 tx.send(process_info).unwrap();
1319 dir::TransitProcessResult::ContinueOrAbort
1320 };
1321
1322 let result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
1323
1324 assert_eq!(16, result);
1325 assert!(!compare_dir(&dir1.0, &path_to));
1326 assert!(compare_dir(&dir2.0, &path_to));
1327 assert!(!files_eq(&file1.0, &file1.1));
1328 assert!(files_eq(&file2.0, &file2.1));
1329
1330 }).join();
1331
1332 match result {
1333 Ok(_) => {}
1334 Err(err) => panic!(err),
1335 }
1336
1337 match rx.recv() {
1338 Err(_) => panic!("Errors should not be!"),
1339 _ => {}
1340
1341 }
1342
1343
1344 }
1345
1346 #[test]
it_copy_with_progress_exist_overwrite_and_skip_exist()1347 fn it_copy_with_progress_exist_overwrite_and_skip_exist() {
1348 let test_dir =
1349 Path::new(TEST_FOLDER).join("it_copy_with_progress_exist_overwrite_and_skip_exist");
1350 let path_to = test_dir.join("out");
1351 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
1352 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
1353 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
1354 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
1355 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
1356 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
1357 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
1358 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
1359
1360 match dir::create_all(&path_to, true) {
1361 Ok(_) => {}
1362 Err(_) => {}
1363 };
1364
1365 dir::create_all(&dir1.0, true).unwrap();
1366 dir::create_all(&dir2.0, true).unwrap();
1367 dir::create_all(&sub.0, true).unwrap();
1368 dir::create_all(&sub.1, true).unwrap();
1369
1370
1371 assert!(dir1.0.exists());
1372 assert!(dir1.1.exists());
1373 assert!(dir2.0.exists());
1374 assert!(!dir2.1.exists());
1375 assert!(sub.0.exists());
1376 assert!(sub.1.exists());
1377
1378 file::write_all(&file1.0, "content1").unwrap();
1379 file::write_all(&file2.0, "content2").unwrap();
1380 file::write_all(&file3.0, "content3").unwrap();
1381 file::write_all(&file4.0, "content4").unwrap();
1382 file::write_all(&file5.0, "content5").unwrap();
1383
1384 file::write_all(&file1.1, "old content1").unwrap();
1385 file::write_all(&file3.1, "old content3").unwrap();
1386 file::write_all(&file4.1, "old content4").unwrap();
1387
1388 assert!(file1.0.exists());
1389 assert!(file2.0.exists());
1390 assert!(file3.0.exists());
1391 assert!(file4.0.exists());
1392 assert!(file5.0.exists());
1393 assert!(file1.1.exists());
1394 assert!(!file2.1.exists());
1395 assert!(file3.1.exists());
1396 assert!(file4.1.exists());
1397 assert!(!file5.1.exists());
1398
1399 let mut options = dir::CopyOptions::new();
1400 options.overwrite = true;
1401 options.skip_exist = true;
1402 let (tx, rx) = mpsc::channel();
1403 let result = thread::spawn(move || {
1404 let mut from_paths = Vec::new();
1405 from_paths.push(dir1.0.as_path());
1406 from_paths.push(dir2.0.as_path());
1407 from_paths.push(file1.0.as_path());
1408 from_paths.push(file2.0.as_path());
1409
1410 let func_test = |process_info: TransitProcess| {
1411 tx.send(process_info).unwrap();
1412 dir::TransitProcessResult::ContinueOrAbort
1413 };
1414
1415 let result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
1416
1417 assert_eq!(40, result);
1418 assert!(compare_dir(&dir1.0, &path_to));
1419 assert!(compare_dir(&dir2.0, &path_to));
1420 assert!(files_eq(&file1.0, &file1.1));
1421 assert!(files_eq(&file2.0, &file2.1));
1422
1423 }).join();
1424
1425 match result {
1426 Ok(_) => {}
1427 Err(err) => panic!(err),
1428 }
1429
1430 match rx.recv() {
1431 Err(_) => panic!("Errors should not be!"),
1432 _ => {}
1433
1434 }
1435 }
1436
1437
1438 #[test]
it_copy_with_progress_using_first_levels()1439 fn it_copy_with_progress_using_first_levels() {
1440
1441 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_using_first_levels");
1442 let path_to = test_dir.join("out");
1443 let d_level_1 = (test_dir.join("d_level_1"), path_to.join("d_level_1"));
1444 let d_level_2 = (d_level_1.0.join("d_level_2"), d_level_1.1.join("d_level_2"));
1445 let d_level_3 = (d_level_2.0.join("d_level_3"), d_level_2.1.join("d_level_3"));
1446 let d_level_4 = (d_level_3.0.join("d_level_4"), d_level_3.1.join("d_level_4"));
1447 let d_level_5 = (d_level_4.0.join("d_level_5"), d_level_4.1.join("d_level_5"));
1448
1449 let d2_level_1 = (test_dir.join("d2_level_1"), path_to.join("d2_level_1"));
1450 let d2_level_2 = (d_level_1.0.join("d2_level_2"), d_level_1.1.join("d2_level_2"));
1451 let d2_level_3 = (d_level_2.0.join("d2_level_3"), d_level_2.1.join("d2_level_3"));
1452 let d2_level_4 = (d_level_3.0.join("d2_level_4"), d_level_3.1.join("d2_level_4"));
1453 let d2_level_5 = (d_level_4.0.join("d2_level_5"), d_level_4.1.join("d2_level_5"));
1454
1455 let d3_level_1 = (test_dir.join("d3_level_1"), path_to.join("d3_level_1"));
1456
1457 let file1 = (d_level_1.0.join("file1.txt"),d_level_1.1.join("file1.txt"));
1458 let file2 = (d_level_2.0.join("file2.txt"),d_level_2.1.join("file2.txt"));
1459 let file3 = (d_level_3.0.join("file3.txt"),d_level_3.1.join("file3.txt"));
1460 let file4 = (d_level_4.0.join("file4.txt"),d_level_4.1.join("file4.txt"));
1461 let file5 = (d_level_5.0.join("file5.txt"),d_level_5.1.join("file5.txt"));
1462
1463 let file21 = (d2_level_1.0.join("file21.txt"),d2_level_1.1.join("file21.txt"));
1464 let file22 = (d2_level_2.0.join("file22.txt"),d2_level_2.1.join("file22.txt"));
1465 let file23 = (d2_level_3.0.join("file23.txt"),d2_level_3.1.join("file23.txt"));
1466 let file24 = (d2_level_4.0.join("file24.txt"),d2_level_4.1.join("file24.txt"));
1467 let file25 = (d2_level_5.0.join("file25.txt"),d2_level_5.1.join("file25.txt"));
1468
1469 let file31 = (d3_level_1.0.join("file31.txt"),d3_level_1.1.join("file31.txt"));
1470
1471 dir::create_all(&d_level_1.0, true).unwrap();
1472 dir::create_all(&d_level_2.0, true).unwrap();
1473 dir::create_all(&d_level_3.0, true).unwrap();
1474 dir::create_all(&d_level_4.0, true).unwrap();
1475 dir::create_all(&d_level_5.0, true).unwrap();
1476 dir::create_all(&path_to, true).unwrap();
1477
1478 dir::create_all(&d2_level_1.0, true).unwrap();
1479 dir::create_all(&d2_level_2.0, true).unwrap();
1480 dir::create_all(&d2_level_3.0, true).unwrap();
1481 dir::create_all(&d2_level_4.0, true).unwrap();
1482 dir::create_all(&d2_level_5.0, true).unwrap();
1483
1484 dir::create_all(&d3_level_1.0, true).unwrap();
1485
1486 assert!(path_to.exists());
1487 assert!(d_level_1.0.exists());
1488 assert!(d_level_2.0.exists());
1489 assert!(d_level_3.0.exists());
1490 assert!(d_level_4.0.exists());
1491 assert!(d_level_5.0.exists());
1492
1493 assert!(d2_level_1.0.exists());
1494 assert!(d2_level_2.0.exists());
1495 assert!(d2_level_3.0.exists());
1496 assert!(d2_level_4.0.exists());
1497 assert!(d2_level_5.0.exists());
1498
1499 assert!(d3_level_1.0.exists());
1500
1501 assert!(!d_level_1.1.exists());
1502 assert!(!d_level_2.1.exists());
1503 assert!(!d_level_3.1.exists());
1504 assert!(!d_level_4.1.exists());
1505 assert!(!d_level_5.1.exists());
1506
1507 assert!(!d2_level_1.1.exists());
1508 assert!(!d2_level_2.1.exists());
1509 assert!(!d2_level_3.1.exists());
1510 assert!(!d2_level_4.1.exists());
1511 assert!(!d2_level_5.1.exists());
1512
1513 assert!(!d3_level_1.1.exists());
1514
1515 fs_extra::file::write_all(&file1.0, "content1").unwrap();
1516 fs_extra::file::write_all(&file2.0, "content2").unwrap();
1517 fs_extra::file::write_all(&file3.0, "content3").unwrap();
1518 fs_extra::file::write_all(&file4.0, "content4").unwrap();
1519 fs_extra::file::write_all(&file5.0, "content5").unwrap();
1520
1521 fs_extra::file::write_all(&file21.0, "2content1").unwrap();
1522 fs_extra::file::write_all(&file22.0, "2content2").unwrap();
1523 fs_extra::file::write_all(&file23.0, "2content3").unwrap();
1524 fs_extra::file::write_all(&file24.0, "2content4").unwrap();
1525 fs_extra::file::write_all(&file25.0, "2content5").unwrap();
1526
1527 fs_extra::file::write_all(&file31.0, "3content1").unwrap();
1528
1529 assert!(file1.0.exists());
1530 assert!(file2.0.exists());
1531 assert!(file3.0.exists());
1532 assert!(file4.0.exists());
1533 assert!(file5.0.exists());
1534
1535 assert!(file21.0.exists());
1536 assert!(file22.0.exists());
1537 assert!(file23.0.exists());
1538 assert!(file24.0.exists());
1539 assert!(file25.0.exists());
1540
1541 assert!(file31.0.exists());
1542
1543 assert!(!file1.1.exists());
1544 assert!(!file2.1.exists());
1545 assert!(!file3.1.exists());
1546 assert!(!file4.1.exists());
1547 assert!(!file5.1.exists());
1548
1549 assert!(!file21.1.exists());
1550 assert!(!file22.1.exists());
1551 assert!(!file23.1.exists());
1552 assert!(!file24.1.exists());
1553 assert!(!file25.1.exists());
1554
1555 assert!(!file31.1.exists());
1556
1557
1558 let mut options = dir::CopyOptions::new();
1559 options.depth = 1;
1560 let (tx, rx) = mpsc::channel();
1561 let result = thread::spawn(move || {
1562 let mut from_paths = Vec::new();
1563 from_paths.push(d_level_1.0.as_path());
1564 from_paths.push(d2_level_1.0.as_path());
1565 from_paths.push(d3_level_1.0.as_path());
1566
1567 let func_test = |process_info: TransitProcess| {
1568 tx.send(process_info).unwrap();
1569 dir::TransitProcessResult::ContinueOrAbort
1570 };
1571
1572 let result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
1573
1574 assert_eq!(26, result);
1575
1576 assert!(file1.0.exists());
1577 assert!(file2.0.exists());
1578 assert!(file3.0.exists());
1579 assert!(file4.0.exists());
1580 assert!(file5.0.exists());
1581
1582 assert!(file21.0.exists());
1583 assert!(file22.0.exists());
1584 assert!(file23.0.exists());
1585 assert!(file24.0.exists());
1586 assert!(file25.0.exists());
1587
1588 assert!(file31.0.exists());
1589
1590 assert!(file1.1.exists());
1591 assert!(!file2.1.exists());
1592 assert!(!file3.1.exists());
1593 assert!(!file4.1.exists());
1594 assert!(!file5.1.exists());
1595
1596 assert!(file21.1.exists());
1597 assert!(!file22.1.exists());
1598 assert!(!file23.1.exists());
1599 assert!(!file24.1.exists());
1600 assert!(!file25.1.exists());
1601
1602 assert!(file31.1.exists());
1603 assert!(files_eq(&file1.0, &file1.1));
1604 assert!(files_eq(&file21.0, &file21.1));
1605 assert!(files_eq(&file31.0, &file31.1));
1606
1607 }).join();
1608
1609 match result {
1610 Ok(_) => {}
1611 Err(err) => panic!(err),
1612 }
1613
1614 match rx.recv() {
1615 Err(_) => panic!("Errors should not be!"),
1616 _ => {}
1617
1618 }
1619 }
1620
1621
1622 #[test]
it_copy_with_progress_using_four_levels()1623 fn it_copy_with_progress_using_four_levels() {
1624
1625 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_using_four_levels");
1626 let path_to = test_dir.join("out");
1627 let d_level_1 = (test_dir.join("d_level_1"), path_to.join("d_level_1"));
1628 let d_level_2 = (d_level_1.0.join("d_level_2"), d_level_1.1.join("d_level_2"));
1629 let d_level_3 = (d_level_2.0.join("d_level_3"), d_level_2.1.join("d_level_3"));
1630 let d_level_4 = (d_level_3.0.join("d_level_4"), d_level_3.1.join("d_level_4"));
1631 let d_level_5 = (d_level_4.0.join("d_level_5"), d_level_4.1.join("d_level_5"));
1632
1633 let d2_level_1 = (test_dir.join("d2_level_1"), path_to.join("d2_level_1"));
1634 let d2_level_2 = (d_level_1.0.join("d2_level_2"), d_level_1.1.join("d2_level_2"));
1635 let d2_level_3 = (d_level_2.0.join("d2_level_3"), d_level_2.1.join("d2_level_3"));
1636 let d2_level_4 = (d_level_3.0.join("d2_level_4"), d_level_3.1.join("d2_level_4"));
1637 let d2_level_5 = (d_level_4.0.join("d2_level_5"), d_level_4.1.join("d2_level_5"));
1638
1639 let d3_level_1 = (test_dir.join("d3_level_1"), path_to.join("d3_level_1"));
1640
1641 let file1 = (d_level_1.0.join("file1.txt"),d_level_1.1.join("file1.txt"));
1642 let file2 = (d_level_2.0.join("file2.txt"),d_level_2.1.join("file2.txt"));
1643 let file3 = (d_level_3.0.join("file3.txt"),d_level_3.1.join("file3.txt"));
1644 let file4 = (d_level_4.0.join("file4.txt"),d_level_4.1.join("file4.txt"));
1645 let file5 = (d_level_5.0.join("file5.txt"),d_level_5.1.join("file5.txt"));
1646
1647 let file21 = (d2_level_1.0.join("file21.txt"),d2_level_1.1.join("file21.txt"));
1648 let file22 = (d2_level_2.0.join("file22.txt"),d2_level_2.1.join("file22.txt"));
1649 let file23 = (d2_level_3.0.join("file23.txt"),d2_level_3.1.join("file23.txt"));
1650 let file24 = (d2_level_4.0.join("file24.txt"),d2_level_4.1.join("file24.txt"));
1651 let file25 = (d2_level_5.0.join("file25.txt"),d2_level_5.1.join("file25.txt"));
1652
1653 let file31 = (d3_level_1.0.join("file31.txt"),d3_level_1.1.join("file31.txt"));
1654
1655 dir::create_all(&d_level_1.0, true).unwrap();
1656 dir::create_all(&d_level_2.0, true).unwrap();
1657 dir::create_all(&d_level_3.0, true).unwrap();
1658 dir::create_all(&d_level_4.0, true).unwrap();
1659 dir::create_all(&d_level_5.0, true).unwrap();
1660 dir::create_all(&path_to, true).unwrap();
1661
1662 dir::create_all(&d2_level_1.0, true).unwrap();
1663 dir::create_all(&d2_level_2.0, true).unwrap();
1664 dir::create_all(&d2_level_3.0, true).unwrap();
1665 dir::create_all(&d2_level_4.0, true).unwrap();
1666 dir::create_all(&d2_level_5.0, true).unwrap();
1667
1668 dir::create_all(&d3_level_1.0, true).unwrap();
1669
1670 assert!(path_to.exists());
1671 assert!(d_level_1.0.exists());
1672 assert!(d_level_2.0.exists());
1673 assert!(d_level_3.0.exists());
1674 assert!(d_level_4.0.exists());
1675 assert!(d_level_5.0.exists());
1676
1677 assert!(d2_level_1.0.exists());
1678 assert!(d2_level_2.0.exists());
1679 assert!(d2_level_3.0.exists());
1680 assert!(d2_level_4.0.exists());
1681 assert!(d2_level_5.0.exists());
1682
1683 assert!(d3_level_1.0.exists());
1684
1685 assert!(!d_level_1.1.exists());
1686 assert!(!d_level_2.1.exists());
1687 assert!(!d_level_3.1.exists());
1688 assert!(!d_level_4.1.exists());
1689 assert!(!d_level_5.1.exists());
1690
1691 assert!(!d2_level_1.1.exists());
1692 assert!(!d2_level_2.1.exists());
1693 assert!(!d2_level_3.1.exists());
1694 assert!(!d2_level_4.1.exists());
1695 assert!(!d2_level_5.1.exists());
1696
1697 assert!(!d3_level_1.1.exists());
1698
1699 fs_extra::file::write_all(&file1.0, "content1").unwrap();
1700 fs_extra::file::write_all(&file2.0, "content2").unwrap();
1701 fs_extra::file::write_all(&file3.0, "content3").unwrap();
1702 fs_extra::file::write_all(&file4.0, "content4").unwrap();
1703 fs_extra::file::write_all(&file5.0, "content5").unwrap();
1704
1705 fs_extra::file::write_all(&file21.0, "2content1").unwrap();
1706 fs_extra::file::write_all(&file22.0, "2content2").unwrap();
1707 fs_extra::file::write_all(&file23.0, "2content3").unwrap();
1708 fs_extra::file::write_all(&file24.0, "2content4").unwrap();
1709 fs_extra::file::write_all(&file25.0, "2content5").unwrap();
1710
1711 fs_extra::file::write_all(&file31.0, "3content1").unwrap();
1712
1713 assert!(file1.0.exists());
1714 assert!(file2.0.exists());
1715 assert!(file3.0.exists());
1716 assert!(file4.0.exists());
1717 assert!(file5.0.exists());
1718
1719 assert!(file21.0.exists());
1720 assert!(file22.0.exists());
1721 assert!(file23.0.exists());
1722 assert!(file24.0.exists());
1723 assert!(file25.0.exists());
1724
1725 assert!(file31.0.exists());
1726
1727 assert!(!file1.1.exists());
1728 assert!(!file2.1.exists());
1729 assert!(!file3.1.exists());
1730 assert!(!file4.1.exists());
1731 assert!(!file5.1.exists());
1732
1733 assert!(!file21.1.exists());
1734 assert!(!file22.1.exists());
1735 assert!(!file23.1.exists());
1736 assert!(!file24.1.exists());
1737 assert!(!file25.1.exists());
1738
1739 assert!(!file31.1.exists());
1740
1741
1742 let mut options = dir::CopyOptions::new();
1743 options.depth = 4;
1744 let (tx, rx) = mpsc::channel();
1745 let result = thread::spawn(move || {
1746 let mut from_paths = Vec::new();
1747 from_paths.push(d_level_1.0.as_path());
1748 from_paths.push(d2_level_1.0.as_path());
1749 from_paths.push(d3_level_1.0.as_path());
1750
1751 let func_test = |process_info: TransitProcess| {
1752 tx.send(process_info).unwrap();
1753 dir::TransitProcessResult::ContinueOrAbort
1754 };
1755
1756 let result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
1757
1758 assert_eq!(77, result);
1759
1760 assert!(file1.0.exists());
1761 assert!(file2.0.exists());
1762 assert!(file3.0.exists());
1763 assert!(file4.0.exists());
1764 assert!(file5.0.exists());
1765
1766 assert!(file21.0.exists());
1767 assert!(file22.0.exists());
1768 assert!(file23.0.exists());
1769 assert!(file24.0.exists());
1770 assert!(file25.0.exists());
1771
1772 assert!(file31.0.exists());
1773
1774 assert!(file1.1.exists());
1775 assert!(file2.1.exists());
1776 assert!(file3.1.exists());
1777 assert!(file4.1.exists());
1778 assert!(!file5.1.exists());
1779
1780 assert!(file21.1.exists());
1781 assert!(file22.1.exists());
1782 assert!(file23.1.exists());
1783 assert!(file24.1.exists());
1784 assert!(!file25.1.exists());
1785
1786 assert!(file31.1.exists());
1787 assert!(files_eq(&file1.0, &file1.1));
1788 assert!(files_eq(&file21.0, &file21.1));
1789 assert!(files_eq(&file31.0, &file31.1));
1790
1791 }).join();
1792
1793 match result {
1794 Ok(_) => {}
1795 Err(err) => panic!(err),
1796 }
1797
1798 match rx.recv() {
1799 Err(_) => panic!("Errors should not be!"),
1800 _ => {}
1801
1802 }
1803 }
1804
1805
1806
1807 #[test]
it_move_work()1808 fn it_move_work() {
1809
1810 let test_dir = Path::new(TEST_FOLDER).join("it_move_work");
1811 let path_to = test_dir.join("out");
1812 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
1813 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
1814 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
1815 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
1816 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
1817 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
1818 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
1819 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
1820
1821 match dir::create_all(&path_to, true) {
1822 Ok(_) => {}
1823 Err(_) => {}
1824 };
1825 dir::create_all(&dir1.0, true).unwrap();
1826 dir::create_all(&dir2.0, true).unwrap();
1827 dir::create_all(&sub.0, true).unwrap();
1828
1829 assert!(dir1.0.exists());
1830 assert!(!dir1.1.exists());
1831 assert!(dir2.0.exists());
1832 assert!(!dir2.1.exists());
1833 assert!(sub.0.exists());
1834 assert!(!sub.1.exists());
1835
1836 file::write_all(&file1.0, "content1").unwrap();
1837 file::write_all(&file2.0, "content2").unwrap();
1838 file::write_all(&file3.0, "content3").unwrap();
1839 file::write_all(&file4.0, "content4").unwrap();
1840 file::write_all(&file5.0, "content5").unwrap();
1841
1842 assert!(file1.0.exists());
1843 assert!(file2.0.exists());
1844 assert!(file3.0.exists());
1845 assert!(file4.0.exists());
1846 assert!(file5.0.exists());
1847 assert!(!file1.1.exists());
1848 assert!(!file2.1.exists());
1849 assert!(!file3.1.exists());
1850 assert!(!file4.1.exists());
1851 assert!(!file5.1.exists());
1852
1853
1854
1855 let mut from_paths = Vec::new();
1856 from_paths.push(dir1.0.as_path());
1857 from_paths.push(dir2.0.as_path());
1858 from_paths.push(file1.0.as_path());
1859 from_paths.push(file2.0.as_path());
1860
1861 let options = dir::CopyOptions::new();
1862 let result = move_items(&from_paths, &path_to, &options).unwrap();
1863
1864 assert_eq!(40, result);
1865 assert!(!file1.0.exists());
1866 assert!(!file2.0.exists());
1867 assert!(!file3.0.exists());
1868 assert!(!file4.0.exists());
1869 assert!(!file5.0.exists());
1870 assert!(file1.1.exists());
1871 assert!(file2.1.exists());
1872 assert!(file3.1.exists());
1873 assert!(file4.1.exists());
1874 assert!(file5.1.exists());
1875
1876 }
1877
1878
1879 #[test]
it_move_source_not_exist()1880 fn it_move_source_not_exist() {
1881 let test_dir = Path::new(TEST_FOLDER).join("it_move_source_not_exist");
1882 let path_to = test_dir.join("out");
1883 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
1884 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
1885 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
1886 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
1887
1888 match dir::create_all(&path_to, true) {
1889 Ok(_) => {}
1890 Err(_) => {}
1891 };
1892
1893 assert!(!dir1.0.exists());
1894 assert!(!dir1.1.exists());
1895 assert!(!dir2.0.exists());
1896 assert!(!dir2.1.exists());
1897 assert!(!sub.0.exists());
1898 assert!(!sub.1.exists());
1899
1900
1901 assert!(!file1.0.exists());
1902 assert!(!file1.1.exists());
1903
1904
1905 let mut from_paths = Vec::new();
1906 from_paths.push(dir1.0.as_path());
1907 from_paths.push(dir2.0.as_path());
1908 from_paths.push(file1.0.as_path());
1909
1910 let options = dir::CopyOptions::new();
1911 match move_items(&from_paths, &path_to, &options) {
1912 Ok(_) => panic!("Should be a error!"),
1913 Err(err) => {
1914 match err.kind {
1915 ErrorKind::NotFound => {}
1916 _ => {}
1917 }
1918 }
1919 };
1920 }
1921
1922
1923 #[test]
it_move_exist_overwrite()1924 fn it_move_exist_overwrite() {
1925
1926 let test_dir = Path::new(TEST_FOLDER).join("it_move_exist_overwrite");
1927 let path_to = test_dir.join("out");
1928 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
1929 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
1930 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
1931 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
1932 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
1933 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
1934 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
1935 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
1936
1937 match dir::create_all(&path_to, true) {
1938 Ok(_) => {}
1939 Err(_) => {}
1940 };
1941
1942 dir::create_all(&dir1.0, true).unwrap();
1943 dir::create_all(&dir2.0, true).unwrap();
1944 dir::create_all(&sub.0, true).unwrap();
1945 dir::create_all(&sub.1, true).unwrap();
1946
1947
1948 assert!(dir1.0.exists());
1949 assert!(dir1.1.exists());
1950 assert!(dir2.0.exists());
1951 assert!(!dir2.1.exists());
1952 assert!(sub.0.exists());
1953 assert!(sub.1.exists());
1954
1955 file::write_all(&file1.0, "content1").unwrap();
1956 file::write_all(&file2.0, "content2").unwrap();
1957 file::write_all(&file3.0, "content3").unwrap();
1958 file::write_all(&file4.0, "content4").unwrap();
1959 file::write_all(&file5.0, "content5").unwrap();
1960
1961 file::write_all(&file1.1, "old content1").unwrap();
1962 file::write_all(&file3.1, "old content3").unwrap();
1963 file::write_all(&file4.1, "old content4").unwrap();
1964
1965 assert!(file1.0.exists());
1966 assert!(file2.0.exists());
1967 assert!(file3.0.exists());
1968 assert!(file4.0.exists());
1969 assert!(file5.0.exists());
1970 assert!(file1.1.exists());
1971 assert!(!file2.1.exists());
1972 assert!(file3.1.exists());
1973 assert!(file4.1.exists());
1974 assert!(!file5.1.exists());
1975
1976
1977 let mut from_paths = Vec::new();
1978 from_paths.push(dir1.0.as_path());
1979 from_paths.push(dir2.0.as_path());
1980 from_paths.push(file1.0.as_path());
1981 from_paths.push(file2.0.as_path());
1982
1983 let mut options = dir::CopyOptions::new();
1984 options.overwrite = true;
1985 let result = move_items(&from_paths, &path_to, &options).unwrap();
1986
1987 assert_eq!(40, result);
1988 assert!(!file1.0.exists());
1989 assert!(!file2.0.exists());
1990 assert!(!file3.0.exists());
1991 assert!(!file4.0.exists());
1992 assert!(!file5.0.exists());
1993 assert!(file1.1.exists());
1994 assert!(file2.1.exists());
1995 assert!(file3.1.exists());
1996 assert!(file4.1.exists());
1997 assert!(file5.1.exists());
1998
1999 }
2000
2001 #[test]
it_move_exist_not_overwrite()2002 fn it_move_exist_not_overwrite() {
2003
2004 let test_dir = Path::new(TEST_FOLDER).join("it_move_exist_not_overwrite");
2005 let path_to = test_dir.join("out");
2006 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2007 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2008 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2009 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2010 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
2011 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
2012 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
2013 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
2014
2015 match dir::create_all(&path_to, true) {
2016 Ok(_) => {}
2017 Err(_) => {}
2018 };
2019
2020 dir::create_all(&dir1.0, true).unwrap();
2021 dir::create_all(&dir2.0, true).unwrap();
2022 dir::create_all(&sub.0, true).unwrap();
2023 dir::create_all(&sub.1, true).unwrap();
2024
2025
2026 assert!(dir1.0.exists());
2027 assert!(dir1.1.exists());
2028 assert!(dir2.0.exists());
2029 assert!(!dir2.1.exists());
2030 assert!(sub.0.exists());
2031 assert!(sub.1.exists());
2032
2033 file::write_all(&file1.0, "content1").unwrap();
2034 file::write_all(&file2.0, "content2").unwrap();
2035 file::write_all(&file3.0, "content3").unwrap();
2036 file::write_all(&file4.0, "content4").unwrap();
2037 file::write_all(&file5.0, "content5").unwrap();
2038
2039 file::write_all(&file1.1, "old content1").unwrap();
2040 file::write_all(&file3.1, "old content3").unwrap();
2041 file::write_all(&file4.1, "old content4").unwrap();
2042
2043 assert!(file1.0.exists());
2044 assert!(file2.0.exists());
2045 assert!(file3.0.exists());
2046 assert!(file4.0.exists());
2047 assert!(file5.0.exists());
2048 assert!(file1.1.exists());
2049 assert!(!file2.1.exists());
2050 assert!(file3.1.exists());
2051 assert!(file4.1.exists());
2052 assert!(!file5.1.exists());
2053
2054
2055 let mut from_paths = Vec::new();
2056 from_paths.push(dir1.0.as_path());
2057 from_paths.push(dir2.0.as_path());
2058 from_paths.push(file1.0.as_path());
2059 from_paths.push(file2.0.as_path());
2060
2061 let options = dir::CopyOptions::new();
2062 match move_items(&from_paths, &path_to, &options) {
2063 Ok(_) => panic!("Should be a error!"),
2064 Err(err) => {
2065 match err.kind {
2066 ErrorKind::AlreadyExists => {}
2067 _ => panic!(format!("{}", err.to_string())),
2068 }
2069 }
2070 };
2071
2072
2073 }
2074
2075
2076 #[test]
it_move_exist_skip()2077 fn it_move_exist_skip() {
2078
2079 let test_dir = Path::new(TEST_FOLDER).join("it_move_exist_skip");
2080 let path_to = test_dir.join("out");
2081 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2082 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2083 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2084 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2085 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
2086 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
2087 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
2088 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
2089
2090 match dir::create_all(&path_to, true) {
2091 Ok(_) => {}
2092 Err(_) => {}
2093 };
2094
2095 dir::create_all(&dir1.0, true).unwrap();
2096 dir::create_all(&dir2.0, true).unwrap();
2097 dir::create_all(&sub.0, true).unwrap();
2098 dir::create_all(&sub.1, true).unwrap();
2099
2100
2101 assert!(dir1.0.exists());
2102 assert!(dir1.1.exists());
2103 assert!(dir2.0.exists());
2104 assert!(!dir2.1.exists());
2105 assert!(sub.0.exists());
2106 assert!(sub.1.exists());
2107
2108 file::write_all(&file1.0, "content1").unwrap();
2109 file::write_all(&file2.0, "content2").unwrap();
2110 file::write_all(&file3.0, "content3").unwrap();
2111 file::write_all(&file4.0, "content4").unwrap();
2112 file::write_all(&file5.0, "content5").unwrap();
2113
2114 file::write_all(&file1.1, "old content1").unwrap();
2115 file::write_all(&file3.1, "old content3").unwrap();
2116 file::write_all(&file4.1, "old content4").unwrap();
2117
2118 assert!(file1.0.exists());
2119 assert!(file2.0.exists());
2120 assert!(file3.0.exists());
2121 assert!(file4.0.exists());
2122 assert!(file5.0.exists());
2123 assert!(file1.1.exists());
2124 assert!(!file2.1.exists());
2125 assert!(file3.1.exists());
2126 assert!(file4.1.exists());
2127 assert!(!file5.1.exists());
2128
2129
2130 let mut from_paths = Vec::new();
2131 from_paths.push(dir1.0.as_path());
2132 from_paths.push(dir2.0.as_path());
2133 from_paths.push(file1.0.as_path());
2134 from_paths.push(file2.0.as_path());
2135
2136 let mut options = dir::CopyOptions::new();
2137 options.skip_exist = true;
2138 let result = move_items(&from_paths, &path_to, &options).unwrap();
2139
2140 assert_eq!(16, result);
2141 assert!(!files_eq(&file1.0, &file1.1));
2142 assert!(!file2.0.exists());
2143 assert!(!files_eq(&file3.0, &file3.1));
2144 assert!(!files_eq(&file4.0, &file4.1));
2145 assert!(!file5.0.exists());
2146 }
2147
2148 #[test]
it_move_exist_overwrite_and_skip_exist()2149 fn it_move_exist_overwrite_and_skip_exist() {
2150
2151 let test_dir = Path::new(TEST_FOLDER).join("it_move_exist_overwrite_and_skip_exist");
2152 let path_to = test_dir.join("out");
2153 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2154 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2155 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2156 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2157 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
2158 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
2159 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
2160 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
2161
2162 match dir::create_all(&path_to, true) {
2163 Ok(_) => {}
2164 Err(_) => {}
2165 };
2166
2167 dir::create_all(&dir1.0, true).unwrap();
2168 dir::create_all(&dir2.0, true).unwrap();
2169 dir::create_all(&sub.0, true).unwrap();
2170 dir::create_all(&sub.1, true).unwrap();
2171
2172
2173 assert!(dir1.0.exists());
2174 assert!(dir1.1.exists());
2175 assert!(dir2.0.exists());
2176 assert!(!dir2.1.exists());
2177 assert!(sub.0.exists());
2178 assert!(sub.1.exists());
2179
2180 file::write_all(&file1.0, "content1").unwrap();
2181 file::write_all(&file2.0, "content2").unwrap();
2182 file::write_all(&file3.0, "content3").unwrap();
2183 file::write_all(&file4.0, "content4").unwrap();
2184 file::write_all(&file5.0, "content5").unwrap();
2185
2186 file::write_all(&file1.1, "old content1").unwrap();
2187 file::write_all(&file3.1, "old content3").unwrap();
2188 file::write_all(&file4.1, "old content4").unwrap();
2189
2190 assert!(file1.0.exists());
2191 assert!(file2.0.exists());
2192 assert!(file3.0.exists());
2193 assert!(file4.0.exists());
2194 assert!(file5.0.exists());
2195 assert!(file1.1.exists());
2196 assert!(!file2.1.exists());
2197 assert!(file3.1.exists());
2198 assert!(file4.1.exists());
2199 assert!(!file5.1.exists());
2200
2201
2202 let mut from_paths = Vec::new();
2203 from_paths.push(dir1.0.as_path());
2204 from_paths.push(dir2.0.as_path());
2205 from_paths.push(file1.0.as_path());
2206 from_paths.push(file2.0.as_path());
2207
2208 let mut options = dir::CopyOptions::new();
2209 options.overwrite = true;
2210 options.skip_exist = true;
2211 let result = move_items(&from_paths, &path_to, &options).unwrap();
2212
2213 assert_eq!(40, result);
2214 assert!(!file1.0.exists());
2215 assert!(!file2.0.exists());
2216 assert!(!file3.0.exists());
2217 assert!(!file4.0.exists());
2218 assert!(!file5.0.exists());
2219 assert!(file1.1.exists());
2220 assert!(file2.1.exists());
2221 assert!(file3.1.exists());
2222 assert!(file4.1.exists());
2223 assert!(file5.1.exists());
2224 }
2225
2226
2227 #[test]
it_move_progress_work()2228 fn it_move_progress_work() {
2229
2230 let test_dir = Path::new(TEST_FOLDER).join("it_move_progress_work");
2231 let path_to = test_dir.join("out");
2232 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2233 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2234 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2235 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2236 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
2237 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
2238 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
2239 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
2240
2241 match dir::create_all(&path_to, true) {
2242 Ok(_) => {}
2243 Err(_) => {}
2244 };
2245 dir::create_all(&dir1.0, true).unwrap();
2246 dir::create_all(&dir2.0, true).unwrap();
2247 dir::create_all(&sub.0, true).unwrap();
2248
2249 assert!(dir1.0.exists());
2250 assert!(!dir1.1.exists());
2251 assert!(dir2.0.exists());
2252 assert!(!dir2.1.exists());
2253 assert!(sub.0.exists());
2254 assert!(!sub.1.exists());
2255
2256 file::write_all(&file1.0, "content1").unwrap();
2257 file::write_all(&file2.0, "content22").unwrap();
2258 file::write_all(&file3.0, "content3").unwrap();
2259 file::write_all(&file4.0, "content4").unwrap();
2260 file::write_all(&file5.0, "content5").unwrap();
2261
2262 assert!(file1.0.exists());
2263 assert!(file2.0.exists());
2264 assert!(file3.0.exists());
2265 assert!(file4.0.exists());
2266 assert!(file5.0.exists());
2267 assert!(!file1.1.exists());
2268 assert!(!file2.1.exists());
2269 assert!(!file3.1.exists());
2270 assert!(!file4.1.exists());
2271 assert!(!file5.1.exists());
2272
2273
2274 let options = dir::CopyOptions::new();
2275 let (tx, rx) = mpsc::channel();
2276 let result = thread::spawn(move || {
2277 let mut from_paths = Vec::new();
2278 from_paths.push(dir1.0.as_path());
2279 from_paths.push(dir2.0.as_path());
2280 from_paths.push(file1.0.as_path());
2281 from_paths.push(file2.0.as_path());
2282
2283 let func_test = |process_info: TransitProcess| {
2284 tx.send(process_info).unwrap();
2285 dir::TransitProcessResult::ContinueOrAbort
2286 };
2287 let result = move_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
2288
2289 assert_eq!(41, result);
2290 assert!(!file1.0.exists());
2291 assert!(!file2.0.exists());
2292 assert!(!file3.0.exists());
2293 assert!(!file4.0.exists());
2294 assert!(!file5.0.exists());
2295 assert!(file1.1.exists());
2296 assert!(file2.1.exists());
2297 assert!(file3.1.exists());
2298 assert!(file4.1.exists());
2299 assert!(file5.1.exists());
2300 }).join();
2301
2302 loop {
2303 match rx.try_recv() {
2304 Ok(process_info) => {
2305 if process_info.file_name == "file2.txt" {
2306 assert_eq!(9, process_info.file_total_bytes);
2307 assert_eq!(41, process_info.total_bytes);
2308 } else if process_info.file_name == "file1.txt" {
2309 assert_eq!(8, process_info.file_total_bytes);
2310 assert_eq!(41, process_info.total_bytes);
2311 }
2312 }
2313 Err(TryRecvError::Disconnected) => {
2314 break;
2315 }
2316 Err(TryRecvError::Empty) => {}
2317 }
2318 }
2319
2320 match result {
2321 Ok(_) => {}
2322 Err(err) => panic!(err),
2323 }
2324
2325 }
2326
2327
2328
2329 #[test]
it_move_with_progress_source_not_exist()2330 fn it_move_with_progress_source_not_exist() {
2331 let test_dir = Path::new(TEST_FOLDER).join("it_move_with_progress_source_not_exist");
2332 let path_to = test_dir.join("out");
2333 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2334 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2335 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2336 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2337
2338 match dir::create_all(&path_to, true) {
2339 Ok(_) => {}
2340 Err(_) => {}
2341 };
2342
2343 assert!(!dir1.0.exists());
2344 assert!(!dir1.1.exists());
2345 assert!(!dir2.0.exists());
2346 assert!(!dir2.1.exists());
2347 assert!(!sub.0.exists());
2348 assert!(!sub.1.exists());
2349
2350
2351 assert!(!file1.0.exists());
2352 assert!(!file1.1.exists());
2353
2354
2355 let mut from_paths = Vec::new();
2356 from_paths.push(dir1.0.as_path());
2357 from_paths.push(dir2.0.as_path());
2358 from_paths.push(file1.0.as_path());
2359
2360
2361 let func_test = |process_info: TransitProcess| {
2362 println!("{}", process_info.total_bytes);
2363 dir::TransitProcessResult::ContinueOrAbort
2364 };
2365 let options = dir::CopyOptions::new();
2366 match move_items_with_progress(&from_paths, &path_to, &options, func_test) {
2367 Ok(_) => panic!("Should be a error!"),
2368 Err(err) => {
2369 match err.kind {
2370 ErrorKind::NotFound => {}
2371 _ => {}
2372 }
2373 }
2374 };
2375 }
2376
2377
2378 #[test]
it_move_with_progress_exist_overwrite()2379 fn it_move_with_progress_exist_overwrite() {
2380
2381 let test_dir = Path::new(TEST_FOLDER).join("it_move_with_progress_exist_overwrite");
2382 let path_to = test_dir.join("out");
2383 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2384 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2385 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2386 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2387 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
2388 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
2389 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
2390 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
2391
2392 match dir::create_all(&path_to, true) {
2393 Ok(_) => {}
2394 Err(_) => {}
2395 };
2396
2397 dir::create_all(&dir1.0, true).unwrap();
2398 dir::create_all(&dir2.0, true).unwrap();
2399 dir::create_all(&sub.0, true).unwrap();
2400 dir::create_all(&sub.1, true).unwrap();
2401
2402
2403 assert!(dir1.0.exists());
2404 assert!(dir1.1.exists());
2405 assert!(dir2.0.exists());
2406 assert!(!dir2.1.exists());
2407 assert!(sub.0.exists());
2408 assert!(sub.1.exists());
2409
2410 file::write_all(&file1.0, "content1").unwrap();
2411 file::write_all(&file2.0, "content2").unwrap();
2412 file::write_all(&file3.0, "content3").unwrap();
2413 file::write_all(&file4.0, "content4").unwrap();
2414 file::write_all(&file5.0, "content5").unwrap();
2415
2416 file::write_all(&file1.1, "old content1").unwrap();
2417 file::write_all(&file3.1, "old content3").unwrap();
2418 file::write_all(&file4.1, "old content4").unwrap();
2419
2420 assert!(file1.0.exists());
2421 assert!(file2.0.exists());
2422 assert!(file3.0.exists());
2423 assert!(file4.0.exists());
2424 assert!(file5.0.exists());
2425 assert!(file1.1.exists());
2426 assert!(!file2.1.exists());
2427 assert!(file3.1.exists());
2428 assert!(file4.1.exists());
2429 assert!(!file5.1.exists());
2430
2431 let mut options = dir::CopyOptions::new();
2432 options.overwrite = true;
2433 let (tx, rx) = mpsc::channel();
2434 let result = thread::spawn(move || {
2435 let mut from_paths = Vec::new();
2436 from_paths.push(dir1.0.as_path());
2437 from_paths.push(dir2.0.as_path());
2438 from_paths.push(file1.0.as_path());
2439 from_paths.push(file2.0.as_path());
2440
2441 let func_test = |process_info: TransitProcess| {
2442 tx.send(process_info).unwrap();
2443 dir::TransitProcessResult::ContinueOrAbort
2444 };
2445 let result = move_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
2446
2447 assert_eq!(40, result);
2448 assert!(!file1.0.exists());
2449 assert!(!file2.0.exists());
2450 assert!(!file3.0.exists());
2451 assert!(!file4.0.exists());
2452 assert!(!file5.0.exists());
2453 assert!(file1.1.exists());
2454 assert!(file2.1.exists());
2455 assert!(file3.1.exists());
2456 assert!(file4.1.exists());
2457 assert!(file5.1.exists());
2458 }).join();
2459
2460 match result {
2461 Ok(_) => {}
2462 Err(err) => panic!(err),
2463 }
2464
2465 match rx.recv() {
2466 Err(_) => panic!("Errors should not be!"),
2467 _ => {}
2468
2469 }
2470
2471 }
2472
2473 #[test]
it_move_with_progress_exist_not_overwrite()2474 fn it_move_with_progress_exist_not_overwrite() {
2475
2476 let test_dir = Path::new(TEST_FOLDER).join("it_move_with_progress_exist_not_overwrite");
2477 let path_to = test_dir.join("out");
2478 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2479 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2480 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2481 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2482 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
2483 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
2484 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
2485 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
2486
2487 match dir::create_all(&path_to, true) {
2488 Ok(_) => {}
2489 Err(_) => {}
2490 };
2491
2492 dir::create_all(&dir1.0, true).unwrap();
2493 dir::create_all(&dir2.0, true).unwrap();
2494 dir::create_all(&sub.0, true).unwrap();
2495 dir::create_all(&sub.1, true).unwrap();
2496
2497
2498 assert!(dir1.0.exists());
2499 assert!(dir1.1.exists());
2500 assert!(dir2.0.exists());
2501 assert!(!dir2.1.exists());
2502 assert!(sub.0.exists());
2503 assert!(sub.1.exists());
2504
2505 file::write_all(&file1.0, "content1").unwrap();
2506 file::write_all(&file2.0, "content2").unwrap();
2507 file::write_all(&file3.0, "content3").unwrap();
2508 file::write_all(&file4.0, "content4").unwrap();
2509 file::write_all(&file5.0, "content5").unwrap();
2510
2511 file::write_all(&file1.1, "old content1").unwrap();
2512 file::write_all(&file3.1, "old content3").unwrap();
2513 file::write_all(&file4.1, "old content4").unwrap();
2514
2515 assert!(file1.0.exists());
2516 assert!(file2.0.exists());
2517 assert!(file3.0.exists());
2518 assert!(file4.0.exists());
2519 assert!(file5.0.exists());
2520 assert!(file1.1.exists());
2521 assert!(!file2.1.exists());
2522 assert!(file3.1.exists());
2523 assert!(file4.1.exists());
2524 assert!(!file5.1.exists());
2525
2526
2527 let mut from_paths = Vec::new();
2528 from_paths.push(dir1.0.as_path());
2529 from_paths.push(dir2.0.as_path());
2530 from_paths.push(file1.0.as_path());
2531 from_paths.push(file2.0.as_path());
2532
2533 let options = dir::CopyOptions::new();
2534 let func_test = |process_info: TransitProcess| {
2535 println!("{}", process_info.total_bytes);
2536 dir::TransitProcessResult::ContinueOrAbort
2537 };
2538 match move_items_with_progress(&from_paths, &path_to, &options, func_test) {
2539 Ok(_) => panic!("Should be a error!"),
2540 Err(err) => {
2541 match err.kind {
2542 ErrorKind::AlreadyExists => {}
2543 _ => panic!(format!("{}", err.to_string())),
2544 }
2545 }
2546 };
2547
2548
2549 }
2550
2551
2552 #[test]
it_move_with_progress_exist_skip_exist()2553 fn it_move_with_progress_exist_skip_exist() {
2554
2555 let test_dir = Path::new(TEST_FOLDER).join("it_move_with_progress_exist_skip_exist");
2556 let path_to = test_dir.join("out");
2557 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2558 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2559 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2560 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2561 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
2562 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
2563 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
2564 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
2565
2566 match dir::create_all(&path_to, true) {
2567 Ok(_) => {}
2568 Err(_) => {}
2569 };
2570
2571 dir::create_all(&dir1.0, true).unwrap();
2572 dir::create_all(&dir2.0, true).unwrap();
2573 dir::create_all(&sub.0, true).unwrap();
2574 dir::create_all(&sub.1, true).unwrap();
2575 dir::create_all(&dir2.1, true).unwrap();
2576
2577
2578 assert!(dir1.0.exists());
2579 assert!(dir1.1.exists());
2580 assert!(dir2.0.exists());
2581 assert!(dir2.1.exists());
2582 assert!(sub.0.exists());
2583 assert!(sub.1.exists());
2584
2585 file::write_all(&file1.0, "content1").unwrap();
2586 file::write_all(&file2.0, "content2").unwrap();
2587 file::write_all(&file3.0, "content3").unwrap();
2588 file::write_all(&file4.0, "content4").unwrap();
2589 file::write_all(&file5.0, "content5").unwrap();
2590
2591 file::write_all(&file1.1, "old content1").unwrap();
2592 file::write_all(&file3.1, "old content3").unwrap();
2593 file::write_all(&file4.1, "old content4").unwrap();
2594 file::write_all(&file5.1, "old content5").unwrap();
2595
2596 assert!(file1.0.exists());
2597 assert!(file2.0.exists());
2598 assert!(file3.0.exists());
2599 assert!(file4.0.exists());
2600 assert!(file5.0.exists());
2601 assert!(file1.1.exists());
2602 assert!(!file2.1.exists());
2603 assert!(file3.1.exists());
2604 assert!(file4.1.exists());
2605 assert!(file5.1.exists());
2606
2607
2608
2609 let mut options = dir::CopyOptions::new();
2610 options.skip_exist = true;
2611 options.overwrite = false;
2612 let (tx, rx) = mpsc::channel();
2613 let result = thread::spawn(move || {
2614 let mut from_paths = Vec::new();
2615 from_paths.push(dir1.0.as_path());
2616 from_paths.push(dir2.0.as_path());
2617 from_paths.push(file1.0.as_path());
2618 from_paths.push(file2.0.as_path());
2619
2620 let func_test = |process_info: TransitProcess| {
2621 tx.send(process_info).unwrap();
2622 dir::TransitProcessResult::ContinueOrAbort
2623 };
2624 let result = move_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
2625
2626 assert_eq!(8, result);
2627 assert!(file1.0.exists());
2628 assert!(!file2.0.exists());
2629 assert!(file3.0.exists());
2630 assert!(file4.0.exists());
2631 assert!(file5.0.exists());
2632 assert!(file1.1.exists());
2633 assert!(file2.1.exists());
2634 assert!(file3.1.exists());
2635 assert!(file4.1.exists());
2636 assert!(file5.1.exists());
2637 assert!(!files_eq(&file1.0, &file1.1));
2638 }).join();
2639
2640 match result {
2641 Ok(_) => {}
2642 Err(err) => panic!(err),
2643 }
2644
2645 match rx.recv() {
2646 Err(_) => panic!("Errors should not be!"),
2647 _ => {}
2648
2649 }
2650
2651
2652 }
2653
2654 #[test]
it_move_with_progress_exist_overwrite_and_skip_exist()2655 fn it_move_with_progress_exist_overwrite_and_skip_exist() {
2656 let test_dir =
2657 Path::new(TEST_FOLDER).join("it_move_with_progress_exist_overwrite_and_skip_exist");
2658 let path_to = test_dir.join("out");
2659 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2660 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2661 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2662 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2663 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
2664 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
2665 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
2666 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
2667
2668 match dir::create_all(&path_to, true) {
2669 Ok(_) => {}
2670 Err(_) => {}
2671 };
2672
2673 dir::create_all(&dir1.0, true).unwrap();
2674 dir::create_all(&dir2.0, true).unwrap();
2675 dir::create_all(&sub.0, true).unwrap();
2676 dir::create_all(&sub.1, true).unwrap();
2677
2678
2679 assert!(dir1.0.exists());
2680 assert!(dir1.1.exists());
2681 assert!(dir2.0.exists());
2682 assert!(!dir2.1.exists());
2683 assert!(sub.0.exists());
2684 assert!(sub.1.exists());
2685
2686 file::write_all(&file1.0, "content1").unwrap();
2687 file::write_all(&file2.0, "content2").unwrap();
2688 file::write_all(&file3.0, "content3").unwrap();
2689 file::write_all(&file4.0, "content4").unwrap();
2690 file::write_all(&file5.0, "content5").unwrap();
2691
2692 file::write_all(&file1.1, "old content1").unwrap();
2693 file::write_all(&file3.1, "old content3").unwrap();
2694 file::write_all(&file4.1, "old content4").unwrap();
2695
2696 assert!(file1.0.exists());
2697 assert!(file2.0.exists());
2698 assert!(file3.0.exists());
2699 assert!(file4.0.exists());
2700 assert!(file5.0.exists());
2701 assert!(file1.1.exists());
2702 assert!(!file2.1.exists());
2703 assert!(file3.1.exists());
2704 assert!(file4.1.exists());
2705 assert!(!file5.1.exists());
2706
2707 let mut options = dir::CopyOptions::new();
2708 options.overwrite = true;
2709 options.skip_exist = true;
2710 let (tx, rx) = mpsc::channel();
2711 let result = thread::spawn(move || {
2712 let mut from_paths = Vec::new();
2713 from_paths.push(dir1.0.as_path());
2714 from_paths.push(dir2.0.as_path());
2715 from_paths.push(file1.0.as_path());
2716 from_paths.push(file2.0.as_path());
2717
2718 let func_test = |process_info: TransitProcess| {
2719 tx.send(process_info).unwrap();
2720 dir::TransitProcessResult::ContinueOrAbort
2721 };
2722 let result = move_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
2723
2724 assert_eq!(40, result);
2725 assert!(!file1.0.exists());
2726 assert!(!file2.0.exists());
2727 assert!(!file3.0.exists());
2728 assert!(!file4.0.exists());
2729 assert!(!file5.0.exists());
2730 assert!(file1.1.exists());
2731 assert!(file2.1.exists());
2732 assert!(file3.1.exists());
2733 assert!(file4.1.exists());
2734 assert!(file5.1.exists());
2735
2736 }).join();
2737
2738 match result {
2739 Ok(_) => {}
2740 Err(err) => panic!(err),
2741 }
2742
2743 match rx.recv() {
2744 Err(_) => panic!("Errors should not be!"),
2745 _ => {}
2746
2747 }
2748 }
2749
2750
2751
2752 #[test]
it_remove_work()2753 fn it_remove_work() {
2754
2755 let test_dir = Path::new(TEST_FOLDER).join("it_remove_work");
2756 let dir1 = test_dir.join("dir1");
2757 let dir2 = test_dir.join("dir2");
2758 let sub = dir1.join("sub");
2759 let file1 = test_dir.join("file1.txt");
2760 let file2 = test_dir.join("file2.txt");
2761 let file3 = dir1.join("file3.txt");
2762 let file4 = sub.join("file4.txt");
2763 let file5 = dir2.join("file5.txt");
2764
2765 dir::create_all(&dir1, true).unwrap();
2766 dir::create_all(&dir2, true).unwrap();
2767 dir::create_all(&sub, true).unwrap();
2768
2769 assert!(dir1.exists());
2770 assert!(dir2.exists());
2771 assert!(sub.exists());
2772
2773 file::write_all(&file1, "content1").unwrap();
2774 file::write_all(&file2, "content2").unwrap();
2775 file::write_all(&file3, "content3").unwrap();
2776 file::write_all(&file4, "content4").unwrap();
2777 file::write_all(&file5, "content5").unwrap();
2778
2779 assert!(file1.exists());
2780 assert!(file2.exists());
2781 assert!(file3.exists());
2782 assert!(file4.exists());
2783 assert!(file5.exists());
2784
2785 let mut from_paths = Vec::new();
2786 from_paths.push(dir1.as_path());
2787 from_paths.push(dir2.as_path());
2788 from_paths.push(file1.as_path());
2789 from_paths.push(file2.as_path());
2790
2791 remove_items(&from_paths).unwrap();
2792 assert!(!file1.exists());
2793 assert!(!file2.exists());
2794 assert!(!file3.exists());
2795 assert!(!file4.exists());
2796 assert!(!file5.exists());
2797
2798
2799 }
2800
2801
2802 #[test]
it_copy_with_progress_exist_user_decide_overwrite()2803 fn it_copy_with_progress_exist_user_decide_overwrite() {
2804 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_exist_user_decide_overwrite");
2805 let path_to = test_dir.join("out");
2806 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2807 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2808 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2809 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2810 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
2811 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
2812 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
2813 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
2814
2815
2816 dir::create_all(&dir1.0, true).unwrap();
2817 dir::create_all(&dir1.1, true).unwrap();
2818 dir::create_all(&dir2.0, true).unwrap();
2819 dir::create_all(&dir2.1, true).unwrap();
2820 dir::create_all(&sub.0, true).unwrap();
2821 dir::create_all(&sub.1, true).unwrap();
2822
2823
2824 assert!(&dir1.0.exists());
2825 assert!(&dir1.1.exists());
2826 assert!(&dir2.0.exists());
2827 assert!(&dir2.1.exists());
2828 assert!(&sub.0.exists());
2829 assert!(&sub.1.exists());
2830
2831 fs_extra::file::write_all(&file1.0, "content1").unwrap();
2832 fs_extra::file::write_all(&file2.0, "content2").unwrap();
2833 fs_extra::file::write_all(&file3.0, "content3").unwrap();
2834 fs_extra::file::write_all(&file4.0, "content4").unwrap();
2835 fs_extra::file::write_all(&file5.0, "content5").unwrap();
2836
2837 fs_extra::file::write_all(&file1.1, "old content11").unwrap();
2838 fs_extra::file::write_all(&file2.1, "old content12").unwrap();
2839 fs_extra::file::write_all(&file3.1, "old content13").unwrap();
2840 fs_extra::file::write_all(&file4.1, "old content14").unwrap();
2841 fs_extra::file::write_all(&file5.1, "old content15").unwrap();
2842
2843 assert!(file1.0.exists());
2844 assert!(file2.0.exists());
2845 assert!(file3.0.exists());
2846 assert!(file4.0.exists());
2847 assert!(file5.0.exists());
2848 assert!(file1.1.exists());
2849 assert!(file2.1.exists());
2850 assert!(file3.1.exists());
2851 assert!(file4.1.exists());
2852 assert!(file5.1.exists());
2853
2854 let mut options = dir::CopyOptions::new();
2855 assert!(!compare_dir(&dir1.0, &dir1.1));
2856 assert!(!compare_dir(&dir2.0, &dir2.1));
2857 assert!(!files_eq(&file1.0, &file1.1));
2858 assert!(!files_eq(&file2.0, &file2.1));
2859 options.buffer_size = 1;
2860 let (tx, rx) = mpsc::channel();
2861 let result = thread::spawn(move || {
2862 let mut count_exist_files = 0;
2863 let mut from_paths = Vec::new();
2864 from_paths.push(dir1.0.as_path());
2865 from_paths.push(dir2.0.as_path());
2866 from_paths.push(file1.0.as_path());
2867 from_paths.push(file2.0.as_path());
2868
2869 let result: u64;
2870 {
2871 let func_test = |process_info: TransitProcess| {
2872 let result: dir::TransitProcessResult;
2873 match process_info.state {
2874 dir::TransitState::Exists => {
2875 count_exist_files += 1;
2876 result = dir::TransitProcessResult::Overwrite;
2877 tx.send(process_info).unwrap();
2878 }
2879 _ => result = dir::TransitProcessResult::Abort,
2880 };
2881 result
2882 };
2883
2884 result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
2885 }
2886 assert_eq!(5, count_exist_files);
2887
2888 assert_eq!(40, result);
2889 assert!(dir1.0.exists());
2890 assert!(dir1.1.exists());
2891 assert!(dir2.0.exists());
2892 assert!(dir2.1.exists());
2893 assert!(compare_dir(&dir1.0, &path_to));
2894 assert!(compare_dir(&dir2.0, &path_to));
2895 assert!(files_eq(&file1.0, &file1.1));
2896 assert!(files_eq(&file2.0, &file2.1));
2897
2898 }).join();
2899
2900
2901 match result {
2902 Ok(_) => {}
2903 Err(err) => panic!(err),
2904 }
2905 rx.try_recv().unwrap();
2906 }
2907
2908
2909 #[test]
it_copy_with_progress_exist_user_decide_overwrite_all()2910 fn it_copy_with_progress_exist_user_decide_overwrite_all() {
2911 let test_dir =
2912 Path::new(TEST_FOLDER).join("it_copy_with_progress_exist_user_decide_overwrite_all");
2913 let path_to = test_dir.join("out");
2914 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
2915 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
2916 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
2917 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
2918 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
2919 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
2920 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
2921 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
2922
2923
2924 dir::create_all(&dir1.0, true).unwrap();
2925 dir::create_all(&dir1.1, true).unwrap();
2926 dir::create_all(&dir2.0, true).unwrap();
2927 dir::create_all(&dir2.1, true).unwrap();
2928 dir::create_all(&sub.0, true).unwrap();
2929 dir::create_all(&sub.1, true).unwrap();
2930
2931
2932 assert!(&dir1.0.exists());
2933 assert!(&dir1.1.exists());
2934 assert!(&dir2.0.exists());
2935 assert!(&dir2.1.exists());
2936 assert!(&sub.0.exists());
2937 assert!(&sub.1.exists());
2938
2939 fs_extra::file::write_all(&file1.0, "content1").unwrap();
2940 fs_extra::file::write_all(&file2.0, "content2").unwrap();
2941 fs_extra::file::write_all(&file3.0, "content3").unwrap();
2942 fs_extra::file::write_all(&file4.0, "content4").unwrap();
2943 fs_extra::file::write_all(&file5.0, "content5").unwrap();
2944
2945 fs_extra::file::write_all(&file1.1, "old content11").unwrap();
2946 fs_extra::file::write_all(&file2.1, "old content12").unwrap();
2947 fs_extra::file::write_all(&file3.1, "old content13").unwrap();
2948 fs_extra::file::write_all(&file4.1, "old content14").unwrap();
2949 fs_extra::file::write_all(&file5.1, "old content15").unwrap();
2950
2951 assert!(file1.0.exists());
2952 assert!(file2.0.exists());
2953 assert!(file3.0.exists());
2954 assert!(file4.0.exists());
2955 assert!(file5.0.exists());
2956 assert!(file1.1.exists());
2957 assert!(file2.1.exists());
2958 assert!(file3.1.exists());
2959 assert!(file4.1.exists());
2960 assert!(file5.1.exists());
2961
2962 let mut options = dir::CopyOptions::new();
2963 assert!(!compare_dir(&dir1.0, &dir1.1));
2964 assert!(!compare_dir(&dir2.0, &dir2.1));
2965 assert!(!files_eq(&file1.0, &file1.1));
2966 assert!(!files_eq(&file2.0, &file2.1));
2967 options.buffer_size = 1;
2968 let (tx, rx) = mpsc::channel();
2969 let result = thread::spawn(move || {
2970 let mut count_exist_files = 0;
2971 let mut from_paths = Vec::new();
2972 from_paths.push(dir1.0.as_path());
2973 from_paths.push(dir2.0.as_path());
2974 from_paths.push(file1.0.as_path());
2975 from_paths.push(file2.0.as_path());
2976
2977 let result: u64;
2978 {
2979 let func_test = |process_info: TransitProcess| {
2980 let result: dir::TransitProcessResult;
2981 match process_info.state {
2982 dir::TransitState::Exists => {
2983 count_exist_files += 1;
2984 result = dir::TransitProcessResult::OverwriteAll;
2985 tx.send(process_info).unwrap();
2986 }
2987 _ => result = dir::TransitProcessResult::Abort,
2988 };
2989 result
2990 };
2991
2992 result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
2993 }
2994 assert_eq!(1, count_exist_files);
2995
2996 assert_eq!(40, result);
2997 assert!(dir1.0.exists());
2998 assert!(dir1.1.exists());
2999 assert!(dir2.0.exists());
3000 assert!(dir2.1.exists());
3001 assert!(compare_dir(&dir1.0, &path_to));
3002 assert!(compare_dir(&dir2.0, &path_to));
3003 assert!(files_eq(&file1.0, &file1.1));
3004 assert!(files_eq(&file2.0, &file2.1));
3005
3006 }).join();
3007
3008
3009 match result {
3010 Ok(_) => {}
3011 Err(err) => panic!(err),
3012 }
3013 rx.try_recv().unwrap();
3014 }
3015
3016 #[test]
it_copy_with_progress_exist_user_decide_skip()3017 fn it_copy_with_progress_exist_user_decide_skip() {
3018 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_exist_user_decide_skip");
3019 let path_to = test_dir.join("out");
3020 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
3021 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
3022 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
3023 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
3024 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
3025 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
3026 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
3027 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
3028
3029
3030 dir::create_all(&dir1.0, true).unwrap();
3031 dir::create_all(&dir1.1, true).unwrap();
3032 dir::create_all(&dir2.0, true).unwrap();
3033 dir::create_all(&dir2.1, true).unwrap();
3034 dir::create_all(&sub.0, true).unwrap();
3035 dir::create_all(&sub.1, true).unwrap();
3036
3037
3038 assert!(&dir1.0.exists());
3039 assert!(&dir1.1.exists());
3040 assert!(&dir2.0.exists());
3041 assert!(&dir2.1.exists());
3042 assert!(&sub.0.exists());
3043 assert!(&sub.1.exists());
3044
3045 fs_extra::file::write_all(&file1.0, "content1").unwrap();
3046 fs_extra::file::write_all(&file2.0, "content2").unwrap();
3047 fs_extra::file::write_all(&file3.0, "content3").unwrap();
3048 fs_extra::file::write_all(&file4.0, "content4").unwrap();
3049 fs_extra::file::write_all(&file5.0, "content5").unwrap();
3050
3051 fs_extra::file::write_all(&file1.1, "old content11").unwrap();
3052 fs_extra::file::write_all(&file2.1, "old content12").unwrap();
3053 fs_extra::file::write_all(&file3.1, "old content13").unwrap();
3054 fs_extra::file::write_all(&file4.1, "old content14").unwrap();
3055 fs_extra::file::write_all(&file5.1, "old content15").unwrap();
3056
3057 assert!(file1.0.exists());
3058 assert!(file2.0.exists());
3059 assert!(file3.0.exists());
3060 assert!(file4.0.exists());
3061 assert!(file5.0.exists());
3062 assert!(file1.1.exists());
3063 assert!(file2.1.exists());
3064 assert!(file3.1.exists());
3065 assert!(file4.1.exists());
3066 assert!(file5.1.exists());
3067
3068 let mut options = dir::CopyOptions::new();
3069 assert!(!compare_dir(&dir1.0, &dir1.1));
3070 assert!(!compare_dir(&dir2.0, &dir2.1));
3071 assert!(!files_eq(&file1.0, &file1.1));
3072 assert!(!files_eq(&file2.0, &file2.1));
3073 options.buffer_size = 1;
3074 let (tx, rx) = mpsc::channel();
3075 let result = thread::spawn(move || {
3076 let mut count_exist_files = 0;
3077 let mut from_paths = Vec::new();
3078 from_paths.push(dir1.0.as_path());
3079 from_paths.push(dir2.0.as_path());
3080 from_paths.push(file1.0.as_path());
3081 from_paths.push(file2.0.as_path());
3082
3083 let result: u64;
3084 {
3085 let func_test = |process_info: TransitProcess| {
3086 let result: dir::TransitProcessResult;
3087 match process_info.state {
3088 dir::TransitState::Exists => {
3089 count_exist_files += 1;
3090 result = dir::TransitProcessResult::Skip;
3091 tx.send(process_info).unwrap();
3092 }
3093 _ => result = dir::TransitProcessResult::Abort,
3094 };
3095 result
3096 };
3097
3098 result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
3099 }
3100 assert_eq!(5, count_exist_files);
3101
3102 assert_eq!(0, result);
3103 assert!(dir1.0.exists());
3104 assert!(dir1.1.exists());
3105 assert!(dir2.0.exists());
3106 assert!(dir2.1.exists());
3107 assert!(!compare_dir(&dir1.0, &path_to));
3108 assert!(!compare_dir(&dir2.0, &path_to));
3109 assert!(!files_eq(&file1.0, &file1.1));
3110 assert!(!files_eq(&file2.0, &file2.1));
3111
3112 }).join();
3113
3114
3115 match result {
3116 Ok(_) => {}
3117 Err(err) => panic!(err),
3118 }
3119 rx.try_recv().unwrap();
3120 }
3121
3122 #[test]
it_copy_with_progress_exist_user_decide_skip_all()3123 fn it_copy_with_progress_exist_user_decide_skip_all() {
3124 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_exist_user_decide_skip_all");
3125 let path_to = test_dir.join("out");
3126 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
3127 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
3128 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
3129 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
3130 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
3131 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
3132 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
3133 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
3134
3135
3136 dir::create_all(&dir1.0, true).unwrap();
3137 dir::create_all(&dir1.1, true).unwrap();
3138 dir::create_all(&dir2.0, true).unwrap();
3139 dir::create_all(&dir2.1, true).unwrap();
3140 dir::create_all(&sub.0, true).unwrap();
3141 dir::create_all(&sub.1, true).unwrap();
3142
3143
3144 assert!(&dir1.0.exists());
3145 assert!(&dir1.1.exists());
3146 assert!(&dir2.0.exists());
3147 assert!(&dir2.1.exists());
3148 assert!(&sub.0.exists());
3149 assert!(&sub.1.exists());
3150
3151 fs_extra::file::write_all(&file1.0, "content1").unwrap();
3152 fs_extra::file::write_all(&file2.0, "content2").unwrap();
3153 fs_extra::file::write_all(&file3.0, "content3").unwrap();
3154 fs_extra::file::write_all(&file4.0, "content4").unwrap();
3155 fs_extra::file::write_all(&file5.0, "content5").unwrap();
3156
3157 fs_extra::file::write_all(&file1.1, "old content11").unwrap();
3158 fs_extra::file::write_all(&file2.1, "old content12").unwrap();
3159 fs_extra::file::write_all(&file3.1, "old content13").unwrap();
3160 fs_extra::file::write_all(&file4.1, "old content14").unwrap();
3161 fs_extra::file::write_all(&file5.1, "old content15").unwrap();
3162
3163 assert!(file1.0.exists());
3164 assert!(file2.0.exists());
3165 assert!(file3.0.exists());
3166 assert!(file4.0.exists());
3167 assert!(file5.0.exists());
3168 assert!(file1.1.exists());
3169 assert!(file2.1.exists());
3170 assert!(file3.1.exists());
3171 assert!(file4.1.exists());
3172 assert!(file5.1.exists());
3173
3174 let mut options = dir::CopyOptions::new();
3175 assert!(!compare_dir(&dir1.0, &dir1.1));
3176 assert!(!compare_dir(&dir2.0, &dir2.1));
3177 assert!(!files_eq(&file1.0, &file1.1));
3178 assert!(!files_eq(&file2.0, &file2.1));
3179 options.buffer_size = 1;
3180 let (tx, rx) = mpsc::channel();
3181 let result = thread::spawn(move || {
3182 let mut count_exist_files = 0;
3183 let mut from_paths = Vec::new();
3184 from_paths.push(dir1.0.as_path());
3185 from_paths.push(dir2.0.as_path());
3186 from_paths.push(file1.0.as_path());
3187 from_paths.push(file2.0.as_path());
3188
3189 let result: u64;
3190 {
3191 let func_test = |process_info: TransitProcess| {
3192 let result: dir::TransitProcessResult;
3193 match process_info.state {
3194 dir::TransitState::Exists => {
3195 count_exist_files += 1;
3196 result = dir::TransitProcessResult::SkipAll;
3197 tx.send(process_info).unwrap();
3198 }
3199 _ => result = dir::TransitProcessResult::Abort,
3200 };
3201 result
3202 };
3203
3204 result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
3205 }
3206 assert_eq!(1, count_exist_files);
3207
3208 assert_eq!(0, result);
3209 assert!(dir1.0.exists());
3210 assert!(dir1.1.exists());
3211 assert!(dir2.0.exists());
3212 assert!(dir2.1.exists());
3213 assert!(!compare_dir(&dir1.0, &path_to));
3214 assert!(!compare_dir(&dir2.0, &path_to));
3215 assert!(!files_eq(&file1.0, &file1.1));
3216 assert!(!files_eq(&file2.0, &file2.1));
3217
3218 }).join();
3219
3220
3221 match result {
3222 Ok(_) => {}
3223 Err(err) => panic!(err),
3224 }
3225 rx.try_recv().unwrap();
3226 }
3227
3228 #[test]
it_copy_with_progress_exist_user_decide_retry()3229 fn it_copy_with_progress_exist_user_decide_retry() {
3230 let test_dir = Path::new(TEST_FOLDER).join("it_copy_with_progress_exist_user_decide_retry");
3231 let path_to = test_dir.join("out");
3232 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
3233 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
3234 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
3235 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
3236 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
3237 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
3238 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
3239 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
3240
3241
3242 dir::create_all(&dir1.0, true).unwrap();
3243 dir::create_all(&dir1.1, true).unwrap();
3244 dir::create_all(&dir2.0, true).unwrap();
3245 dir::create_all(&dir2.1, true).unwrap();
3246 dir::create_all(&sub.0, true).unwrap();
3247 dir::create_all(&sub.1, true).unwrap();
3248
3249
3250 assert!(&dir1.0.exists());
3251 assert!(&dir1.1.exists());
3252 assert!(&dir2.0.exists());
3253 assert!(&dir2.1.exists());
3254 assert!(&sub.0.exists());
3255 assert!(&sub.1.exists());
3256
3257 fs_extra::file::write_all(&file1.0, "content1").unwrap();
3258 fs_extra::file::write_all(&file2.0, "content2").unwrap();
3259 fs_extra::file::write_all(&file3.0, "content3").unwrap();
3260 fs_extra::file::write_all(&file4.0, "content4").unwrap();
3261 fs_extra::file::write_all(&file5.0, "content5").unwrap();
3262
3263 fs_extra::file::write_all(&file1.1, "old content11").unwrap();
3264 fs_extra::file::write_all(&file2.1, "old content12").unwrap();
3265 fs_extra::file::write_all(&file3.1, "old content13").unwrap();
3266 fs_extra::file::write_all(&file4.1, "old content14").unwrap();
3267 fs_extra::file::write_all(&file5.1, "old content15").unwrap();
3268
3269 assert!(file1.0.exists());
3270 assert!(file2.0.exists());
3271 assert!(file3.0.exists());
3272 assert!(file4.0.exists());
3273 assert!(file5.0.exists());
3274 assert!(file1.1.exists());
3275 assert!(file2.1.exists());
3276 assert!(file3.1.exists());
3277 assert!(file4.1.exists());
3278 assert!(file5.1.exists());
3279
3280 let mut options = dir::CopyOptions::new();
3281 assert!(!compare_dir(&dir1.0, &dir1.1));
3282 assert!(!compare_dir(&dir2.0, &dir2.1));
3283 assert!(!files_eq(&file1.0, &file1.1));
3284 assert!(!files_eq(&file2.0, &file2.1));
3285 options.buffer_size = 1;
3286 let (tx, rx) = mpsc::channel();
3287 let result = thread::spawn(move || {
3288 let mut count_exist_files = 0;
3289 let mut from_paths = Vec::new();
3290 from_paths.push(dir1.0.as_path());
3291 from_paths.push(dir2.0.as_path());
3292 from_paths.push(file1.0.as_path());
3293 from_paths.push(file2.0.as_path());
3294
3295 let result: u64;
3296 {
3297 let func_test = |process_info: TransitProcess| {
3298 let result: dir::TransitProcessResult;
3299 match process_info.state {
3300 dir::TransitState::Exists => {
3301 if count_exist_files == 3 || count_exist_files > 6 {
3302 result = dir::TransitProcessResult::Skip;
3303 } else {
3304 result = dir::TransitProcessResult::Retry;
3305 }
3306
3307 count_exist_files += 1;
3308 tx.send(process_info).unwrap();
3309 }
3310 _ => result = dir::TransitProcessResult::Abort,
3311 };
3312 result
3313 };
3314
3315 result = copy_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
3316 }
3317 assert_eq!(11, count_exist_files);
3318
3319 assert_eq!(0, result);
3320 assert!(dir1.0.exists());
3321 assert!(dir1.1.exists());
3322 assert!(dir2.0.exists());
3323 assert!(dir2.1.exists());
3324 assert!(!compare_dir(&dir1.0, &path_to));
3325 assert!(!compare_dir(&dir2.0, &path_to));
3326 assert!(!files_eq(&file1.0, &file1.1));
3327 assert!(!files_eq(&file2.0, &file2.1));
3328
3329 }).join();
3330
3331
3332 match result {
3333 Ok(_) => {}
3334 Err(err) => panic!(err),
3335 }
3336 rx.try_recv().unwrap();
3337 }
3338
3339
3340
3341
3342
3343 #[test]
it_move_with_progress_exist_user_decide_overwrite()3344 fn it_move_with_progress_exist_user_decide_overwrite() {
3345 let test_dir = Path::new(TEST_FOLDER).join("it_move_with_progress_exist_user_decide_overwrite");
3346 let path_to = test_dir.join("out");
3347 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
3348 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
3349 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
3350 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
3351 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
3352 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
3353 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
3354 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
3355
3356
3357 dir::create_all(&dir1.0, true).unwrap();
3358 dir::create_all(&dir1.1, true).unwrap();
3359 dir::create_all(&dir2.0, true).unwrap();
3360 dir::create_all(&dir2.1, true).unwrap();
3361 dir::create_all(&sub.0, true).unwrap();
3362 dir::create_all(&sub.1, true).unwrap();
3363
3364
3365 assert!(&dir1.0.exists());
3366 assert!(&dir1.1.exists());
3367 assert!(&dir2.0.exists());
3368 assert!(&dir2.1.exists());
3369 assert!(&sub.0.exists());
3370 assert!(&sub.1.exists());
3371
3372 fs_extra::file::write_all(&file1.0, "content1").unwrap();
3373 fs_extra::file::write_all(&file2.0, "content2").unwrap();
3374 fs_extra::file::write_all(&file3.0, "content3").unwrap();
3375 fs_extra::file::write_all(&file4.0, "content4").unwrap();
3376 fs_extra::file::write_all(&file5.0, "content5").unwrap();
3377
3378 fs_extra::file::write_all(&file1.1, "old content11").unwrap();
3379 fs_extra::file::write_all(&file2.1, "old content12").unwrap();
3380 fs_extra::file::write_all(&file3.1, "old content13").unwrap();
3381 fs_extra::file::write_all(&file4.1, "old content14").unwrap();
3382 fs_extra::file::write_all(&file5.1, "old content15").unwrap();
3383
3384 assert!(file1.0.exists());
3385 assert!(file2.0.exists());
3386 assert!(file3.0.exists());
3387 assert!(file4.0.exists());
3388 assert!(file5.0.exists());
3389 assert!(file1.1.exists());
3390 assert!(file2.1.exists());
3391 assert!(file3.1.exists());
3392 assert!(file4.1.exists());
3393 assert!(file5.1.exists());
3394
3395 let mut options = dir::CopyOptions::new();
3396 assert!(!compare_dir(&dir1.0, &dir1.1));
3397 assert!(!compare_dir(&dir2.0, &dir2.1));
3398 assert!(!files_eq(&file1.0, &file1.1));
3399 assert!(!files_eq(&file2.0, &file2.1));
3400 options.buffer_size = 1;
3401 let (tx, rx) = mpsc::channel();
3402 let result = thread::spawn(move || {
3403 let mut count_exist_files = 0;
3404 let mut from_paths = Vec::new();
3405 from_paths.push(dir1.0.as_path());
3406 from_paths.push(dir2.0.as_path());
3407 from_paths.push(file1.0.as_path());
3408 from_paths.push(file2.0.as_path());
3409
3410 let result: u64;
3411 {
3412 let func_test = |process_info: TransitProcess| {
3413 let result: dir::TransitProcessResult;
3414 match process_info.state {
3415 dir::TransitState::Exists => {
3416 count_exist_files += 1;
3417 result = dir::TransitProcessResult::Overwrite;
3418 tx.send(process_info).unwrap();
3419 }
3420 _ => result = dir::TransitProcessResult::Abort,
3421 };
3422 result
3423 };
3424
3425 result = move_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
3426 }
3427 assert_eq!(5, count_exist_files);
3428
3429 assert_eq!(40, result);
3430 assert!(!dir1.0.exists());
3431 assert!(!dir2.0.exists());
3432 assert!(dir1.1.exists());
3433 assert!(dir2.1.exists());
3434
3435 }).join();
3436
3437
3438 match result {
3439 Ok(_) => {}
3440 Err(err) => panic!(err),
3441 }
3442 rx.try_recv().unwrap();
3443 }
3444
3445
3446 #[test]
it_move_with_progress_exist_user_decide_overwrite_all()3447 fn it_move_with_progress_exist_user_decide_overwrite_all() {
3448 let test_dir =
3449 Path::new(TEST_FOLDER).join("it_move_with_progress_exist_user_decide_overwrite_all");
3450 let path_to = test_dir.join("out");
3451 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
3452 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
3453 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
3454 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
3455 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
3456 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
3457 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
3458 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
3459
3460
3461 dir::create_all(&dir1.0, true).unwrap();
3462 dir::create_all(&dir1.1, true).unwrap();
3463 dir::create_all(&dir2.0, true).unwrap();
3464 dir::create_all(&dir2.1, true).unwrap();
3465 dir::create_all(&sub.0, true).unwrap();
3466 dir::create_all(&sub.1, true).unwrap();
3467
3468
3469 assert!(&dir1.0.exists());
3470 assert!(&dir1.1.exists());
3471 assert!(&dir2.0.exists());
3472 assert!(&dir2.1.exists());
3473 assert!(&sub.0.exists());
3474 assert!(&sub.1.exists());
3475
3476 fs_extra::file::write_all(&file1.0, "content1").unwrap();
3477 fs_extra::file::write_all(&file2.0, "content2").unwrap();
3478 fs_extra::file::write_all(&file3.0, "content3").unwrap();
3479 fs_extra::file::write_all(&file4.0, "content4").unwrap();
3480 fs_extra::file::write_all(&file5.0, "content5").unwrap();
3481
3482 fs_extra::file::write_all(&file1.1, "old content11").unwrap();
3483 fs_extra::file::write_all(&file2.1, "old content12").unwrap();
3484 fs_extra::file::write_all(&file3.1, "old content13").unwrap();
3485 fs_extra::file::write_all(&file4.1, "old content14").unwrap();
3486 fs_extra::file::write_all(&file5.1, "old content15").unwrap();
3487
3488 assert!(file1.0.exists());
3489 assert!(file2.0.exists());
3490 assert!(file3.0.exists());
3491 assert!(file4.0.exists());
3492 assert!(file5.0.exists());
3493 assert!(file1.1.exists());
3494 assert!(file2.1.exists());
3495 assert!(file3.1.exists());
3496 assert!(file4.1.exists());
3497 assert!(file5.1.exists());
3498
3499 let mut options = dir::CopyOptions::new();
3500 assert!(!compare_dir(&dir1.0, &dir1.1));
3501 assert!(!compare_dir(&dir2.0, &dir2.1));
3502 assert!(!files_eq(&file1.0, &file1.1));
3503 assert!(!files_eq(&file2.0, &file2.1));
3504 options.buffer_size = 1;
3505 let (tx, rx) = mpsc::channel();
3506 let result = thread::spawn(move || {
3507 let mut count_exist_files = 0;
3508 let mut from_paths = Vec::new();
3509 from_paths.push(dir1.0.as_path());
3510 from_paths.push(dir2.0.as_path());
3511 from_paths.push(file1.0.as_path());
3512 from_paths.push(file2.0.as_path());
3513
3514 let result: u64;
3515 {
3516 let func_test = |process_info: TransitProcess| {
3517 let result: dir::TransitProcessResult;
3518 match process_info.state {
3519 dir::TransitState::Exists => {
3520 count_exist_files += 1;
3521 result = dir::TransitProcessResult::OverwriteAll;
3522 tx.send(process_info).unwrap();
3523 }
3524 _ => result = dir::TransitProcessResult::Abort,
3525 };
3526 result
3527 };
3528
3529 result = move_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
3530 }
3531 assert_eq!(1, count_exist_files);
3532
3533 assert_eq!(40, result);
3534 assert!(!dir1.0.exists());
3535 assert!(!dir2.0.exists());
3536 assert!(dir1.1.exists());
3537 assert!(dir2.1.exists());
3538
3539 }).join();
3540
3541
3542 match result {
3543 Ok(_) => {}
3544 Err(err) => panic!(err),
3545 }
3546 rx.try_recv().unwrap();
3547 }
3548
3549 #[test]
it_move_with_progress_exist_user_decide_skip()3550 fn it_move_with_progress_exist_user_decide_skip() {
3551 let test_dir = Path::new(TEST_FOLDER).join("it_move_with_progress_exist_user_decide_skip");
3552 let path_to = test_dir.join("out");
3553 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
3554 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
3555 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
3556 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
3557 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
3558 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
3559 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
3560 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
3561
3562
3563 dir::create_all(&dir1.0, true).unwrap();
3564 dir::create_all(&dir1.1, true).unwrap();
3565 dir::create_all(&dir2.0, true).unwrap();
3566 dir::create_all(&dir2.1, true).unwrap();
3567 dir::create_all(&sub.0, true).unwrap();
3568 dir::create_all(&sub.1, true).unwrap();
3569
3570
3571 assert!(&dir1.0.exists());
3572 assert!(&dir1.1.exists());
3573 assert!(&dir2.0.exists());
3574 assert!(&dir2.1.exists());
3575 assert!(&sub.0.exists());
3576 assert!(&sub.1.exists());
3577
3578 fs_extra::file::write_all(&file1.0, "content1").unwrap();
3579 fs_extra::file::write_all(&file2.0, "content2").unwrap();
3580 fs_extra::file::write_all(&file3.0, "content3").unwrap();
3581 fs_extra::file::write_all(&file4.0, "content4").unwrap();
3582 fs_extra::file::write_all(&file5.0, "content5").unwrap();
3583
3584 fs_extra::file::write_all(&file1.1, "old content11").unwrap();
3585 fs_extra::file::write_all(&file2.1, "old content12").unwrap();
3586 fs_extra::file::write_all(&file3.1, "old content13").unwrap();
3587 fs_extra::file::write_all(&file4.1, "old content14").unwrap();
3588 fs_extra::file::write_all(&file5.1, "old content15").unwrap();
3589
3590 assert!(file1.0.exists());
3591 assert!(file2.0.exists());
3592 assert!(file3.0.exists());
3593 assert!(file4.0.exists());
3594 assert!(file5.0.exists());
3595 assert!(file1.1.exists());
3596 assert!(file2.1.exists());
3597 assert!(file3.1.exists());
3598 assert!(file4.1.exists());
3599 assert!(file5.1.exists());
3600
3601 let mut options = dir::CopyOptions::new();
3602 assert!(!compare_dir(&dir1.0, &dir1.1));
3603 assert!(!compare_dir(&dir2.0, &dir2.1));
3604 assert!(!files_eq(&file1.0, &file1.1));
3605 assert!(!files_eq(&file2.0, &file2.1));
3606 options.buffer_size = 1;
3607 let (tx, rx) = mpsc::channel();
3608 let result = thread::spawn(move || {
3609 let mut count_exist_files = 0;
3610 let mut from_paths = Vec::new();
3611 from_paths.push(dir1.0.as_path());
3612 from_paths.push(dir2.0.as_path());
3613 from_paths.push(file1.0.as_path());
3614 from_paths.push(file2.0.as_path());
3615
3616 let result: u64;
3617 {
3618 let func_test = |process_info: TransitProcess| {
3619 let result: dir::TransitProcessResult;
3620 match process_info.state {
3621 dir::TransitState::Exists => {
3622 count_exist_files += 1;
3623 result = dir::TransitProcessResult::Skip;
3624 tx.send(process_info).unwrap();
3625 }
3626 _ => result = dir::TransitProcessResult::Abort,
3627 };
3628 result
3629 };
3630
3631 result = move_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
3632 }
3633 assert_eq!(5, count_exist_files);
3634
3635 assert_eq!(0, result);
3636 assert!(dir1.0.exists());
3637 assert!(dir2.0.exists());
3638 assert!(dir1.1.exists());
3639 assert!(dir2.1.exists());
3640
3641 }).join();
3642
3643
3644 match result {
3645 Ok(_) => {}
3646 Err(err) => panic!(err),
3647 }
3648 rx.try_recv().unwrap();
3649 }
3650
3651 #[test]
it_move_with_progress_exist_user_decide_skip_all()3652 fn it_move_with_progress_exist_user_decide_skip_all() {
3653 let test_dir = Path::new(TEST_FOLDER).join("it_move_with_progress_exist_user_decide_skip_all");
3654 let path_to = test_dir.join("out");
3655 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
3656 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
3657 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
3658 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
3659 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
3660 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
3661 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
3662 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
3663
3664
3665 dir::create_all(&dir1.0, true).unwrap();
3666 dir::create_all(&dir1.1, true).unwrap();
3667 dir::create_all(&dir2.0, true).unwrap();
3668 dir::create_all(&dir2.1, true).unwrap();
3669 dir::create_all(&sub.0, true).unwrap();
3670 dir::create_all(&sub.1, true).unwrap();
3671
3672
3673 assert!(&dir1.0.exists());
3674 assert!(&dir1.1.exists());
3675 assert!(&dir2.0.exists());
3676 assert!(&dir2.1.exists());
3677 assert!(&sub.0.exists());
3678 assert!(&sub.1.exists());
3679
3680 fs_extra::file::write_all(&file1.0, "content1").unwrap();
3681 fs_extra::file::write_all(&file2.0, "content2").unwrap();
3682 fs_extra::file::write_all(&file3.0, "content3").unwrap();
3683 fs_extra::file::write_all(&file4.0, "content4").unwrap();
3684 fs_extra::file::write_all(&file5.0, "content5").unwrap();
3685
3686 fs_extra::file::write_all(&file1.1, "old content11").unwrap();
3687 fs_extra::file::write_all(&file2.1, "old content12").unwrap();
3688 fs_extra::file::write_all(&file3.1, "old content13").unwrap();
3689 fs_extra::file::write_all(&file4.1, "old content14").unwrap();
3690 fs_extra::file::write_all(&file5.1, "old content15").unwrap();
3691
3692 assert!(file1.0.exists());
3693 assert!(file2.0.exists());
3694 assert!(file3.0.exists());
3695 assert!(file4.0.exists());
3696 assert!(file5.0.exists());
3697 assert!(file1.1.exists());
3698 assert!(file2.1.exists());
3699 assert!(file3.1.exists());
3700 assert!(file4.1.exists());
3701 assert!(file5.1.exists());
3702
3703 let mut options = dir::CopyOptions::new();
3704 assert!(!compare_dir(&dir1.0, &dir1.1));
3705 assert!(!compare_dir(&dir2.0, &dir2.1));
3706 assert!(!files_eq(&file1.0, &file1.1));
3707 assert!(!files_eq(&file2.0, &file2.1));
3708 options.buffer_size = 1;
3709 let (tx, rx) = mpsc::channel();
3710 let result = thread::spawn(move || {
3711 let mut count_exist_files = 0;
3712 let mut from_paths = Vec::new();
3713 from_paths.push(dir1.0.as_path());
3714 from_paths.push(dir2.0.as_path());
3715 from_paths.push(file1.0.as_path());
3716 from_paths.push(file2.0.as_path());
3717
3718 let result: u64;
3719 {
3720 let func_test = |process_info: TransitProcess| {
3721 let result: dir::TransitProcessResult;
3722 match process_info.state {
3723 dir::TransitState::Exists => {
3724 count_exist_files += 1;
3725 result = dir::TransitProcessResult::SkipAll;
3726 tx.send(process_info).unwrap();
3727 }
3728 _ => result = dir::TransitProcessResult::Abort,
3729 };
3730 result
3731 };
3732
3733 result = move_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
3734 }
3735 assert_eq!(1, count_exist_files);
3736
3737 assert_eq!(0, result);
3738 assert!(dir1.0.exists());
3739 assert!(dir2.0.exists());
3740 assert!(dir1.1.exists());
3741 assert!(dir2.1.exists());
3742 assert!(file1.0.exists());
3743 assert!(file2.0.exists());
3744
3745 }).join();
3746
3747
3748 match result {
3749 Ok(_) => {}
3750 Err(err) => panic!(err),
3751 }
3752 rx.try_recv().unwrap();
3753 }
3754
3755 #[test]
it_move_with_progress_exist_user_decide_retry()3756 fn it_move_with_progress_exist_user_decide_retry() {
3757 let test_dir = Path::new(TEST_FOLDER).join("it_move_with_progress_exist_user_decide_retry");
3758 let path_to = test_dir.join("out");
3759 let dir1 = (test_dir.join("dir1"), path_to.join("dir1"));
3760 let dir2 = (test_dir.join("dir2"), path_to.join("dir2"));
3761 let sub = (dir1.0.join("sub"), dir1.1.join("sub"));
3762 let file1 = (test_dir.join("file1.txt"), path_to.join("file1.txt"));
3763 let file2 = (test_dir.join("file2.txt"), path_to.join("file2.txt"));
3764 let file3 = (dir1.0.join("file3.txt"), dir1.1.join("file3.txt"));
3765 let file4 = (sub.0.join("file4.txt"), sub.1.join("file4.txt"));
3766 let file5 = (dir2.0.join("file5.txt"), dir2.1.join("file5.txt"));
3767
3768
3769 dir::create_all(&dir1.0, true).unwrap();
3770 dir::create_all(&dir1.1, true).unwrap();
3771 dir::create_all(&dir2.0, true).unwrap();
3772 dir::create_all(&dir2.1, true).unwrap();
3773 dir::create_all(&sub.0, true).unwrap();
3774 dir::create_all(&sub.1, true).unwrap();
3775
3776
3777 assert!(&dir1.0.exists());
3778 assert!(&dir1.1.exists());
3779 assert!(&dir2.0.exists());
3780 assert!(&dir2.1.exists());
3781 assert!(&sub.0.exists());
3782 assert!(&sub.1.exists());
3783
3784 fs_extra::file::write_all(&file1.0, "content1").unwrap();
3785 fs_extra::file::write_all(&file2.0, "content2").unwrap();
3786 fs_extra::file::write_all(&file3.0, "content3").unwrap();
3787 fs_extra::file::write_all(&file4.0, "content4").unwrap();
3788 fs_extra::file::write_all(&file5.0, "content5").unwrap();
3789
3790 fs_extra::file::write_all(&file1.1, "old content11").unwrap();
3791 fs_extra::file::write_all(&file2.1, "old content12").unwrap();
3792 fs_extra::file::write_all(&file3.1, "old content13").unwrap();
3793 fs_extra::file::write_all(&file4.1, "old content14").unwrap();
3794 fs_extra::file::write_all(&file5.1, "old content15").unwrap();
3795
3796 assert!(file1.0.exists());
3797 assert!(file2.0.exists());
3798 assert!(file3.0.exists());
3799 assert!(file4.0.exists());
3800 assert!(file5.0.exists());
3801 assert!(file1.1.exists());
3802 assert!(file2.1.exists());
3803 assert!(file3.1.exists());
3804 assert!(file4.1.exists());
3805 assert!(file5.1.exists());
3806
3807 let mut options = dir::CopyOptions::new();
3808 assert!(!compare_dir(&dir1.0, &dir1.1));
3809 assert!(!compare_dir(&dir2.0, &dir2.1));
3810 assert!(!files_eq(&file1.0, &file1.1));
3811 assert!(!files_eq(&file2.0, &file2.1));
3812 options.buffer_size = 1;
3813 let (tx, rx) = mpsc::channel();
3814 let result = thread::spawn(move || {
3815 let mut count_exist_files = 0;
3816 let mut from_paths = Vec::new();
3817 from_paths.push(dir1.0.as_path());
3818 from_paths.push(dir2.0.as_path());
3819 from_paths.push(file1.0.as_path());
3820 from_paths.push(file2.0.as_path());
3821
3822 let result: u64;
3823 {
3824 let func_test = |process_info: TransitProcess| {
3825 let result: dir::TransitProcessResult;
3826 match process_info.state {
3827 dir::TransitState::Exists => {
3828 if count_exist_files == 3 || count_exist_files > 6 {
3829 result = dir::TransitProcessResult::Skip;
3830 } else {
3831 result = dir::TransitProcessResult::Retry;
3832 }
3833
3834 count_exist_files += 1;
3835 tx.send(process_info).unwrap();
3836 }
3837 _ => result = dir::TransitProcessResult::Abort,
3838 };
3839 result
3840 };
3841
3842 result = move_items_with_progress(&from_paths, &path_to, &options, func_test).unwrap();
3843 }
3844 assert_eq!(11, count_exist_files);
3845
3846 assert_eq!(0, result);
3847 assert!(dir1.0.exists());
3848 assert!(dir2.0.exists());
3849 assert!(dir1.1.exists());
3850 assert!(dir2.1.exists());
3851
3852 }).join();
3853
3854
3855 match result {
3856 Ok(_) => {}
3857 Err(err) => panic!(err),
3858 }
3859 rx.try_recv().unwrap();
3860 }
3861