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