Merge pull request #6293 from cakebaker/cp_remove_panics_in_tests

cp: remove panics in tests
This commit is contained in:
Sylvestre Ledru 2024-04-30 17:25:18 +02:00 committed by GitHub
commit 1162c53f56
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -3402,29 +3402,23 @@ fn test_cp_archive_on_directory_ending_dot() {
#[test] #[test]
#[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))] #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
fn test_cp_debug_default() { fn test_cp_debug_default() {
#[cfg(target_os = "macos")]
let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
#[cfg(target_os = "linux")]
let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
#[cfg(windows)]
let expected = "copy offload: unsupported, reflink: unsupported, sparse detection: unsupported";
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let at = &ts.fixtures; let at = &ts.fixtures;
at.touch("a"); at.touch("a");
let result = ts.ucmd().arg("--debug").arg("a").arg("b").succeeds();
let stdout_str = result.stdout_str(); ts.ucmd()
#[cfg(target_os = "macos")] .arg("--debug")
if !stdout_str .arg("a")
.contains("copy offload: unknown, reflink: unsupported, sparse detection: unsupported") .arg("b")
{ .succeeds()
panic!("Failure: stdout was \n{stdout_str}"); .stdout_contains(expected);
}
#[cfg(target_os = "linux")]
if !stdout_str.contains("copy offload: unknown, reflink: unsupported, sparse detection: no") {
panic!("Failure: stdout was \n{stdout_str}");
}
#[cfg(windows)]
if !stdout_str
.contains("copy offload: unsupported, reflink: unsupported, sparse detection: unsupported")
{
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -3436,6 +3430,7 @@ fn test_cp_debug_multiple_default() {
at.touch("a"); at.touch("a");
at.touch("b"); at.touch("b");
at.mkdir(dir); at.mkdir(dir);
let result = ts let result = ts
.ucmd() .ucmd()
.arg("--debug") .arg("--debug")
@ -3444,62 +3439,15 @@ fn test_cp_debug_multiple_default() {
.arg(dir) .arg(dir)
.succeeds(); .succeeds();
let stdout_str = result.stdout_str();
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
{ let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
if !stdout_str
.contains("copy offload: unknown, reflink: unsupported, sparse detection: unsupported")
{
panic!("Failure: stdout was \n{stdout_str}");
}
// two files, two occurrences
assert_eq!(
result
.stdout_str()
.matches(
"copy offload: unknown, reflink: unsupported, sparse detection: unsupported"
)
.count(),
2
);
}
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
{ let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
if !stdout_str.contains("copy offload: unknown, reflink: unsupported, sparse detection: no") #[cfg(windows)]
{ let expected = "copy offload: unsupported, reflink: unsupported, sparse detection: unsupported";
panic!("Failure: stdout was \n{stdout_str}");
}
// two files, two occurrences // two files, two occurrences
assert_eq!( assert_eq!(result.stdout_str().matches(expected).count(), 2);
result
.stdout_str()
.matches("copy offload: unknown, reflink: unsupported, sparse detection: no")
.count(),
2
);
}
#[cfg(target_os = "windows")]
{
if !stdout_str.contains(
"copy offload: unsupported, reflink: unsupported, sparse detection: unsupported",
) {
panic!("Failure: stdout was \n{stdout_str}");
}
// two files, two occurrences
assert_eq!(
result
.stdout_str()
.matches("copy offload: unsupported, reflink: unsupported, sparse detection: unsupported")
.count(),
2
);
}
} }
#[test] #[test]
@ -3508,19 +3456,15 @@ fn test_cp_debug_sparse_reflink() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let at = &ts.fixtures; let at = &ts.fixtures;
at.touch("a"); at.touch("a");
let result = ts
.ucmd() ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--sparse=always") .arg("--sparse=always")
.arg("--reflink=never") .arg("--reflink=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: avoided, reflink: no, sparse detection: zeros");
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: zeros") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -3544,18 +3488,14 @@ fn test_cp_debug_sparse_always() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let at = &ts.fixtures; let at = &ts.fixtures;
at.touch("a"); at.touch("a");
let result = ts
.ucmd() ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--sparse=always") .arg("--sparse=always")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let stdout_str = result.stdout_str(); .stdout_contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros");
if !stdout_str.contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros")
{
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -3564,17 +3504,14 @@ fn test_cp_debug_sparse_never() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let at = &ts.fixtures; let at = &ts.fixtures;
at.touch("a"); at.touch("a");
let result = ts
.ucmd() ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--sparse=never") .arg("--sparse=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let stdout_str = result.stdout_str(); .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: no") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -3593,63 +3530,40 @@ fn test_cp_debug_sparse_auto() {
#[cfg(any(target_os = "linux", target_os = "macos"))] #[cfg(any(target_os = "linux", target_os = "macos"))]
{ {
let result = ts #[cfg(target_os = "macos")]
.ucmd() let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
#[cfg(target_os = "linux")]
let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--sparse=auto") .arg("--sparse=auto")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains(expected);
let stdout_str = result.stdout_str();
#[cfg(target_os = "macos")]
if !stdout_str
.contains("copy offload: unknown, reflink: unsupported, sparse detection: unsupported")
{
panic!("Failure: stdout was \n{stdout_str}");
}
#[cfg(target_os = "linux")]
if !stdout_str.contains("copy offload: unknown, reflink: unsupported, sparse detection: no")
{
panic!("Failure: stdout was \n{stdout_str}");
}
} }
} }
#[test] #[test]
#[cfg(any(target_os = "linux", target_os = "macos"))] #[cfg(any(target_os = "linux", target_os = "macos"))]
fn test_cp_debug_reflink_auto() { fn test_cp_debug_reflink_auto() {
#[cfg(target_os = "macos")]
let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
#[cfg(target_os = "linux")]
let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let at = &ts.fixtures; let at = &ts.fixtures;
at.touch("a"); at.touch("a");
let result = ts
.ucmd() ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=auto") .arg("--reflink=auto")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains(expected);
#[cfg(target_os = "linux")]
{
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: unknown, reflink: unsupported, sparse detection: no")
{
panic!("Failure: stdout was \n{stdout_str}");
}
}
#[cfg(target_os = "macos")]
{
let stdout_str = result.stdout_str();
if !stdout_str
.contains("copy offload: unknown, reflink: unsupported, sparse detection: unsupported")
{
panic!("Failure: stdout was \n{stdout_str}");
}
}
} }
#[test] #[test]
@ -3658,19 +3572,14 @@ fn test_cp_debug_sparse_always_reflink_auto() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let at = &ts.fixtures; let at = &ts.fixtures;
at.touch("a"); at.touch("a");
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--sparse=always") .arg("--sparse=always")
.arg("--reflink=auto") .arg("--reflink=auto")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let stdout_str = result.stdout_str(); .stdout_contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros");
if !stdout_str.contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros")
{
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -3678,11 +3587,10 @@ fn test_cp_only_source_no_target() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let at = &ts.fixtures; let at = &ts.fixtures;
at.touch("a"); at.touch("a");
let result = ts.ucmd().arg("a").fails(); ts.ucmd()
let stderr_str = result.stderr_str(); .arg("a")
if !stderr_str.contains("missing destination file operand after \"a\"") { .fails()
panic!("Failure: stderr was \n{stderr_str}"); .stderr_contains("missing destination file operand after \"a\"");
}
} }
#[test] #[test]
@ -3822,6 +3730,7 @@ fn test_acl_preserve() {
assert!(compare_xattrs(&file, &file_target)); assert!(compare_xattrs(&file, &file_target));
} }
#[test] #[test]
#[cfg(any(target_os = "linux", target_os = "android"))] #[cfg(any(target_os = "linux", target_os = "android"))]
fn test_cp_debug_reflink_never_with_hole() { fn test_cp_debug_reflink_never_with_hole() {
@ -3834,24 +3743,19 @@ fn test_cp_debug_reflink_never_with_hole() {
.unwrap(); .unwrap();
f.set_len(10000).unwrap(); f.set_len(10000).unwrap();
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=never") .arg("--reflink=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap(); .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE");
let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
if dst_file_metadata.blocks() != src_file_metadata.blocks() {
panic!("File not sparsely copied");
}
let stdout_str = result.stdout_str(); let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE") { let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
panic!("Failure: stdout was \n{stdout_str}"); assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
}
} }
#[test] #[test]
#[cfg(any(target_os = "linux", target_os = "android"))] #[cfg(any(target_os = "linux", target_os = "android"))]
fn test_cp_debug_reflink_never_empty_file_with_hole() { fn test_cp_debug_reflink_never_empty_file_with_hole() {
@ -3864,23 +3768,17 @@ fn test_cp_debug_reflink_never_empty_file_with_hole() {
.unwrap(); .unwrap();
f.set_len(10000).unwrap(); f.set_len(10000).unwrap();
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=never") .arg("--reflink=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap(); .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
if dst_file_metadata.blocks() != src_file_metadata.blocks() {
panic!("File not sparsely copied");
}
let stdout_str = result.stdout_str(); let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
if !stdout_str.contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE") { let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
panic!("Failure: stdout was \n{stdout_str}"); assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
}
} }
#[test] #[test]
@ -3896,18 +3794,17 @@ fn test_cp_debug_default_with_hole() {
f.set_len(10000).unwrap(); f.set_len(10000).unwrap();
at.append_bytes("a", "hello".as_bytes()); at.append_bytes("a", "hello".as_bytes());
let result = ts.ucmd().arg("--debug").arg("a").arg("b").succeeds();
let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
if dst_file_metadata.blocks() != src_file_metadata.blocks() {
panic!("File not sparsely copied");
}
let stdout_str = result.stdout_str(); ts.ucmd()
if !stdout_str.contains("copy offload: yes, reflink: unsupported, sparse detection: SEEK_HOLE") .arg("--debug")
{ .arg("a")
panic!("Failure: stdout was \n{stdout_str}"); .arg("b")
} .succeeds()
.stdout_contains("copy offload: yes, reflink: unsupported, sparse detection: SEEK_HOLE");
let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
} }
#[test] #[test]
@ -3923,19 +3820,14 @@ fn test_cp_debug_default_less_than_512_bytes() {
.unwrap(); .unwrap();
f.set_len(400).unwrap(); f.set_len(400).unwrap();
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=auto") .arg("--reflink=auto")
.arg("--sparse=auto") .arg("--sparse=auto")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: yes, reflink: unsupported, sparse detection: no");
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: yes, reflink: unsupported, sparse detection: no") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -3950,13 +3842,14 @@ fn test_cp_debug_default_without_hole() {
at.append_bytes("a", &filler_bytes); at.append_bytes("a", &filler_bytes);
let result = ts.ucmd().arg("--debug").arg("a").arg("b").succeeds(); ts.ucmd()
.arg("--debug")
let stdout_str = result.stdout_str(); .arg("a")
if !stdout_str.contains("copy offload: yes, reflink: unsupported, sparse detection: no") { .arg("b")
panic!("Failure: stdout was \n{stdout_str}"); .succeeds()
} .stdout_contains("copy offload: yes, reflink: unsupported, sparse detection: no");
} }
#[test] #[test]
#[cfg(any(target_os = "linux", target_os = "android"))] #[cfg(any(target_os = "linux", target_os = "android"))]
fn test_cp_debug_default_empty_file_with_hole() { fn test_cp_debug_default_empty_file_with_hole() {
@ -3969,19 +3862,18 @@ fn test_cp_debug_default_empty_file_with_hole() {
.unwrap(); .unwrap();
f.set_len(10000).unwrap(); f.set_len(10000).unwrap();
let result = ts.ucmd().arg("--debug").arg("a").arg("b").succeeds(); ts.ucmd()
let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap(); .arg("--debug")
let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap(); .arg("a")
if dst_file_metadata.blocks() != src_file_metadata.blocks() { .arg("b")
panic!("File not sparsely copied"); .succeeds()
} .stdout_contains(
"copy offload: unknown, reflink: unsupported, sparse detection: SEEK_HOLE",
);
let stdout_str = result.stdout_str(); let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
if !stdout_str let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
.contains("copy offload: unknown, reflink: unsupported, sparse detection: SEEK_HOLE") assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
{
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -3996,25 +3888,18 @@ fn test_cp_debug_reflink_never_sparse_always_with_hole() {
.unwrap(); .unwrap();
f.set_len(10000).unwrap(); f.set_len(10000).unwrap();
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=never") .arg("--reflink=never")
.arg("--sparse=always") .arg("--sparse=always")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap(); .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE + zeros");
let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap(); let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
if dst_file_metadata.blocks() != src_file_metadata.blocks() { let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
panic!("File not sparsely copied"); assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
}
let stdout_str = result.stdout_str();
if !stdout_str
.contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE + zeros")
{
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -4026,23 +3911,20 @@ fn test_cp_debug_reflink_never_sparse_always_without_hole() {
at.write("a", "hello"); at.write("a", "hello");
at.append_bytes("a", &empty_bytes); at.append_bytes("a", &empty_bytes);
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=never") .arg("--reflink=never")
.arg("--sparse=always") .arg("--sparse=always")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap(); .stdout_contains("copy offload: avoided, reflink: no, sparse detection: zeros");
if dst_file_metadata.blocks() != dst_file_metadata.blksize() / 512 { let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
panic!("Zero sequenced blocks not removed"); assert_eq!(
} dst_file_metadata.blocks(),
let stdout_str = result.stdout_str(); dst_file_metadata.blksize() / 512
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: zeros") { );
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -4057,19 +3939,14 @@ fn test_cp_debug_reflink_never_sparse_always_empty_file_with_hole() {
.unwrap(); .unwrap();
f.set_len(10000).unwrap(); f.set_len(10000).unwrap();
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=never") .arg("--reflink=never")
.arg("--sparse=always") .arg("--sparse=always")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -4086,9 +3963,7 @@ fn test_cp_default_virtual_file() {
let dest_size = std::fs::metadata(at.plus("b")) let dest_size = std::fs::metadata(at.plus("b"))
.expect("Metadata of copied file cannot be read") .expect("Metadata of copied file cannot be read")
.size(); .size();
if dest_size == 0 { assert!(dest_size > 0);
panic!("Copy unsuccessful");
}
} }
#[test] #[test]
#[cfg(any(target_os = "linux", target_os = "android"))] #[cfg(any(target_os = "linux", target_os = "android"))]
@ -4100,25 +3975,20 @@ fn test_cp_debug_reflink_auto_sparse_always_non_sparse_file_with_long_zero_seque
at.touch("a"); at.touch("a");
at.append_bytes("a", &buf); at.append_bytes("a", &buf);
at.append_bytes("a", "hello".as_bytes()); at.append_bytes("a", "hello".as_bytes());
let result = ts
.ucmd() ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--sparse=always") .arg("--sparse=always")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros");
let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap(); let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
assert_eq!(
if dst_file_metadata.blocks() != dst_file_metadata.blksize() / 512 { dst_file_metadata.blocks(),
panic!("Zero sequenced blocks not removed"); dst_file_metadata.blksize() / 512
} );
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros")
{
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -4127,17 +3997,14 @@ fn test_cp_debug_sparse_never_empty_sparse_file() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let at = &ts.fixtures; let at = &ts.fixtures;
at.touch("a"); at.touch("a");
let result = ts
.ucmd() ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--sparse=never") .arg("--sparse=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let stdout_str = result.stdout_str(); .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: no") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -4150,46 +4017,38 @@ fn test_cp_debug_reflink_never_sparse_always_non_sparse_file_with_long_zero_sequ
at.touch("a"); at.touch("a");
at.append_bytes("a", &buf); at.append_bytes("a", &buf);
at.append_bytes("a", "hello".as_bytes()); at.append_bytes("a", "hello".as_bytes());
let result = ts
.ucmd() ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=never") .arg("--reflink=never")
.arg("--sparse=always") .arg("--sparse=always")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: avoided, reflink: no, sparse detection: zeros");
let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap(); let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
assert_eq!(
if dst_file_metadata.blocks() != dst_file_metadata.blksize() / 512 { dst_file_metadata.blocks(),
panic!("Zero sequenced blocks not removed"); dst_file_metadata.blksize() / 512
} );
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: zeros") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
fn test_cp_debug_sparse_always_sparse_virtual_file() { fn test_cp_debug_sparse_always_sparse_virtual_file() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--sparse=always") .arg("--sparse=always")
.arg("/sys/kernel/address_bits") .arg("/sys/kernel/address_bits")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains(
let stdout_str = result.stdout_str();
if !stdout_str.contains(
"copy offload: avoided, reflink: unsupported, sparse detection: SEEK_HOLE + zeros", "copy offload: avoided, reflink: unsupported, sparse detection: SEEK_HOLE + zeros",
) { );
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
#[cfg(any(target_os = "linux", target_os = "android"))] #[cfg(any(target_os = "linux", target_os = "android"))]
fn test_cp_debug_reflink_never_less_than_512_bytes() { fn test_cp_debug_reflink_never_less_than_512_bytes() {
@ -4203,18 +4062,13 @@ fn test_cp_debug_reflink_never_less_than_512_bytes() {
.unwrap(); .unwrap();
f.set_len(400).unwrap(); f.set_len(400).unwrap();
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=never") .arg("--reflink=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: no") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -4229,19 +4083,16 @@ fn test_cp_debug_reflink_never_sparse_never_empty_file_with_hole() {
.unwrap(); .unwrap();
f.set_len(10000).unwrap(); f.set_len(10000).unwrap();
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=never") .arg("--reflink=never")
.arg("--sparse=never") .arg("--sparse=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let stdout_str = result.stdout_str(); .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
if !stdout_str.contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
#[cfg(any(target_os = "linux", target_os = "android"))] #[cfg(any(target_os = "linux", target_os = "android"))]
fn test_cp_debug_reflink_never_file_with_hole() { fn test_cp_debug_reflink_never_file_with_hole() {
@ -4254,18 +4105,15 @@ fn test_cp_debug_reflink_never_file_with_hole() {
.unwrap(); .unwrap();
f.set_len(10000).unwrap(); f.set_len(10000).unwrap();
at.append_bytes("a", "hello".as_bytes()); at.append_bytes("a", "hello".as_bytes());
let result = ts
.ucmd() ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=never") .arg("--reflink=never")
.arg("--sparse=never") .arg("--sparse=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let stdout_str = result.stdout_str(); .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE");
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -4281,19 +4129,14 @@ fn test_cp_debug_sparse_never_less_than_512_bytes() {
.unwrap(); .unwrap();
f.set_len(400).unwrap(); f.set_len(400).unwrap();
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=auto") .arg("--reflink=auto")
.arg("--sparse=never") .arg("--sparse=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: no") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -4308,20 +4151,16 @@ fn test_cp_debug_sparse_never_without_hole() {
at.append_bytes("a", &filler_bytes); at.append_bytes("a", &filler_bytes);
let result = ts ts.ucmd()
.ucmd()
.arg("--reflink=auto") .arg("--reflink=auto")
.arg("--sparse=never") .arg("--sparse=never")
.arg("--debug") .arg("--debug")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: no") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
#[cfg(any(target_os = "linux", target_os = "android"))] #[cfg(any(target_os = "linux", target_os = "android"))]
fn test_cp_debug_sparse_never_empty_file_with_hole() { fn test_cp_debug_sparse_never_empty_file_with_hole() {
@ -4334,19 +4173,16 @@ fn test_cp_debug_sparse_never_empty_file_with_hole() {
.unwrap(); .unwrap();
f.set_len(10000).unwrap(); f.set_len(10000).unwrap();
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=auto") .arg("--reflink=auto")
.arg("--sparse=never") .arg("--sparse=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let stdout_str = result.stdout_str(); .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
if !stdout_str.contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
#[cfg(any(target_os = "linux", target_os = "android"))] #[cfg(any(target_os = "linux", target_os = "android"))]
fn test_cp_debug_sparse_never_file_with_hole() { fn test_cp_debug_sparse_never_file_with_hole() {
@ -4359,73 +4195,54 @@ fn test_cp_debug_sparse_never_file_with_hole() {
.unwrap(); .unwrap();
f.set_len(10000).unwrap(); f.set_len(10000).unwrap();
at.append_bytes("a", "hello".as_bytes()); at.append_bytes("a", "hello".as_bytes());
let result = ts
.ucmd() ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=auto") .arg("--reflink=auto")
.arg("--sparse=never") .arg("--sparse=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
let stdout_str = result.stdout_str(); .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE");
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
fn test_cp_debug_default_sparse_virtual_file() { fn test_cp_debug_default_sparse_virtual_file() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("/sys/kernel/address_bits") .arg("/sys/kernel/address_bits")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains(
let stdout_str = result.stdout_str(); "copy offload: unsupported, reflink: unsupported, sparse detection: SEEK_HOLE",
if !stdout_str );
.contains("copy offload: unsupported, reflink: unsupported, sparse detection: SEEK_HOLE")
{
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
fn test_cp_debug_sparse_never_zero_sized_virtual_file() { fn test_cp_debug_sparse_never_zero_sized_virtual_file() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("--sparse=never") .arg("--sparse=never")
.arg("/proc/version") .arg("/proc/version")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: no") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
fn test_cp_debug_default_zero_sized_virtual_file() { fn test_cp_debug_default_zero_sized_virtual_file() {
let ts = TestScenario::new(util_name!()); let ts = TestScenario::new(util_name!());
let result = ts ts.ucmd()
.ucmd()
.arg("--debug") .arg("--debug")
.arg("/proc/version") .arg("/proc/version")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: unsupported, reflink: unsupported, sparse detection: no");
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: unsupported, reflink: unsupported, sparse detection: no")
{
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]
@ -4436,18 +4253,14 @@ fn test_cp_debug_reflink_never_without_hole() {
let at = &ts.fixtures; let at = &ts.fixtures;
at.write("a", "hello"); at.write("a", "hello");
at.append_bytes("a", &filler_bytes); at.append_bytes("a", &filler_bytes);
let result = ts
.ucmd() ts.ucmd()
.arg("--debug") .arg("--debug")
.arg("--reflink=never") .arg("--reflink=never")
.arg("a") .arg("a")
.arg("b") .arg("b")
.succeeds(); .succeeds()
.stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
let stdout_str = result.stdout_str();
if !stdout_str.contains("copy offload: avoided, reflink: no, sparse detection: no") {
panic!("Failure: stdout was \n{stdout_str}");
}
} }
#[test] #[test]