use super::*;
use crate::filesystem::disk_writer::SeekableDiskWriter;
fn make_small_cache(max_bytes: usize) -> WrDiskCache {
WrDiskCache::with_max_size_bytes(max_bytes)
}
#[tokio::test]
async fn test_new_constructor_mb() {
let cache = WrDiskCache::new(16); assert_eq!(cache.max_size_bytes(), 16 * 1024 * 1024);
assert_eq!(cache.current_size_bytes(), 0);
assert!(cache.is_empty().await);
}
#[tokio::test]
async fn test_with_max_size_bytes_constructor() {
let cache = WrDiskCache::with_max_size_bytes(1024); assert_eq!(cache.max_size_bytes(), 1024);
assert_eq!(cache.current_size_bytes(), 0);
}
#[tokio::test]
async fn test_write_and_read() {
let cache = make_small_cache(4096);
cache.write(0, bytes::Bytes::from("hello")).await.unwrap();
cache.write(100, bytes::Bytes::from("world")).await.unwrap();
assert_eq!(cache.size().await, 10);
assert_eq!(cache.count().await, 2);
let result = cache.read(0, 5).await.unwrap();
assert!(result.is_some());
assert_eq!(&result.unwrap()[..], b"hello");
let result = cache.read(100, 5).await.unwrap();
assert!(result.is_some());
assert_eq!(&result.unwrap()[..], b"world");
}
#[tokio::test]
async fn test_flush_returns_dirty_entries() {
let cache = make_small_cache(4096);
cache.write(0, bytes::Bytes::from("data1")).await.unwrap();
cache.write(10, bytes::Bytes::from("data2")).await.unwrap();
assert_eq!(cache.dirty_count().await, 2);
let flushed = cache.flush().await.unwrap();
assert_eq!(flushed.len(), 2);
assert_eq!(cache.dirty_count().await, 0);
assert_eq!(cache.count().await, 2);
}
#[tokio::test]
async fn test_flush_to_persists_and_marks_only_successful_snapshot_clean() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("flush-to.bin");
let cache = make_small_cache(4096);
cache
.write(7, bytes::Bytes::from_static(b"cached"))
.await
.unwrap();
let mut writer = crate::filesystem::disk_writer::CachedDiskWriter::new(&path, None, None);
writer.open().await.unwrap();
cache.flush_to(&mut writer).await.unwrap();
assert_eq!(cache.dirty_count().await, 0);
writer.flush().await.unwrap();
let data = tokio::fs::read(&path).await.unwrap();
assert_eq!(&data[7..13], b"cached");
}
#[tokio::test]
async fn test_stats_track_hits_flushes_and_safe_eviction() {
let cache = make_small_cache(100);
cache
.write(0, bytes::Bytes::from_static(b"abcd"))
.await
.unwrap();
assert!(cache.read(0, 4).await.unwrap().is_some());
assert!(cache.read(10, 1).await.unwrap().is_none());
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("stats.bin");
let mut writer = crate::filesystem::disk_writer::CachedDiskWriter::new(&path, None, None);
writer.open().await.unwrap();
cache.flush_to(&mut writer).await.unwrap();
let stats = cache.stats();
assert_eq!(stats.cache_hits, 1);
assert_eq!(stats.cache_misses, 1);
assert_eq!(stats.flush_count, 1);
assert_eq!(stats.flush_pending_write_count, 1);
assert_eq!(stats.flush_write_count, 1);
assert_eq!(stats.flush_write_bytes, 4);
assert_eq!(stats.clean_eviction_count, 0);
assert_eq!(stats.dirty_eviction_count, 0);
writer.close().await.unwrap();
}
#[test]
fn test_coalesce_flush_entries_only_merges_contiguous_ranges() {
let adjacent = vec![
(0, bytes::Bytes::from_static(b"ab"), 1),
(2, bytes::Bytes::from_static(b"cd"), 2),
(10, bytes::Bytes::from_static(b"ef"), 3),
];
let coalesced = super::coalesce_flush_entries(&adjacent);
assert_eq!(coalesced.len(), 2);
assert_eq!(coalesced[0].0, 0);
assert_eq!(&coalesced[0].1[..], b"abcd");
assert_eq!(coalesced[1].0, 10);
assert_eq!(&coalesced[1].1[..], b"ef");
}
#[tokio::test]
async fn test_clear_resets_cache() {
let cache = make_small_cache(4096);
cache
.write(0, bytes::Bytes::from(vec![0x42; 100]))
.await
.unwrap();
assert_eq!(cache.size().await, 100);
cache.clear().await.unwrap();
assert_eq!(cache.size().await, 0);
assert!(cache.is_empty().await);
assert_eq!(cache.count().await, 0);
}
#[tokio::test]
async fn test_cache_eviction_under_memory_pressure() {
let cache = make_small_cache(500);
cache
.write(0, bytes::Bytes::from(vec![0u8; 100]))
.await
.unwrap(); cache
.write(100, bytes::Bytes::from(vec![1u8; 100]))
.await
.unwrap(); cache
.write(200, bytes::Bytes::from(vec![2u8; 100]))
.await
.unwrap(); assert_eq!(cache.count().await, 3);
assert_eq!(cache.size().await, 300);
cache.flush().await.unwrap();
assert_eq!(cache.dirty_count().await, 0);
assert_eq!(cache.count().await, 3);
cache
.write(300, bytes::Bytes::from(vec![3u8; 100]))
.await
.unwrap(); cache
.write(400, bytes::Bytes::from(vec![4u8; 100]))
.await
.unwrap();
cache
.write(500, bytes::Bytes::from(vec![5u8; 100]))
.await
.unwrap();
let final_count = cache.count().await;
let final_size = cache.size().await;
assert!(
final_count <= 5,
"Expected at most 5 entries after eviction, got {}",
final_count
);
let entry_0 = cache.read(0, 100).await.unwrap();
assert!(
entry_0.is_none(),
"Oldest clean entry (offset 0) should have been evicted"
);
debug!(
"Eviction test: final count={}, final_size={}, expected ~<=500",
final_count, final_size
);
}
#[tokio::test]
async fn test_dirty_entries_are_never_evicted() {
let cache = make_small_cache(400);
cache
.write(0, bytes::Bytes::from(vec![0xAA; 100]))
.await
.unwrap(); cache
.write(100, bytes::Bytes::from(vec![0xBB; 100]))
.await
.unwrap(); cache
.write(200, bytes::Bytes::from(vec![0xCC; 100]))
.await
.unwrap(); cache
.write(300, bytes::Bytes::from(vec![0xDD; 100]))
.await
.unwrap();
assert_eq!(cache.dirty_count().await, 4);
assert_eq!(cache.count().await, 4);
cache
.write(400, bytes::Bytes::from(vec![0xEE; 100]))
.await
.unwrap();
assert_eq!(
cache.count().await,
5,
"All dirty entries must be preserved -- none should be evicted"
);
assert_eq!(
cache.dirty_count().await,
5,
"All entries must still be dirty"
);
for (offset, byte_val) in [
(0u64, 0xAAu8),
(100, 0xBB),
(200, 0xCC),
(300, 0xDD),
(400, 0xEE),
] {
let result = cache.read(offset, 100).await.unwrap();
assert!(
result.is_some(),
"Dirty entry at offset {} must still exist",
offset
);
let data = result.unwrap();
assert!(
data.iter().all(|&b| b == byte_val),
"Data integrity check failed for offset {}: expected 0x{:02X}",
offset,
byte_val
);
}
let flushed = cache.flush().await.unwrap();
assert_eq!(flushed.len(), 5, "Flush must return all 5 dirty entries");
}
#[tokio::test]
async fn test_mixed_dirty_and_clean_eviction() {
let cache = make_small_cache(500);
cache
.write(0, bytes::Bytes::from(vec![1u8; 100]))
.await
.unwrap(); cache
.write(100, bytes::Bytes::from(vec![2u8; 100]))
.await
.unwrap(); cache.flush().await.unwrap();
cache
.write(200, bytes::Bytes::from(vec![3u8; 100]))
.await
.unwrap(); cache
.write(300, bytes::Bytes::from(vec![4u8; 100]))
.await
.unwrap();
cache
.write(400, bytes::Bytes::from(vec![5u8; 100]))
.await
.unwrap(); cache
.write(500, bytes::Bytes::from(vec![6u8; 100]))
.await
.unwrap();
let dirty_cnt = cache.dirty_count().await;
let total_cnt = cache.count().await;
assert!(
dirty_cnt >= 4,
"At least 4 dirty entries must survive, got {}",
dirty_cnt
);
assert!(
total_cnt <= 6,
"Total entries should be bounded, got {}",
total_cnt
);
for (offset, expected_byte) in [(200, 3u8), (300, 4), (400, 5), (500, 6)] {
let result = cache.read(offset, 100).await.unwrap();
assert!(
result.is_some(),
"Dirty entry at offset {} must survive eviction",
offset
);
assert_eq!(result.unwrap()[0], expected_byte);
}
debug!("Mixed eviction: total={}, dirty={}", total_cnt, dirty_cnt);
}
#[tokio::test]
async fn test_flush_then_evict_frees_space() {
let cache = make_small_cache(300);
cache
.write(0, bytes::Bytes::from(vec![0u8; 150]))
.await
.unwrap();
cache.flush().await.unwrap(); assert_eq!(cache.dirty_count().await, 0);
cache
.write(200, bytes::Bytes::from(vec![1u8; 150]))
.await
.unwrap();
cache
.write(400, bytes::Bytes::from(vec![2u8; 150]))
.await
.unwrap();
let _old_entry = cache.read(0, 150).await.unwrap();
let new_entry = cache.read(200, 150).await.unwrap();
assert!(new_entry.is_some(), "Newer dirty entry must survive");
}
#[tokio::test]
async fn test_eviction_to_target_ratio() {
let cache = make_small_cache(1000);
for i in 0..20 {
cache
.write((i * 50) as u64, bytes::Bytes::from(vec![i as u8; 50]))
.await
.unwrap();
}
cache.flush().await.unwrap();
cache
.write(2000, bytes::Bytes::from(vec![0xFF; 50]))
.await
.unwrap();
let size = cache.size().await;
let count = cache.count().await;
assert!(
size <= 550, "After eviction, size ({}) should be near target (~500), max is 1000",
size
);
debug!(
"Eviction to target: size={} bytes, count={} entries",
size, count
);
}
#[tokio::test]
async fn test_current_size_bytes_lock_free() {
let cache = make_small_cache(4096);
cache
.write(0, bytes::Bytes::from(vec![0u8; 256]))
.await
.unwrap();
cache
.write(256, bytes::Bytes::from(vec![1u8; 256]))
.await
.unwrap();
let lock_free_size = cache.current_size_bytes();
let locked_size = cache.size().await;
assert_eq!(lock_free_size, locked_size);
assert_eq!(lock_free_size, 512);
}
#[tokio::test]
async fn test_read_miss_returns_none() {
let cache = make_small_cache(1024);
cache.write(0, bytes::Bytes::from("hello")).await.unwrap();
assert!(cache.read(999, 5).await.unwrap().is_none());
assert!(cache.read(0, 100).await.unwrap().is_none());
}
#[tokio::test]
async fn test_range_based_read() {
let cache = make_small_cache(4096);
cache
.write(0, bytes::Bytes::from(vec![42u8; 100]))
.await
.unwrap();
let result = cache.read(10, 30).await.unwrap();
assert!(result.is_some());
let data = result.unwrap();
assert_eq!(data.len(), 30);
assert!(data.iter().all(|&b| b == 42));
}
#[tokio::test]
async fn test_overlapping_writes_are_last_write_wins() {
let cache = make_small_cache(4096);
cache
.write(0, bytes::Bytes::from_static(b"abcdefghij"))
.await
.unwrap();
cache
.write(5, bytes::Bytes::from_static(b"XYZ"))
.await
.unwrap();
let data = cache.read(0, 10).await.unwrap().unwrap();
assert_eq!(&data[..], b"abcdeXYZij");
assert_eq!(cache.size().await, 10);
assert_eq!(cache.count().await, 3);
assert_eq!(&cache.read(3, 7).await.unwrap().unwrap()[..], b"deXYZij");
}
#[tokio::test]
async fn test_overlapping_writes_flush_latest_bytes_to_disk() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("overlap.bin");
let cache = make_small_cache(4096);
cache
.write(5, bytes::Bytes::from_static(b"XYZ"))
.await
.unwrap();
cache
.write(0, bytes::Bytes::from_static(b"abcdefghij"))
.await
.unwrap();
let mut writer = crate::filesystem::disk_writer::CachedDiskWriter::new(&path, None, None);
writer.open().await.unwrap();
cache.flush_to(&mut writer).await.unwrap();
let data = tokio::fs::read(&path).await.unwrap();
assert_eq!(&data[..], b"abcdefghij");
}
#[tokio::test]
async fn test_cache_rejects_ranges_that_overflow_u64() {
let cache = make_small_cache(4096);
assert!(
cache
.write(u64::MAX, bytes::Bytes::from_static(b"x"))
.await
.is_err()
);
assert!(cache.read(u64::MAX, 2).await.is_err());
}
#[tokio::test]
async fn test_multiple_flushes_only_return_dirty() {
let cache = make_small_cache(4096);
cache.write(0, bytes::Bytes::from("A")).await.unwrap();
cache.write(1, bytes::Bytes::from("B")).await.unwrap();
let f1 = cache.flush().await.unwrap();
assert_eq!(f1.len(), 2);
let f2 = cache.flush().await.unwrap();
assert_eq!(f2.len(), 0);
cache.write(2, bytes::Bytes::from("C")).await.unwrap();
let f3 = cache.flush().await.unwrap();
assert_eq!(f3.len(), 1);
assert_eq!(f3[0].offset(), 2);
}
#[tokio::test]
async fn test_empty_cache_operations() {
let cache = make_small_cache(1024);
assert!(cache.is_empty().await);
assert_eq!(cache.size().await, 0);
assert_eq!(cache.count().await, 0);
assert_eq!(cache.dirty_count().await, 0);
assert!(cache.read(0, 10).await.unwrap().is_none());
let flushed = cache.flush().await.unwrap();
assert!(flushed.is_empty());
cache.clear().await.unwrap();
assert!(cache.is_empty().await);
}
#[tokio::test]
async fn test_large_write_exceeding_max_with_only_dirty_entries() {
let cache = make_small_cache(100);
cache
.write(0, bytes::Bytes::from(vec![0u8; 200]))
.await
.unwrap();
assert_eq!(cache.count().await, 1);
assert_eq!(cache.size().await, 200);
assert_eq!(cache.dirty_count().await, 1);
let result = cache.read(0, 200).await.unwrap();
assert!(result.is_some());
assert_eq!(result.unwrap().len(), 200);
}