random-access-memory 4.0.0-alpha

Continuously read and write to memory using random offsets and lengths
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use random_access_memory as ram;
use random_access_storage::RandomAccess;

#[async_std::test]
async fn can_call_new() {
    let _file = ram::RandomAccessMemory::default();
}

#[async_std::test]
async fn can_open_buffer() {
    let file = ram::RandomAccessMemory::default();
    file.write(0, b"hello").await.unwrap();
}

#[async_std::test]
async fn can_write() {
    let file = ram::RandomAccessMemory::default();
    file.write(0, b"hello").await.unwrap();
    file.write(5, b" world").await.unwrap();
}

#[async_std::test]
async fn can_read() {
    let file = ram::RandomAccessMemory::default();
    file.write(0, b"hello").await.unwrap();
    file.write(5, b" world").await.unwrap();
    let text = file.read(0, 11).await.unwrap();
    let text = String::from_utf8(text.to_vec()).unwrap();
    assert_eq!(text, "hello world");
}

#[async_std::test]
async fn can_len() {
    let file = ram::RandomAccessMemory::default();
    assert_eq!(file.len(), 0);
    file.write(0, b"hello").await.unwrap();
    assert_eq!(file.len(), 5);
    file.write(5, b" world").await.unwrap();
    assert_eq!(file.len(), 11);
}

#[async_std::test]
async fn can_is_empty() {
    let file = ram::RandomAccessMemory::default();
    assert!(file.is_empty());
    file.write(0, b"hello").await.unwrap();
    assert!(!file.is_empty());
}

#[async_std::test]
async fn can_delete() {
    assert_delete(100).await;
    assert_delete(10).await;
    assert_delete(5).await;
    assert_delete(2).await;
    assert_delete(1).await;
}

async fn assert_delete(page_size: usize) {
    let file = ram::RandomAccessMemory::new(page_size);
    file.write(0, b"hello").await.unwrap();
    file.write(5, b" world").await.unwrap();
    file.write(11, b" people").await.unwrap();
    assert_eq!(file.len(), 18);
    file.del(6, 2).await.unwrap();
    assert_eq!(file.len(), 18);
    let text = file.read(0, 6).await.unwrap();
    assert_eq!(String::from_utf8(text.to_vec()).unwrap(), "hello ");
    let zeros = file.read(6, 2).await.unwrap();
    assert_eq!(zeros, [0, 0]);
    let text = file.read(8, 10).await.unwrap();
    assert_eq!(String::from_utf8(text.to_vec()).unwrap(), "rld people");
    file.del(8, 4).await.unwrap();
    assert_eq!(file.len(), 18);
    file.del(10, 8).await.unwrap();
    assert_eq!(file.len(), 10);
}

#[async_std::test]
async fn can_truncate_lt() {
    assert_truncate_lt(100).await;
    assert_truncate_lt(10).await;
    assert_truncate_lt(5).await;
    assert_truncate_lt(2).await;
    assert_truncate_lt(1).await;
}

async fn assert_truncate_lt(page_size: usize) {
    let file = ram::RandomAccessMemory::new(page_size);
    file.write(0, b"hello").await.unwrap();
    file.write(5, b" world").await.unwrap();
    file.write(11, b" people").await.unwrap();
    assert_eq!(file.len(), 18);
    file.truncate(7).await.unwrap();
    assert_eq!(file.len(), 7);
    let text = file.read(0, 7).await.unwrap();
    assert_eq!(String::from_utf8(text.to_vec()).unwrap(), "hello w");
    if file.read(0, 8).await.is_ok() {
        panic!("storage is too big. read past the end should have failed");
    };
    file.write(11, b" people").await.unwrap();
    assert_eq!(file.len(), 18);
    let zeros = file.read(7, 4).await.unwrap();
    assert_eq!(zeros, [0, 0, 0, 0]);
}

#[async_std::test]
async fn can_truncate_gt() {
    assert_truncate_gt(100).await;
    assert_truncate_gt(10).await;
    assert_truncate_gt(5).await;
    assert_truncate_gt(2).await;
    assert_truncate_gt(1).await;
}

async fn assert_truncate_gt(page_size: usize) {
    let file = ram::RandomAccessMemory::new(page_size);
    file.write(0, b"hello").await.unwrap();
    file.write(5, b" world").await.unwrap();
    file.write(11, b" people").await.unwrap();
    assert_eq!(file.len(), 18);
    file.truncate(22).await.unwrap();
    assert_eq!(file.len(), 22);
    let zeros = file.read(18, 4).await.unwrap();
    assert_eq!(zeros, [0, 0, 0, 0]);
    file.write(19, &[1]).await.unwrap();
    let written = file.read(18, 4).await.unwrap();
    assert_eq!(written, [0, 1, 0, 0]);
}

#[async_std::test]
async fn assert_truncate_eq() {
    let file = ram::RandomAccessMemory::new(5);
    file.write(0, b"hello").await.unwrap();
    file.write(5, b" world").await.unwrap();
    file.write(11, b" people").await.unwrap();
    assert_eq!(file.len(), 18);
    file.truncate(18).await.unwrap();
    assert_eq!(file.len(), 18);
}