random-access-memory 3.0.0

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 mut file = ram::RandomAccessMemory::default();
  file.write(0, b"hello").await.unwrap();
}

#[async_std::test]
async fn can_write() {
  let mut 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 mut 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 mut file = ram::RandomAccessMemory::default();
  assert_eq!(file.len().await.unwrap(), 0);
  file.write(0, b"hello").await.unwrap();
  assert_eq!(file.len().await.unwrap(), 5);
  file.write(5, b" world").await.unwrap();
  assert_eq!(file.len().await.unwrap(), 11);
}

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

#[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 mut 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().await.unwrap(), 18);
  file.del(6, 2).await.unwrap();
  assert_eq!(file.len().await.unwrap(), 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().await.unwrap(), 18);
  file.del(10, 8).await.unwrap();
  assert_eq!(file.len().await.unwrap(), 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 mut 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().await.unwrap(), 18);
  file.truncate(7).await.unwrap();
  assert_eq!(file.len().await.unwrap(), 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().await.unwrap(), 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 mut 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().await.unwrap(), 18);
  file.truncate(22).await.unwrap();
  assert_eq!(file.len().await.unwrap(), 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 mut 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().await.unwrap(), 18);
  file.truncate(18).await.unwrap();
  assert_eq!(file.len().await.unwrap(), 18);
}