aboutsummaryrefslogtreecommitdiff
path: root/crates/nres/src/tests.rs
diff options
context:
space:
mode:
Diffstat (limited to 'crates/nres/src/tests.rs')
-rw-r--r--crates/nres/src/tests.rs983
1 files changed, 0 insertions, 983 deletions
diff --git a/crates/nres/src/tests.rs b/crates/nres/src/tests.rs
deleted file mode 100644
index bfa75a8..0000000
--- a/crates/nres/src/tests.rs
+++ /dev/null
@@ -1,983 +0,0 @@
-use super::*;
-use common::collect_files_recursive;
-use std::any::Any;
-use std::fs;
-use std::panic::{catch_unwind, AssertUnwindSafe};
-
-#[derive(Clone)]
-struct SyntheticEntry<'a> {
- kind: u32,
- attr1: u32,
- attr2: u32,
- attr3: u32,
- name: &'a str,
- data: &'a [u8],
-}
-
-fn nres_test_files() -> Vec<PathBuf> {
- let root = Path::new(env!("CARGO_MANIFEST_DIR"))
- .join("..")
- .join("..")
- .join("testdata")
- .join("nres");
- let mut files = Vec::new();
- collect_files_recursive(&root, &mut files);
- files.sort();
- files
- .into_iter()
- .filter(|path| {
- fs::read(path)
- .map(|data| data.get(0..4) == Some(b"NRes"))
- .unwrap_or(false)
- })
- .collect()
-}
-
-fn make_temp_copy(original: &Path, bytes: &[u8]) -> PathBuf {
- let mut path = std::env::temp_dir();
- let file_name = original
- .file_name()
- .and_then(|v| v.to_str())
- .unwrap_or("archive");
- path.push(format!(
- "nres-test-{}-{}-{}",
- std::process::id(),
- unix_time_nanos(),
- file_name
- ));
- fs::write(&path, bytes).expect("failed to create temp file");
- path
-}
-
-fn panic_message(payload: Box<dyn Any + Send>) -> String {
- let any = payload.as_ref();
- if let Some(message) = any.downcast_ref::<String>() {
- return message.clone();
- }
- if let Some(message) = any.downcast_ref::<&str>() {
- return (*message).to_string();
- }
- String::from("panic without message")
-}
-
-fn read_u32_le(bytes: &[u8], offset: usize) -> u32 {
- let slice = bytes
- .get(offset..offset + 4)
- .expect("u32 read out of bounds in test");
- let arr: [u8; 4] = slice.try_into().expect("u32 conversion failed in test");
- u32::from_le_bytes(arr)
-}
-
-fn read_i32_le(bytes: &[u8], offset: usize) -> i32 {
- let slice = bytes
- .get(offset..offset + 4)
- .expect("i32 read out of bounds in test");
- let arr: [u8; 4] = slice.try_into().expect("i32 conversion failed in test");
- i32::from_le_bytes(arr)
-}
-
-fn name_field_bytes(raw: &[u8; 36]) -> Option<&[u8]> {
- let nul = raw.iter().position(|value| *value == 0)?;
- Some(&raw[..nul])
-}
-
-fn build_nres_bytes(entries: &[SyntheticEntry<'_>]) -> Vec<u8> {
- let mut out = vec![0u8; 16];
- let mut offsets = Vec::with_capacity(entries.len());
-
- for entry in entries {
- offsets.push(u32::try_from(out.len()).expect("offset overflow"));
- out.extend_from_slice(entry.data);
- let padding = (8 - (out.len() % 8)) % 8;
- if padding > 0 {
- out.resize(out.len() + padding, 0);
- }
- }
-
- let mut sort_order: Vec<usize> = (0..entries.len()).collect();
- sort_order.sort_by(|a, b| {
- cmp_name_case_insensitive(entries[*a].name.as_bytes(), entries[*b].name.as_bytes())
- });
-
- for (index, entry) in entries.iter().enumerate() {
- let mut name_raw = [0u8; 36];
- let name_bytes = entry.name.as_bytes();
- assert!(name_bytes.len() <= 35, "name too long in fixture");
- name_raw[..name_bytes.len()].copy_from_slice(name_bytes);
-
- push_u32(&mut out, entry.kind);
- push_u32(&mut out, entry.attr1);
- push_u32(&mut out, entry.attr2);
- push_u32(
- &mut out,
- u32::try_from(entry.data.len()).expect("data size overflow"),
- );
- push_u32(&mut out, entry.attr3);
- out.extend_from_slice(&name_raw);
- push_u32(&mut out, offsets[index]);
- push_u32(
- &mut out,
- u32::try_from(sort_order[index]).expect("sort index overflow"),
- );
- }
-
- out[0..4].copy_from_slice(b"NRes");
- out[4..8].copy_from_slice(&0x100_u32.to_le_bytes());
- out[8..12].copy_from_slice(
- &u32::try_from(entries.len())
- .expect("count overflow")
- .to_le_bytes(),
- );
- let total_size = u32::try_from(out.len()).expect("size overflow");
- out[12..16].copy_from_slice(&total_size.to_le_bytes());
- out
-}
-
-#[test]
-fn nres_docs_structural_invariants_all_files() {
- let files = nres_test_files();
- if files.is_empty() {
- eprintln!(
- "skipping nres_docs_structural_invariants_all_files: no NRes archives in testdata/nres"
- );
- return;
- }
-
- for path in files {
- let bytes = fs::read(&path).unwrap_or_else(|err| {
- panic!("failed to read {}: {err}", path.display());
- });
-
- assert!(
- bytes.len() >= 16,
- "NRes header too short in {}",
- path.display()
- );
- assert_eq!(&bytes[0..4], b"NRes", "bad magic in {}", path.display());
- assert_eq!(
- read_u32_le(&bytes, 4),
- 0x100,
- "bad version in {}",
- path.display()
- );
- assert_eq!(
- usize::try_from(read_u32_le(&bytes, 12)).expect("size overflow"),
- bytes.len(),
- "header.total_size mismatch in {}",
- path.display()
- );
-
- let entry_count_i32 = read_i32_le(&bytes, 8);
- assert!(
- entry_count_i32 >= 0,
- "negative entry_count={} in {}",
- entry_count_i32,
- path.display()
- );
- let entry_count = usize::try_from(entry_count_i32).expect("entry_count overflow");
- let directory_len = entry_count.checked_mul(64).expect("directory_len overflow");
- let directory_offset = bytes
- .len()
- .checked_sub(directory_len)
- .unwrap_or_else(|| panic!("directory underflow in {}", path.display()));
- assert!(
- directory_offset >= 16,
- "directory offset before data area in {}",
- path.display()
- );
- assert_eq!(
- directory_offset + directory_len,
- bytes.len(),
- "directory not at file end in {}",
- path.display()
- );
-
- let mut sort_indices = Vec::with_capacity(entry_count);
- let mut entries = Vec::with_capacity(entry_count);
- for index in 0..entry_count {
- let base = directory_offset + index * 64;
- let size = usize::try_from(read_u32_le(&bytes, base + 12)).expect("size overflow");
- let data_offset =
- usize::try_from(read_u32_le(&bytes, base + 56)).expect("offset overflow");
- let sort_index =
- usize::try_from(read_u32_le(&bytes, base + 60)).expect("sort_index overflow");
-
- let mut name_raw = [0u8; 36];
- name_raw.copy_from_slice(
- bytes
- .get(base + 20..base + 56)
- .expect("name field out of bounds in test"),
- );
- let name_bytes = name_field_bytes(&name_raw).unwrap_or_else(|| {
- panic!(
- "name field without NUL terminator in {} entry #{index}",
- path.display()
- )
- });
- assert!(
- name_bytes.len() <= 35,
- "name longer than 35 bytes in {} entry #{index}",
- path.display()
- );
-
- sort_indices.push(sort_index);
- entries.push((name_bytes.to_vec(), data_offset, size));
- }
-
- let mut expected_sort: Vec<usize> = (0..entry_count).collect();
- expected_sort.sort_by(|a, b| cmp_name_case_insensitive(&entries[*a].0, &entries[*b].0));
- assert_eq!(
- sort_indices,
- expected_sort,
- "sort_index table mismatch in {}",
- path.display()
- );
-
- let mut data_regions: Vec<(usize, usize)> =
- entries.iter().map(|(_, off, size)| (*off, *size)).collect();
- data_regions.sort_by_key(|(off, _)| *off);
-
- for (idx, (data_offset, size)) in data_regions.iter().enumerate() {
- assert_eq!(
- data_offset % 8,
- 0,
- "data offset is not 8-byte aligned in {} (region #{idx})",
- path.display()
- );
- assert!(
- *data_offset >= 16,
- "data offset before header end in {} (region #{idx})",
- path.display()
- );
- assert!(
- data_offset.checked_add(*size).unwrap_or(usize::MAX) <= directory_offset,
- "data region overlaps directory in {} (region #{idx})",
- path.display()
- );
- }
-
- for pair in data_regions.windows(2) {
- let (start, size) = pair[0];
- let (next_start, _) = pair[1];
- let end = start
- .checked_add(size)
- .unwrap_or_else(|| panic!("size overflow in {}", path.display()));
- assert!(
- end <= next_start,
- "overlapping data regions in {}: [{start}, {end}) and next at {next_start}",
- path.display()
- );
-
- for (offset, value) in bytes[end..next_start].iter().enumerate() {
- assert_eq!(
- *value,
- 0,
- "non-zero alignment padding in {} at offset {}",
- path.display(),
- end + offset
- );
- }
- }
- }
-}
-
-#[test]
-fn nres_read_and_roundtrip_all_files() {
- let files = nres_test_files();
- if files.is_empty() {
- eprintln!("skipping nres_read_and_roundtrip_all_files: no NRes archives in testdata/nres");
- return;
- }
-
- let checked = files.len();
- let mut success = 0usize;
- let mut failures = Vec::new();
-
- for path in files {
- let display_path = path.display().to_string();
- let result = catch_unwind(AssertUnwindSafe(|| {
- let original = fs::read(&path).expect("failed to read archive");
- let archive = Archive::open_path(&path)
- .unwrap_or_else(|err| panic!("failed to open {}: {err}", path.display()));
-
- let count = archive.entry_count();
- assert_eq!(
- count,
- archive.entries().count(),
- "entry count mismatch: {}",
- path.display()
- );
-
- for idx in 0..count {
- let id = EntryId(idx as u32);
- let entry = archive
- .get(id)
- .unwrap_or_else(|| panic!("missing entry #{idx} in {}", path.display()));
-
- let payload = archive.read(id).unwrap_or_else(|err| {
- panic!("read failed for {} entry #{idx}: {err}", path.display())
- });
-
- let mut out = Vec::new();
- let written = archive.read_into(id, &mut out).unwrap_or_else(|err| {
- panic!(
- "read_into failed for {} entry #{idx}: {err}",
- path.display()
- )
- });
- assert_eq!(
- written,
- payload.as_slice().len(),
- "size mismatch in {} entry #{idx}",
- path.display()
- );
- assert_eq!(
- out.as_slice(),
- payload.as_slice(),
- "payload mismatch in {} entry #{idx}",
- path.display()
- );
-
- let raw = archive
- .raw_slice(id)
- .unwrap_or_else(|err| {
- panic!(
- "raw_slice failed for {} entry #{idx}: {err}",
- path.display()
- )
- })
- .expect("raw_slice must return Some for file-backed archive");
- assert_eq!(
- raw,
- payload.as_slice(),
- "raw slice mismatch in {} entry #{idx}",
- path.display()
- );
-
- let found = archive.find(&entry.meta.name).unwrap_or_else(|| {
- panic!(
- "find failed for name '{}' in {}",
- entry.meta.name,
- path.display()
- )
- });
- let found_meta = archive.get(found).expect("find returned invalid id");
- assert!(
- found_meta.meta.name.eq_ignore_ascii_case(&entry.meta.name),
- "find returned unrelated entry in {}",
- path.display()
- );
- }
-
- let temp_copy = make_temp_copy(&path, &original);
- let mut editor = Archive::edit_path(&temp_copy)
- .unwrap_or_else(|err| panic!("edit_path failed for {}: {err}", path.display()));
-
- for idx in 0..count {
- let data = archive
- .read(EntryId(idx as u32))
- .unwrap_or_else(|err| {
- panic!(
- "read before replace failed for {} entry #{idx}: {err}",
- path.display()
- )
- })
- .into_owned();
- editor
- .replace_data(EntryId(idx as u32), &data)
- .unwrap_or_else(|err| {
- panic!(
- "replace_data failed for {} entry #{idx}: {err}",
- path.display()
- )
- });
- }
-
- editor
- .commit()
- .unwrap_or_else(|err| panic!("commit failed for {}: {err}", path.display()));
- let rebuilt = fs::read(&temp_copy).expect("failed to read rebuilt archive");
- let _ = fs::remove_file(&temp_copy);
-
- assert_eq!(
- original,
- rebuilt,
- "byte-to-byte roundtrip mismatch for {}",
- path.display()
- );
- }));
-
- match result {
- Ok(()) => success += 1,
- Err(payload) => {
- failures.push(format!("{}: {}", display_path, panic_message(payload)));
- }
- }
- }
-
- let failed = failures.len();
- eprintln!(
- "NRes summary: checked={}, success={}, failed={}",
- checked, success, failed
- );
- if !failures.is_empty() {
- panic!(
- "NRes validation failed.\nsummary: checked={}, success={}, failed={}\n{}",
- checked,
- success,
- failed,
- failures.join("\n")
- );
- }
-}
-
-#[test]
-fn nres_raw_mode_exposes_whole_file() {
- let files = nres_test_files();
- let Some(first) = files.first() else {
- eprintln!("skipping nres_raw_mode_exposes_whole_file: no NRes archives in testdata/nres");
- return;
- };
- let original = fs::read(first).expect("failed to read archive");
- let arc: Arc<[u8]> = Arc::from(original.clone().into_boxed_slice());
-
- let archive = Archive::open_bytes(
- arc,
- OpenOptions {
- raw_mode: true,
- sequential_hint: false,
- prefetch_pages: false,
- },
- )
- .expect("raw mode open failed");
-
- assert_eq!(archive.entry_count(), 1);
- let data = archive.read(EntryId(0)).expect("raw read failed");
- assert_eq!(data.as_slice(), original.as_slice());
-}
-
-#[test]
-fn nres_raw_mode_accepts_non_nres_bytes() {
- let payload = b"not-an-nres-archive".to_vec();
- let bytes: Arc<[u8]> = Arc::from(payload.clone().into_boxed_slice());
-
- match Archive::open_bytes(bytes.clone(), OpenOptions::default()) {
- Err(Error::InvalidMagic { .. }) => {}
- other => panic!("expected InvalidMagic without raw_mode, got {other:?}"),
- }
-
- let archive = Archive::open_bytes(
- bytes,
- OpenOptions {
- raw_mode: true,
- sequential_hint: false,
- prefetch_pages: false,
- },
- )
- .expect("raw_mode should accept any bytes");
-
- assert_eq!(archive.entry_count(), 1);
- assert_eq!(archive.find("raw"), Some(EntryId(0)));
- assert_eq!(
- archive
- .read(EntryId(0))
- .expect("raw read failed")
- .as_slice(),
- payload.as_slice()
- );
-}
-
-#[test]
-fn nres_open_options_hints_do_not_change_payload() {
- let payload: Vec<u8> = (0..70_000u32).map(|v| (v % 251) as u8).collect();
- let src = build_nres_bytes(&[SyntheticEntry {
- kind: 7,
- attr1: 70,
- attr2: 700,
- attr3: 7000,
- name: "big.bin",
- data: &payload,
- }]);
- let arc: Arc<[u8]> = Arc::from(src.into_boxed_slice());
-
- let baseline = Archive::open_bytes(arc.clone(), OpenOptions::default())
- .expect("baseline open should succeed");
- let hinted = Archive::open_bytes(
- arc,
- OpenOptions {
- raw_mode: false,
- sequential_hint: true,
- prefetch_pages: true,
- },
- )
- .expect("open with hints should succeed");
-
- assert_eq!(baseline.entry_count(), 1);
- assert_eq!(hinted.entry_count(), 1);
- assert_eq!(baseline.find("BIG.BIN"), Some(EntryId(0)));
- assert_eq!(hinted.find("big.bin"), Some(EntryId(0)));
- assert_eq!(
- baseline
- .read(EntryId(0))
- .expect("baseline read failed")
- .as_slice(),
- hinted
- .read(EntryId(0))
- .expect("hinted read failed")
- .as_slice()
- );
-}
-
-#[test]
-fn nres_commit_empty_archive_has_minimal_layout() {
- let mut path = std::env::temp_dir();
- path.push(format!(
- "nres-empty-commit-{}-{}.lib",
- std::process::id(),
- unix_time_nanos()
- ));
- fs::write(&path, build_nres_bytes(&[])).expect("write empty archive failed");
-
- Archive::edit_path(&path)
- .expect("edit_path failed for empty archive")
- .commit()
- .expect("commit failed for empty archive");
-
- let bytes = fs::read(&path).expect("failed to read committed archive");
- assert_eq!(bytes.len(), 16, "empty archive must contain only header");
- assert_eq!(&bytes[0..4], b"NRes");
- assert_eq!(read_u32_le(&bytes, 4), 0x100);
- assert_eq!(read_u32_le(&bytes, 8), 0);
- assert_eq!(read_u32_le(&bytes, 12), 16);
-
- let _ = fs::remove_file(&path);
-}
-
-#[test]
-fn nres_commit_recomputes_header_directory_and_sort_table() {
- let mut path = std::env::temp_dir();
- path.push(format!(
- "nres-commit-layout-{}-{}.lib",
- std::process::id(),
- unix_time_nanos()
- ));
- fs::write(&path, build_nres_bytes(&[])).expect("write empty archive failed");
-
- let mut editor = Archive::edit_path(&path).expect("edit_path failed");
- editor
- .add(NewEntry {
- kind: 10,
- attr1: 1,
- attr2: 2,
- attr3: 3,
- name: "Zulu",
- data: b"aaaaa",
- })
- .expect("add #0 failed");
- editor
- .add(NewEntry {
- kind: 11,
- attr1: 4,
- attr2: 5,
- attr3: 6,
- name: "alpha",
- data: b"bbbbbbbb",
- })
- .expect("add #1 failed");
- editor
- .add(NewEntry {
- kind: 12,
- attr1: 7,
- attr2: 8,
- attr3: 9,
- name: "Beta",
- data: b"cccc",
- })
- .expect("add #2 failed");
- editor.commit().expect("commit failed");
-
- let bytes = fs::read(&path).expect("failed to read committed archive");
- assert_eq!(&bytes[0..4], b"NRes");
- assert_eq!(read_u32_le(&bytes, 4), 0x100);
-
- let entry_count = usize::try_from(read_u32_le(&bytes, 8)).expect("entry_count overflow");
- let total_size = usize::try_from(read_u32_le(&bytes, 12)).expect("total_size overflow");
- assert_eq!(entry_count, 3);
- assert_eq!(total_size, bytes.len());
-
- let directory_offset = total_size
- .checked_sub(entry_count * 64)
- .expect("invalid directory offset");
- assert!(directory_offset >= 16);
-
- let mut sort_indices = Vec::new();
- let mut prev_data_end = 16usize;
- for idx in 0..entry_count {
- let base = directory_offset + idx * 64;
- let data_size = usize::try_from(read_u32_le(&bytes, base + 12)).expect("size overflow");
- let data_offset = usize::try_from(read_u32_le(&bytes, base + 56)).expect("offset overflow");
- let sort_index =
- usize::try_from(read_u32_le(&bytes, base + 60)).expect("sort index overflow");
-
- assert_eq!(
- data_offset % 8,
- 0,
- "entry #{idx} data offset must be 8-byte aligned"
- );
- assert!(
- data_offset >= prev_data_end,
- "entry #{idx} offset regressed"
- );
- assert!(
- data_offset + data_size <= directory_offset,
- "entry #{idx} overlaps directory"
- );
- prev_data_end = data_offset + data_size;
- sort_indices.push(sort_index);
- }
-
- let names = ["Zulu", "alpha", "Beta"];
- let mut expected_sort: Vec<usize> = (0..names.len()).collect();
- expected_sort
- .sort_by(|a, b| cmp_name_case_insensitive(names[*a].as_bytes(), names[*b].as_bytes()));
- assert_eq!(
- sort_indices, expected_sort,
- "sort table must contain original indexes in case-insensitive alphabetical order"
- );
-
- let archive = Archive::open_path(&path).expect("re-open failed");
- assert_eq!(archive.find("zulu"), Some(EntryId(0)));
- assert_eq!(archive.find("ALPHA"), Some(EntryId(1)));
- assert_eq!(archive.find("beta"), Some(EntryId(2)));
-
- let _ = fs::remove_file(&path);
-}
-
-#[test]
-fn nres_synthetic_read_find_and_edit() {
- let payload_a = b"alpha";
- let payload_b = b"B";
- let payload_c = b"";
- let src = build_nres_bytes(&[
- SyntheticEntry {
- kind: 1,
- attr1: 10,
- attr2: 20,
- attr3: 30,
- name: "Alpha.TXT",
- data: payload_a,
- },
- SyntheticEntry {
- kind: 2,
- attr1: 11,
- attr2: 21,
- attr3: 31,
- name: "beta.bin",
- data: payload_b,
- },
- SyntheticEntry {
- kind: 3,
- attr1: 12,
- attr2: 22,
- attr3: 32,
- name: "Gamma",
- data: payload_c,
- },
- ]);
-
- let archive = Archive::open_bytes(
- Arc::from(src.clone().into_boxed_slice()),
- OpenOptions::default(),
- )
- .expect("open synthetic nres failed");
-
- assert_eq!(archive.entry_count(), 3);
- assert_eq!(archive.find("alpha.txt"), Some(EntryId(0)));
- assert_eq!(archive.find("BETA.BIN"), Some(EntryId(1)));
- assert_eq!(archive.find("gAmMa"), Some(EntryId(2)));
- assert_eq!(archive.find("missing"), None);
-
- assert_eq!(
- archive.read(EntryId(0)).expect("read #0 failed").as_slice(),
- payload_a
- );
- assert_eq!(
- archive.read(EntryId(1)).expect("read #1 failed").as_slice(),
- payload_b
- );
- assert_eq!(
- archive.read(EntryId(2)).expect("read #2 failed").as_slice(),
- payload_c
- );
-
- let mut path = std::env::temp_dir();
- path.push(format!(
- "nres-synth-edit-{}-{}.lib",
- std::process::id(),
- unix_time_nanos()
- ));
- fs::write(&path, &src).expect("write temp synthetic archive failed");
-
- let mut editor = Archive::edit_path(&path).expect("edit_path on synthetic archive failed");
- editor
- .replace_data(EntryId(1), b"replaced")
- .expect("replace_data failed");
- let added = editor
- .add(NewEntry {
- kind: 4,
- attr1: 13,
- attr2: 23,
- attr3: 33,
- name: "delta",
- data: b"new payload",
- })
- .expect("add failed");
- assert_eq!(added, EntryId(3));
- editor.remove(EntryId(2)).expect("remove failed");
- editor.commit().expect("commit failed");
-
- let edited = Archive::open_path(&path).expect("re-open edited archive failed");
- assert_eq!(edited.entry_count(), 3);
- assert_eq!(
- edited
- .read(edited.find("beta.bin").expect("find beta.bin failed"))
- .expect("read beta.bin failed")
- .as_slice(),
- b"replaced"
- );
- assert_eq!(
- edited
- .read(edited.find("delta").expect("find delta failed"))
- .expect("read delta failed")
- .as_slice(),
- b"new payload"
- );
- assert_eq!(edited.find("gamma"), None);
-
- let _ = fs::remove_file(&path);
-}
-
-#[test]
-fn nres_max_name_length_roundtrip() {
- let max_name = "12345678901234567890123456789012345";
- assert_eq!(max_name.len(), 35);
-
- let src = build_nres_bytes(&[SyntheticEntry {
- kind: 9,
- attr1: 1,
- attr2: 2,
- attr3: 3,
- name: max_name,
- data: b"payload",
- }]);
-
- let archive = Archive::open_bytes(Arc::from(src.into_boxed_slice()), OpenOptions::default())
- .expect("open synthetic nres failed");
-
- assert_eq!(archive.entry_count(), 1);
- assert_eq!(archive.find(max_name), Some(EntryId(0)));
- assert_eq!(
- archive.find(&max_name.to_ascii_lowercase()),
- Some(EntryId(0))
- );
-
- let entry = archive.get(EntryId(0)).expect("missing entry 0");
- assert_eq!(entry.meta.name, max_name);
- assert_eq!(
- archive
- .read(EntryId(0))
- .expect("read payload failed")
- .as_slice(),
- b"payload"
- );
-}
-
-#[test]
-fn nres_find_falls_back_when_sort_index_is_out_of_range() {
- let mut bytes = build_nres_bytes(&[
- SyntheticEntry {
- kind: 1,
- attr1: 0,
- attr2: 0,
- attr3: 0,
- name: "Alpha",
- data: b"a",
- },
- SyntheticEntry {
- kind: 2,
- attr1: 0,
- attr2: 0,
- attr3: 0,
- name: "Beta",
- data: b"b",
- },
- SyntheticEntry {
- kind: 3,
- attr1: 0,
- attr2: 0,
- attr3: 0,
- name: "Gamma",
- data: b"c",
- },
- ]);
-
- let entry_count = 3usize;
- let directory_offset = bytes
- .len()
- .checked_sub(entry_count * 64)
- .expect("directory offset underflow");
- let mid_entry_sort_index = directory_offset + 64 + 60;
- bytes[mid_entry_sort_index..mid_entry_sort_index + 4].copy_from_slice(&u32::MAX.to_le_bytes());
-
- let archive = Archive::open_bytes(Arc::from(bytes.into_boxed_slice()), OpenOptions::default())
- .expect("open archive with corrupted sort index failed");
-
- assert_eq!(archive.find("alpha"), Some(EntryId(0)));
- assert_eq!(archive.find("BETA"), Some(EntryId(1)));
- assert_eq!(archive.find("gamma"), Some(EntryId(2)));
- assert_eq!(archive.find("missing"), None);
-}
-
-#[test]
-fn nres_validation_error_cases() {
- let valid = build_nres_bytes(&[SyntheticEntry {
- kind: 1,
- attr1: 2,
- attr2: 3,
- attr3: 4,
- name: "ok",
- data: b"1234",
- }]);
-
- let mut invalid_magic = valid.clone();
- invalid_magic[0..4].copy_from_slice(b"FAIL");
- match Archive::open_bytes(
- Arc::from(invalid_magic.into_boxed_slice()),
- OpenOptions::default(),
- ) {
- Err(Error::InvalidMagic { .. }) => {}
- other => panic!("expected InvalidMagic, got {other:?}"),
- }
-
- let mut invalid_version = valid.clone();
- invalid_version[4..8].copy_from_slice(&0x200_u32.to_le_bytes());
- match Archive::open_bytes(
- Arc::from(invalid_version.into_boxed_slice()),
- OpenOptions::default(),
- ) {
- Err(Error::UnsupportedVersion { got }) => assert_eq!(got, 0x200),
- other => panic!("expected UnsupportedVersion, got {other:?}"),
- }
-
- let mut bad_total = valid.clone();
- bad_total[12..16].copy_from_slice(&0_u32.to_le_bytes());
- match Archive::open_bytes(
- Arc::from(bad_total.into_boxed_slice()),
- OpenOptions::default(),
- ) {
- Err(Error::TotalSizeMismatch { .. }) => {}
- other => panic!("expected TotalSizeMismatch, got {other:?}"),
- }
-
- let mut bad_count = valid.clone();
- bad_count[8..12].copy_from_slice(&(-1_i32).to_le_bytes());
- match Archive::open_bytes(
- Arc::from(bad_count.into_boxed_slice()),
- OpenOptions::default(),
- ) {
- Err(Error::InvalidEntryCount { got }) => assert_eq!(got, -1),
- other => panic!("expected InvalidEntryCount, got {other:?}"),
- }
-
- let mut bad_dir = valid.clone();
- bad_dir[8..12].copy_from_slice(&1000_u32.to_le_bytes());
- match Archive::open_bytes(
- Arc::from(bad_dir.into_boxed_slice()),
- OpenOptions::default(),
- ) {
- Err(Error::DirectoryOutOfBounds { .. }) => {}
- other => panic!("expected DirectoryOutOfBounds, got {other:?}"),
- }
-
- let mut long_name = valid.clone();
- let entry_base = long_name.len() - 64;
- for b in &mut long_name[entry_base + 20..entry_base + 56] {
- *b = b'X';
- }
- match Archive::open_bytes(
- Arc::from(long_name.into_boxed_slice()),
- OpenOptions::default(),
- ) {
- Err(Error::NameTooLong { .. }) => {}
- other => panic!("expected NameTooLong, got {other:?}"),
- }
-
- let mut bad_data = valid.clone();
- bad_data[entry_base + 56..entry_base + 60].copy_from_slice(&12_u32.to_le_bytes());
- bad_data[entry_base + 12..entry_base + 16].copy_from_slice(&32_u32.to_le_bytes());
- match Archive::open_bytes(
- Arc::from(bad_data.into_boxed_slice()),
- OpenOptions::default(),
- ) {
- Err(Error::EntryDataOutOfBounds { .. }) => {}
- other => panic!("expected EntryDataOutOfBounds, got {other:?}"),
- }
-
- let archive = Archive::open_bytes(Arc::from(valid.into_boxed_slice()), OpenOptions::default())
- .expect("open valid archive failed");
- match archive.read(EntryId(99)) {
- Err(Error::EntryIdOutOfRange { .. }) => {}
- other => panic!("expected EntryIdOutOfRange, got {other:?}"),
- }
-}
-
-#[test]
-fn nres_editor_validation_error_cases() {
- let mut path = std::env::temp_dir();
- path.push(format!(
- "nres-editor-errors-{}-{}.lib",
- std::process::id(),
- unix_time_nanos()
- ));
- let src = build_nres_bytes(&[]);
- fs::write(&path, src).expect("write empty archive failed");
-
- let mut editor = Archive::edit_path(&path).expect("edit_path failed");
-
- let long_name = "X".repeat(36);
- match editor.add(NewEntry {
- kind: 0,
- attr1: 0,
- attr2: 0,
- attr3: 0,
- name: &long_name,
- data: b"",
- }) {
- Err(Error::NameTooLong { .. }) => {}
- other => panic!("expected NameTooLong, got {other:?}"),
- }
-
- match editor.add(NewEntry {
- kind: 0,
- attr1: 0,
- attr2: 0,
- attr3: 0,
- name: "bad\0name",
- data: b"",
- }) {
- Err(Error::NameContainsNul) => {}
- other => panic!("expected NameContainsNul, got {other:?}"),
- }
-
- match editor.replace_data(EntryId(0), b"x") {
- Err(Error::EntryIdOutOfRange { .. }) => {}
- other => panic!("expected EntryIdOutOfRange, got {other:?}"),
- }
-
- match editor.remove(EntryId(0)) {
- Err(Error::EntryIdOutOfRange { .. }) => {}
- other => panic!("expected EntryIdOutOfRange, got {other:?}"),
- }
-
- let _ = fs::remove_file(&path);
-}
Copyright © 2026 Valentin A. Popov. All Rights Reverse Engineered.