use super::*; use crate::{AssetManager, MemoryBanks, SoundBankPoolAccess}; use prometeu_hal::{ asset::{AssetCodec, AssetEntry, AssetOpStatus, BankType, LoadStatus, SlotRef}, cartridge::AssetsPayloadSource, }; use std::time::{Duration, Instant}; fn fixtures() -> Vec<(&'static [u8], bool)> { vec![ ( include_bytes!(concat!( env!("CARGO_MANIFEST_DIR"), "/../../../test-fixtures/audio/pcm-only.sbnk" )), false, ), ( include_bytes!(concat!( env!("CARGO_MANIFEST_DIR"), "/../../../test-fixtures/audio/ima-only.sbnk" )), false, ), ( include_bytes!(concat!( env!("CARGO_MANIFEST_DIR"), "/../../../test-fixtures/audio/mixed-sound.sbnk" )), false, ), ( include_bytes!(concat!( env!("CARGO_MANIFEST_DIR"), "/../../../test-fixtures/audio/mixed-music.mbnk" )), true, ), ] } #[test] fn packer_binary_fixtures_materialize_mixed_stereo_banks_and_separate_encoded_from_pcm_sizes() { for (index, (bytes, music)) in fixtures().into_iter().enumerate() { let decoded = decode_audio_bank(bytes, music).unwrap(); let (samples, metrics) = match &decoded { DecodedAudioBank::Sound(b) => (&b.samples, b.metrics), DecodedAudioBank::Music(b) => { assert_eq!(b.events.len(), 4); assert_eq!(b.instruments.len(), 2); assert_eq!(b.tracks, 2); (&b.samples, b.metrics) } }; assert_eq!(metrics.cartridge_bytes, bytes.len()); assert_eq!(metrics.pcm_bytes, if index < 2 { 2000 } else { 6000 }); assert_eq!(samples[0].frames_len(), 1000); assert_eq!(samples[0].loop_end, Some(1000)); if index >= 2 { assert_eq!(samples[1].channels, 2); assert_eq!(samples[1].frames_len(), 1000); } if index != 0 { assert!(decoded.decoded_size() > bytes.len()); } } } #[test] fn complete_validation_rejects_truncation_unknown_codec_bad_loops_and_reserved_bytes() { for (bytes, music) in fixtures() { for cut in [0, 4, 47, 48, bytes.len() - 1] { assert!(decode_audio_bank(&bytes[..cut], music).is_err()); } let name = u32le(bytes, 40).unwrap() as usize; let sample = 48 + name; for (at, value) in [(4, 2), (44, 1), (sample, 99), (sample + 1, 3), (sample + 2, 2), (sample + 34, 1)] { let mut bad = bytes.to_vec(); bad[at] = value; assert!(decode_audio_bank(&bad, music).is_err(), "{at}"); } let mut bad = bytes.to_vec(); bad[sample + 12..sample + 16].copy_from_slice(&1001u32.to_le_bytes()); assert!(decode_audio_bank(&bad, music).is_err()); let mut bad = bytes.to_vec(); bad.push(0); assert!(decode_audio_bank(&bad, music).is_err()); // Mutating every byte must produce either a validated bank or a clean error. for i in 0..bytes.len() { let mut changed = bytes.to_vec(); changed[i] ^= 0xff; let _ = decode_audio_bank(&changed, music); } } } fn entry(id: i32, offset: usize, bytes: &[u8], music: bool) -> AssetEntry { AssetEntry { asset_id: id, asset_name: format!("bank{id}"), bank_type: if music { BankType::MUSIC } else { BankType::SOUNDS }, offset: offset as u64, size: bytes.len() as u64, decoded_size: decode_audio_bank(bytes, music).unwrap().decoded_size() as u64, codec: AssetCodec::None, metadata: serde_json::json!({"version":1}), } } fn ready(manager: &AssetManager, handle: u32) { let end = Instant::now() + Duration::from_secs(3); while matches!( manager.status(handle), LoadStatus::QUEUED | LoadStatus::LOADING | LoadStatus::PENDING | LoadStatus::ACTIVE ) { assert!(Instant::now() < end); std::thread::yield_now(); } assert_eq!(manager.status(handle), LoadStatus::READY); } #[test] fn audio_loading_commit_replacement_and_unload_are_atomic_and_type_isolated() { let fixtures = fixtures(); let sound = fixtures[2].0; let music = fixtures[3].0; let mut payload = sound.to_vec(); payload.extend_from_slice(music); let bad_at = payload.len(); let mut corrupt = sound.to_vec(); corrupt[0] = 0; payload.extend(&corrupt); let mut bad = entry(3, bad_at, sound, false); bad.decoded_size += 1; let banks = Arc::new(MemoryBanks::new()); let manager = AssetManager::new( vec![entry(1, 0, sound, false), entry(2, sound.len(), music, true), bad], AssetsPayloadSource::from_bytes(payload), banks.clone(), banks.clone(), banks.clone(), ); let s = manager.load(1, 0).unwrap(); ready(&manager, s); assert!(banks.sound_bank_slot(0).is_none()); assert_eq!(manager.commit(s), AssetOpStatus::Ok); manager.apply_commits(); let old = banks.sound_bank_slot(0).unwrap(); let m = manager.load(2, 0).unwrap(); ready(&manager, m); manager.commit(m); manager.apply_commits(); assert!(old.alive.load(std::sync::atomic::Ordering::Acquire)); assert!(banks.music_bank_slot(0).is_some()); let failing = manager.load(3, 0).unwrap(); let end = Instant::now() + Duration::from_secs(3); while manager.status(failing) != LoadStatus::ERROR { assert!(Instant::now() < end); std::thread::yield_now(); } manager.apply_commits(); assert!(Arc::ptr_eq(&old, &banks.sound_bank_slot(0).unwrap())); let replacement = manager.load(1, 0).unwrap(); ready(&manager, replacement); assert!(old.alive.load(std::sync::atomic::Ordering::Acquire)); manager.commit(replacement); manager.apply_commits(); assert!(!old.alive.load(std::sync::atomic::Ordering::Acquire)); assert_eq!(manager.unload_audio(true, 0), AssetOpStatus::Ok); assert!(banks.music_bank_slot(0).is_none()); assert!(banks.sound_bank_slot(0).is_some()); assert_eq!(manager.slot_info(SlotRef::music(0)).asset_id, None); assert_eq!(manager.unload_audio(false, 0), AssetOpStatus::Ok); assert!(banks.sound_bank_slot(0).is_none()); assert_eq!(manager.unload_audio(false, 16), AssetOpStatus::InvalidState); } #[test] fn codec_tooling_rejects_overflowing_block_parameters_without_panicking() { for align in [0, 4, usize::MAX - 3, usize::MAX] { assert!(encode_ima_wav4(&[1, 2], 1, align).is_err()); assert!(decode_ima_wav4(&[0; 8], 1, 9, align, 9).is_err()); } assert!(encode_ima_wav4(&[1], 1, 65532).is_err()); assert!(decode_ima_wav4(&[0; 8], 1, usize::MAX, 8, 9).is_err()); assert!(encode_ima_wav4(&[1], 0, 256).is_err()); }