Skip to content

Commit f494b5f

Browse files
qarminqarmin
committed
Test
1 parent 6d7bb78 commit f494b5f

1 file changed

Lines changed: 79 additions & 61 deletions

File tree

‎czkawka_core/src/common/dir_traversal.rs‎

Lines changed: 79 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -702,23 +702,23 @@ mod tests {
702702
const CONTENT: &[u8; 1] = b"a";
703703

704704
fn create_files(dir: &TempDir) -> io::Result<(PathBuf, PathBuf, PathBuf)> {
705-
let (src, hard, other) = (dir.path().join("a"), dir.path().join("b"), dir.path().join("c"));
705+
let (src, hard, other_file) = (dir.path().join("a"), dir.path().join("b"), dir.path().join("c"));
706706

707707
let mut file = File::create(&src)?;
708708
file.write_all(CONTENT)?;
709709
fs::hard_link(&src, &hard)?;
710710
file.set_modified(*NOW)?;
711711

712-
let mut file = File::create(&other)?;
712+
let mut file = File::create(&other_file)?;
713713
file.write_all(CONTENT)?;
714714
file.set_modified(*NOW)?;
715-
Ok((src, hard, other))
715+
Ok((src, hard, other_file))
716716
}
717717

718718
#[test]
719719
fn test_traversal() -> io::Result<()> {
720720
let dir = tempfile::Builder::new().tempdir()?;
721-
let (src, hard, other) = create_files(&dir)?;
721+
let (src, hard, other_file) = create_files(&dir)?;
722722
let secs = NOW.duration_since(SystemTime::UNIX_EPOCH).expect("Cannot fail calculating duration since epoch").as_secs();
723723

724724
let mut common_data = CommonToolData::new(ToolType::SimilarImages);
@@ -750,7 +750,7 @@ mod tests {
750750
modified_date: secs,
751751
},
752752
FileEntry {
753-
path: other,
753+
path: other_file,
754754
size: 1,
755755
modified_date: secs,
756756
},
@@ -766,87 +766,105 @@ mod tests {
766766
}
767767

768768
fn create_temp_structure(dir: &TempDir) -> io::Result<(PathBuf, PathBuf, PathBuf)> {
769-
let global = dir.path().join("global.txt");
770-
let other_dir = dir.path().join("other");
769+
let global_file = dir.path().join("global_file.txt");
770+
let other_dir = dir.path().join("other_file");
771771
fs::create_dir_all(&other_dir)?;
772-
let other = other_dir.join("other.txt");
772+
let other_file = other_dir.join("other_file.txt");
773773

774-
let mut f = File::create(&global)?;
775-
f.write_all(b"global")?;
774+
let mut f = File::create(&global_file)?;
775+
f.write_all(b"global_file")?;
776776
f.set_modified(*NOW)?;
777777

778-
let mut f2 = File::create(&other)?;
779-
f2.write_all(b"other")?;
778+
let mut f2 = File::create(&other_file)?;
779+
f2.write_all(b"other_file")?;
780780
f2.set_modified(*NOW)?;
781781

782-
Ok((global, other, other_dir))
782+
Ok((global_file, other_file, other_dir))
783783
}
784784

785-
#[test]
786-
fn test_traversal_with_and_without_excluded_dir() -> io::Result<()> {
787-
let dir = tempfile::Builder::new().tempdir()?;
788-
let (global, other, other_dir) = create_temp_structure(&dir)?;
789-
let secs = NOW.duration_since(SystemTime::UNIX_EPOCH).expect("Cannot fail calculating duration since epoch").as_secs();
790-
791-
let mut common_data = CommonToolData::new(ToolType::SimilarImages);
792-
common_data.directories.set_included_paths([dir.path().to_owned()].to_vec());
793-
common_data.set_minimal_file_size(0);
794-
785+
fn run_traversal(common_data: &CommonToolData) -> Vec<FileEntry> {
795786
match DirTraversalBuilder::new()
796787
.group_by(|_fe| ())
797788
.stop_flag(&Arc::default())
798-
.common_data(&common_data)
789+
.common_data(common_data)
799790
.build()
800791
.run()
801792
{
802793
DirTraversalResult::SuccessFiles { grouped_file_entries, .. } => {
803-
let actual: IndexSet<_> = grouped_file_entries.into_values().flatten().collect();
804-
assert_eq!(2, actual.len());
805-
assert!(actual.contains(&FileEntry { path: global.clone(), size: 6, modified_date: secs }));
806-
assert!(actual.contains(&FileEntry { path: other.clone(), size: 5, modified_date: secs }));
794+
grouped_file_entries.into_values().flatten().collect()
807795
}
808796
DirTraversalResult::Stopped => panic!("Expect SuccessFiles."),
809797
}
798+
}
810799

811-
let mut common_data2 = CommonToolData::new(ToolType::SimilarImages);
812-
common_data2.directories.set_included_paths([dir.path().to_owned()].to_vec());
813-
common_data2.directories.set_excluded_paths([other_dir.clone()].to_vec());
814-
common_data2.set_minimal_file_size(0);
800+
#[test]
801+
fn test_traversal_with_and_without_excluded_dir() -> io::Result<()> {
802+
let dir = tempfile::Builder::new().tempdir()?;
803+
let (global_file, other_file, other_dir) = create_temp_structure(&dir)?;
804+
let secs = NOW.duration_since(SystemTime::UNIX_EPOCH).expect("Cannot fail calculating duration since epoch").as_secs();
815805

816-
match DirTraversalBuilder::new()
817-
.group_by(|_fe| ())
818-
.stop_flag(&Arc::default())
819-
.common_data(&common_data2)
820-
.build()
821-
.run()
822-
{
823-
DirTraversalResult::SuccessFiles { grouped_file_entries, .. } => {
824-
let actual: IndexSet<_> = grouped_file_entries.into_values().flatten().collect();
825-
assert_eq!(1, actual.len());
826-
assert!(actual.contains(&FileEntry { path: global.clone(), size: 6, modified_date: secs }));
827-
}
828-
DirTraversalResult::Stopped => panic!("Expect SuccessFiles."),
829-
}
806+
let mut common_data = CommonToolData::new(ToolType::SimilarImages);
807+
common_data.directories.set_included_paths([dir.path().to_owned()].to_vec());
808+
common_data.set_minimal_file_size(0);
809+
810+
let actual: IndexSet<_> = run_traversal(&common_data).into_iter().collect();
811+
assert_eq!(2, actual.len());
812+
dbg!(&actual);
813+
assert!(actual.contains(&FileEntry { path: global_file.clone(), size: 11, modified_date: secs }));
814+
assert!(actual.contains(&FileEntry { path: other_file.clone(), size: 10, modified_date: secs }));
830815

831816
let mut common_data2 = CommonToolData::new(ToolType::SimilarImages);
832817
common_data2.directories.set_included_paths([dir.path().to_owned()].to_vec());
833-
common_data2.directories.set_excluded_paths([other.clone()].to_vec());
818+
common_data2.directories.set_excluded_paths([other_dir.clone()].to_vec());
834819
common_data2.set_minimal_file_size(0);
835820

836-
match DirTraversalBuilder::new()
837-
.group_by(|_fe| ())
838-
.stop_flag(&Arc::default())
839-
.common_data(&common_data2)
840-
.build()
841-
.run()
842-
{
843-
DirTraversalResult::SuccessFiles { grouped_file_entries, .. } => {
844-
let actual: IndexSet<_> = grouped_file_entries.into_values().flatten().collect();
845-
assert_eq!(1, actual.len());
846-
assert!(actual.contains(&FileEntry { path: global, size: 6, modified_date: secs }));
847-
}
848-
DirTraversalResult::Stopped => panic!("Expect SuccessFiles."),
849-
}
821+
let actual: IndexSet<_> = run_traversal(&common_data2).into_iter().collect();
822+
assert_eq!(1, actual.len());
823+
assert!(actual.contains(&FileEntry { path: global_file.clone(), size: 11, modified_date: secs }));
824+
825+
let mut common_data3 = CommonToolData::new(ToolType::SimilarImages);
826+
common_data3.directories.set_included_paths([dir.path().to_owned()].to_vec());
827+
common_data3.directories.set_excluded_paths([other_file.clone()].to_vec());
828+
common_data3.set_minimal_file_size(0);
829+
830+
let actual: IndexSet<_> = run_traversal(&common_data3).into_iter().collect();
831+
assert_eq!(1, actual.len());
832+
assert!(actual.contains(&FileEntry { path: global_file.clone(), size: 11, modified_date: secs }));
833+
834+
let mut common_data4 = CommonToolData::new(ToolType::SimilarImages);
835+
common_data4.directories.set_included_paths([global_file.clone()].to_vec());
836+
common_data4.set_minimal_file_size(0);
837+
838+
let actual: IndexSet<_> = run_traversal(&common_data4).into_iter().collect();
839+
assert_eq!(1, actual.len());
840+
assert!(actual.contains(&FileEntry { path: global_file.clone(), size: 11, modified_date: secs }));
841+
842+
let mut common_data5 = CommonToolData::new(ToolType::SimilarImages);
843+
common_data5.directories.set_included_paths([global_file.clone(), other_file.clone()].to_vec());
844+
common_data5.set_minimal_file_size(0);
845+
846+
let actual: IndexSet<_> = run_traversal(&common_data5).into_iter().collect();
847+
assert_eq!(2, actual.len());
848+
assert!(actual.contains(&FileEntry { path: global_file.clone(), size: 11, modified_date: secs }));
849+
assert!(actual.contains(&FileEntry { path: other_file.clone(), size: 10, modified_date: secs }));
850+
851+
let mut common_data6 = CommonToolData::new(ToolType::SimilarImages);
852+
common_data6.directories.set_included_paths([global_file.clone(), other_file.clone()].to_vec());
853+
common_data6.directories.set_excluded_paths([other_file.clone()].to_vec());
854+
common_data6.set_minimal_file_size(0);
855+
856+
let actual: IndexSet<_> = run_traversal(&common_data6).into_iter().collect();
857+
assert_eq!(1, actual.len());
858+
assert!(actual.contains(&FileEntry { path: global_file.clone(), size: 11, modified_date: secs }));
859+
860+
// This test is invalid - other dir should be removed by optimizer
861+
// let mut common_data7 = CommonToolData::new(ToolType::SimilarImages);
862+
// common_data7.directories.set_included_paths([other_file.clone()].to_vec());
863+
// common_data7.directories.set_excluded_paths([other_dir.clone()].to_vec());
864+
// common_data7.set_minimal_file_size(0);
865+
//
866+
// let actual: IndexSet<_> = run_traversal(&common_data7).into_iter().collect();
867+
// assert_eq!(0, actual.len());
850868

851869
Ok(())
852870
}

0 commit comments

Comments
 (0)