use std::os::windows::ffi::OsStrExt;
use windows_sys::Win32::Storage::FileSystem::{
FILE_ACTION_ADDED, FILE_ACTION_MODIFIED, FILE_ACTION_REMOVED, FILE_ACTION_RENAMED_NEW_NAME,
FILE_ACTION_RENAMED_OLD_NAME,
};
use super::{Change, ChangeKind, DecodedBatch, DesyncCause, decode_batch, records};
const UNRECOGNISED_ACTION: u32 = 4242;
fn w(s: &str) -> Vec<u16> {
s.encode_utf16().collect()
}
fn record(next_offset: u32, action: u32, name: &[u16]) -> Vec<u8> {
let name_bytes: Vec<u8> = name.iter().flat_map(|u| u.to_le_bytes()).collect();
let mut v = Vec::new();
v.extend_from_slice(&next_offset.to_le_bytes());
v.extend_from_slice(&action.to_le_bytes());
v.extend_from_slice(&(name_bytes.len() as u32).to_le_bytes());
v.extend_from_slice(&name_bytes);
v
}
fn aligned(name_units: usize) -> usize {
(super::HEADER_LEN + name_units * super::UNIT_LEN).next_multiple_of(super::RECORD_ALIGNMENT)
}
fn chain(recs: &[(u32, Vec<u16>)]) -> Vec<u8> {
let mut buf = Vec::new();
for (i, (action, name)) in recs.iter().enumerate() {
let is_last = i + 1 == recs.len();
let this = aligned(name.len());
let next = if is_last { 0 } else { this as u32 };
let start = buf.len();
buf.extend(record(next, *action, name));
buf.resize(start + this, 0);
}
buf
}
fn changes(buf: &[u8]) -> Vec<Change> {
match decode_batch(buf) {
DecodedBatch::Changes(c) => c,
DecodedBatch::Desync(cause) => panic!("expected changes, got desync {cause:?}"),
}
}
fn desync(buf: &[u8]) -> DesyncCause {
match decode_batch(buf) {
DecodedBatch::Desync(cause) => cause,
DecodedBatch::Changes(c) => panic!("expected a desync, got changes {c:?}"),
}
}
#[test]
fn single_added_record() {
let c = changes(&chain(&[(FILE_ACTION_ADDED, w("a.txt"))]));
assert_eq!(c.len(), 1);
assert_eq!(c[0].kind, ChangeKind::Added);
assert_eq!(c[0].name.as_wide(), w("a.txt").as_slice());
}
#[test]
fn every_recognised_action_maps() {
let c = changes(&chain(&[
(FILE_ACTION_ADDED, w("added")),
(FILE_ACTION_REMOVED, w("removed")),
(FILE_ACTION_MODIFIED, w("modified")),
(FILE_ACTION_RENAMED_OLD_NAME, w("old")),
(FILE_ACTION_RENAMED_NEW_NAME, w("new")),
]));
let kinds: Vec<_> = c.iter().map(|c| c.kind).collect();
assert_eq!(
kinds,
vec![
ChangeKind::Added,
ChangeKind::Removed,
ChangeKind::Modified,
ChangeKind::RenamedOldName,
ChangeKind::RenamedNewName,
]
);
}
#[test]
fn rename_pair_is_kept_distinct_not_joined() {
let c = changes(&chain(&[
(FILE_ACTION_RENAMED_OLD_NAME, w("before.txt")),
(FILE_ACTION_RENAMED_NEW_NAME, w("after.txt")),
]));
assert_eq!(c.len(), 2, "the pair must not be joined into one event");
assert_eq!(c[0].kind, ChangeKind::RenamedOldName);
assert_eq!(c[1].kind, ChangeKind::RenamedNewName);
}
#[test]
fn unknown_action_is_preserved() {
let c = changes(&chain(&[(UNRECOGNISED_ACTION, w("mystery"))]));
assert_eq!(c[0].kind, ChangeKind::Unknown(UNRECOGNISED_ACTION));
}
#[test]
fn name_round_trips_to_os_string() {
let c = changes(&chain(&[(FILE_ACTION_ADDED, w("café.txt"))]));
assert_eq!(
c[0].name.to_os_string(),
std::ffi::OsString::from("café.txt")
);
}
#[test]
fn name_round_trips_to_path_buf() {
let c = changes(&chain(&[(FILE_ACTION_MODIFIED, w("dir\\leaf.txt"))]));
assert_eq!(
c[0].name.to_path_buf(),
std::path::PathBuf::from("dir\\leaf.txt")
);
}
#[test]
fn raw_units_are_preserved() {
let units = w("preserved");
let c = changes(&chain(&[(FILE_ACTION_ADDED, units.clone())]));
assert_eq!(c[0].name.as_wide(), units.as_slice());
}
#[test]
fn two_records_in_order() {
let c = changes(&chain(&[
(FILE_ACTION_ADDED, w("first")),
(FILE_ACTION_REMOVED, w("second")),
]));
assert_eq!(c[0].name.as_wide(), w("first").as_slice());
assert_eq!(c[1].name.as_wide(), w("second").as_slice());
}
#[test]
fn long_name_beyond_max_path() {
let long = "x".repeat(400);
let c = changes(&chain(&[(FILE_ACTION_ADDED, w(&long))]));
assert_eq!(c[0].name.as_wide().len(), 400);
assert_eq!(c[0].name.to_os_string(), std::ffi::OsString::from(&long));
}
#[test]
fn name_filling_the_record_to_the_buffer_edge() {
let name = w("boundary-name");
let buf = record(0, FILE_ACTION_ADDED, &name);
assert_eq!(
buf.len(),
super::HEADER_LEN + name.len() * super::UNIT_LEN,
"name must reach the buffer edge"
);
let c = changes(&buf);
assert_eq!(c.len(), 1);
assert_eq!(c[0].name.as_wide(), name.as_slice());
}
#[test]
fn non_ascii_bmp_name() {
let c = changes(&chain(&[(FILE_ACTION_ADDED, w("日本語.txt"))]));
assert_eq!(
c[0].name.to_os_string(),
std::ffi::OsString::from("日本語.txt")
);
}
#[test]
fn unpaired_surrogate_is_preserved_losslessly() {
let name = vec![0xD800_u16, u16::from(b'A')];
let c = changes(&chain(&[(FILE_ACTION_ADDED, name.clone())]));
assert_eq!(c[0].name.as_wide(), name.as_slice());
let round_trip: Vec<u16> = c[0].name.to_os_string().encode_wide().collect();
assert_eq!(round_trip, name);
}
#[test]
fn empty_name_record() {
let c = changes(&chain(&[(FILE_ACTION_ADDED, Vec::new())]));
assert_eq!(c.len(), 1);
assert_eq!(c[0].kind, ChangeKind::Added);
assert!(c[0].name.as_wide().is_empty());
}
#[test]
fn empty_buffer_is_overflow_desync() {
assert_eq!(
decode_batch(&[]),
DecodedBatch::Desync(DesyncCause::Overflow)
);
}
#[test]
fn truncated_header_is_desync() {
assert_eq!(desync(&[1, 2, 3, 4, 5]), DesyncCause::Overflow);
}
#[test]
fn name_length_overrunning_the_buffer_is_desync() {
let mut buf = Vec::new();
buf.extend_from_slice(&0_u32.to_le_bytes()); buf.extend_from_slice(&FILE_ACTION_ADDED.to_le_bytes());
buf.extend_from_slice(&100_u32.to_le_bytes()); buf.extend_from_slice(&[0x41, 0x00]); assert_eq!(desync(&buf), DesyncCause::Overflow);
}
#[test]
fn next_offset_out_of_bounds_is_desync() {
let buf = record(10_000, FILE_ACTION_ADDED, &w("a"));
assert_eq!(desync(&buf), DesyncCause::Overflow);
}
#[test]
fn next_offset_pointing_into_current_record_is_desync() {
let buf = record(4, FILE_ACTION_ADDED, &w("ab"));
assert_eq!(desync(&buf), DesyncCause::Overflow);
}
#[test]
fn unaligned_next_offset_is_desync() {
let first = record(0, FILE_ACTION_ADDED, &w("a"));
let mut buf = record(15, FILE_ACTION_ADDED, &w("a")); buf.resize(15, 0);
buf.extend(first);
assert_eq!(desync(&buf), DesyncCause::Overflow);
}
#[test]
fn odd_name_length_is_desync() {
let mut buf = Vec::new();
buf.extend_from_slice(&0_u32.to_le_bytes());
buf.extend_from_slice(&FILE_ACTION_ADDED.to_le_bytes());
buf.extend_from_slice(&3_u32.to_le_bytes()); buf.extend_from_slice(&[0x41, 0x00, 0x42]); assert_eq!(desync(&buf), DesyncCause::Overflow);
}
#[test]
fn name_overrunning_next_entry_offset_is_desync() {
let mut buf = Vec::new();
buf.extend_from_slice(&16_u32.to_le_bytes());
buf.extend_from_slice(&FILE_ACTION_ADDED.to_le_bytes());
buf.extend_from_slice(&8_u32.to_le_bytes()); buf.extend_from_slice(&[0x41, 0x00, 0x42, 0x00]); buf.extend_from_slice(&0_u32.to_le_bytes());
buf.extend_from_slice(&FILE_ACTION_ADDED.to_le_bytes());
buf.extend_from_slice(&2_u32.to_le_bytes());
buf.extend_from_slice(&[0x43, 0x00]);
assert_eq!(desync(&buf), DesyncCause::Overflow);
}
#[test]
fn zero_offset_with_trailing_record_is_desync() {
let mut buf = record(0, FILE_ACTION_ADDED, &w("a"));
buf.resize(aligned(1), 0); buf.extend(record(0, FILE_ACTION_ADDED, &w("b")));
assert_eq!(desync(&buf), DesyncCause::Overflow);
}
#[test]
fn zero_offset_trailing_alignment_padding_decodes_cleanly() {
let mut buf = record(0, FILE_ACTION_ADDED, &w("a")); buf.resize(aligned(1), 0); let c = changes(&buf);
assert_eq!(c.len(), 1);
assert_eq!(c[0].name.as_wide(), w("a").as_slice());
}
#[test]
fn zero_offset_misaligned_trailing_tail_is_desync() {
for extra in [1usize, 3] {
let mut buf = record(0, FILE_ACTION_ADDED, &w("a")); buf.resize(buf.len() + extra, 0);
assert_eq!(
desync(&buf),
DesyncCause::Overflow,
"a {extra}-byte tail is not valid DWORD padding"
);
}
}
#[test]
fn raw_records_expose_the_unmapped_action() {
let buf = chain(&[(FILE_ACTION_MODIFIED, w("x"))]);
let recs: Vec<_> = records(&buf).collect();
assert_eq!(recs.len(), 1);
assert_eq!(recs[0].action, FILE_ACTION_MODIFIED);
assert_eq!(recs[0].name.as_wide(), w("x").as_slice());
}
#[link(name = "kernel32")]
unsafe extern "system" {
fn lstrlenW(lpstring: *const u16) -> i32;
}
#[test]
fn a_decoded_name_feeds_a_wide_win32_call_with_no_conversion() {
let buf = record(0, FILE_ACTION_ADDED, &w("report.txt"));
let c = changes(&buf);
let name = &c[0].name;
assert!(
!name.has_interior_nul(),
"a valid C string needs no NUL inside"
);
let counted = unsafe { lstrlenW(name.as_wtf16().as_terminated_ptr()) };
assert_eq!(counted as usize, name.len());
assert_eq!(name.len(), "report.txt".len());
}
#[test]
fn the_deref_surface_exposes_the_borrowed_units() {
let buf = record(0, FILE_ACTION_ADDED, &w("caf\u{e9}.txt"));
let c = changes(&buf);
let name = &c[0].name;
assert_eq!(name.as_units(), name.as_wide());
assert_eq!(name.len(), name.as_wide().len());
assert_eq!(name.to_string_lossy(), "caf\u{e9}.txt");
assert!(!name.as_ptr().is_null());
}
#[test]
fn debug_escapes_a_lone_surrogate_rather_than_replacing_it() {
let high = record(0, FILE_ACTION_ADDED, &[0x61, 0xD800, 0x62]);
let low = record(0, FILE_ACTION_ADDED, &[0x61, 0xDC00, 0x62]);
let high_debug = format!("{:?}", changes(&high)[0].name);
let low_debug = format!("{:?}", changes(&low)[0].name);
assert!(
high_debug.contains("d800"),
"expected an escape, got {high_debug}"
);
assert!(
low_debug.contains("dc00"),
"expected an escape, got {low_debug}"
);
assert_ne!(
high_debug, low_debug,
"two distinct malformed names must not render identically"
);
assert!(
!high_debug.contains('\u{fffd}'),
"a lone surrogate must not be replaced"
);
}
#[test]
fn an_interior_nul_in_a_name_is_preserved_and_reported() {
let buf = record(0, FILE_ACTION_ADDED, &[0x61, 0x0000, 0x62]);
let c = changes(&buf);
let name = &c[0].name;
assert_eq!(name.as_wide(), &[0x61, 0x0000, 0x62]);
assert_eq!(name.len(), 3, "the NUL is content, not a terminator");
assert!(
name.has_interior_nul(),
"the terminated pointer would be truncated here, and the type reports it"
);
}
#[cfg(feature = "test-util")]
#[test]
fn relative_name_for_test_round_trips_a_str() {
let name = super::RelativeName::for_test("sub\\leaf.txt");
assert_eq!(
name.to_os_string(),
std::ffi::OsString::from("sub\\leaf.txt")
);
}
#[cfg(feature = "test-util")]
#[test]
fn relative_name_for_test_os_round_trips() {
let original = std::ffi::OsString::from("dir\\file.bin");
let name = super::RelativeName::for_test_os(&original);
assert_eq!(name.to_os_string(), original);
}
#[cfg(feature = "test-util")]
#[test]
fn relative_name_for_test_units_preserves_a_lone_surrogate() {
let units = [0x0073u16, 0xD800, 0x0074];
let name = super::RelativeName::for_test_units(&units);
assert_eq!(name.as_wide(), units.as_slice());
}