platform-mem 0.2.0

Memory for linksplatform
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Tests for AsyncFileMem (moved from src/async_mem.rs per project conventions)

use platform_mem::AsyncFileMem;

#[tokio::test]
async fn test_async_file_mem_temp_and_grow() {
    let mem = AsyncFileMem::<u64>::temp().unwrap();
    assert!(mem.is_empty().await.unwrap());

    mem.grow_filled(10, 42).await.unwrap();
    assert_eq!(mem.len().await.unwrap(), 10);
    assert_eq!(mem.get(0).await.unwrap(), Some(42));
    assert_eq!(mem.get(9).await.unwrap(), Some(42));
    assert_eq!(mem.get(10).await.unwrap(), None);
}

#[tokio::test]
async fn test_async_file_mem_persistence() {
    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("persist.bin");

    // Write data
    {
        let mut mem = AsyncFileMem::<u64>::from_path(&path).unwrap();
        mem.grow_filled(5, 123).await.unwrap();
        mem.set(2, 456).await.unwrap();
        mem.shutdown().await.unwrap();
    }

    // Read data back — use grow_assumed to map existing file data
    {
        let mem = AsyncFileMem::<u64>::from_path(&path).unwrap();
        unsafe { mem.grow_assumed(5).await.unwrap() };
        assert_eq!(mem.len().await.unwrap(), 5);
        assert_eq!(mem.get(0).await.unwrap(), Some(123));
        assert_eq!(mem.get(2).await.unwrap(), Some(456));
    }
}

#[tokio::test]
async fn test_async_file_mem_shrink() {
    let mem = AsyncFileMem::<u64>::temp().unwrap();
    mem.grow_filled(20, 1).await.unwrap();
    assert_eq!(mem.len().await.unwrap(), 20);

    mem.shrink(5).await.unwrap();
    assert_eq!(mem.len().await.unwrap(), 15);
}

#[tokio::test]
async fn test_async_file_mem_grow_zeroed() {
    let mem = AsyncFileMem::<u64>::temp().unwrap();
    unsafe {
        mem.grow_zeroed(10).await.unwrap();
    }
    assert_eq!(mem.len().await.unwrap(), 10);
    for i in 0..10 {
        assert_eq!(mem.get(i).await.unwrap(), Some(0));
    }
}

#[tokio::test]
async fn test_async_file_mem_read_write_slice() {
    let mem = AsyncFileMem::<u64>::temp().unwrap();
    mem.grow_filled(10, 0).await.unwrap();

    mem.write_slice(3, vec![10, 20, 30]).await.unwrap();

    let data = mem.read_slice(3, 3).await.unwrap();
    assert_eq!(data, vec![10, 20, 30]);

    assert_eq!(mem.get(2).await.unwrap(), Some(0));
    assert_eq!(mem.get(6).await.unwrap(), Some(0));
}

#[tokio::test]
async fn test_async_file_mem_set_get() {
    let mem = AsyncFileMem::<u64>::temp().unwrap();
    mem.grow_filled(5, 0).await.unwrap();

    assert!(mem.set(0, 100).await.unwrap());
    assert!(mem.set(4, 400).await.unwrap());
    assert!(!mem.set(5, 500).await.unwrap()); // out of bounds

    assert_eq!(mem.get(0).await.unwrap(), Some(100));
    assert_eq!(mem.get(4).await.unwrap(), Some(400));
}

#[tokio::test]
async fn test_async_file_mem_multiple_grows() {
    let mem = AsyncFileMem::<u64>::temp().unwrap();

    mem.grow_filled(5, 1).await.unwrap();
    mem.grow_filled(5, 2).await.unwrap();
    mem.grow_filled(5, 3).await.unwrap();

    assert_eq!(mem.len().await.unwrap(), 15);
    assert_eq!(mem.get(0).await.unwrap(), Some(1));
    assert_eq!(mem.get(5).await.unwrap(), Some(2));
    assert_eq!(mem.get(10).await.unwrap(), Some(3));
}

#[tokio::test]
async fn test_async_file_mem_sequential_operations() {
    let mem = AsyncFileMem::<u64>::temp().unwrap();
    mem.grow_filled(100, 0).await.unwrap();

    for i in 0..10u64 {
        mem.set(i as usize, i * 10).await.unwrap();
    }

    for i in 0..10u64 {
        assert_eq!(mem.get(i as usize).await.unwrap(), Some(i * 10));
    }
}