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
141
142
143
|
use borsh::{from_reader, to_vec, BorshDeserialize, BorshSerialize};
use alloc::{
string::{String, ToString},
vec::Vec,
};
const ERROR_NOT_ALL_BYTES_READ: &str = "Not all bytes read";
const ERROR_UNEXPECTED_LENGTH_OF_INPUT: &str = "Unexpected length of input";
#[derive(BorshSerialize, BorshDeserialize, Debug)]
struct Serializable {
item1: i32,
item2: String,
item3: f64,
}
#[test]
fn test_custom_reader() {
let s = Serializable {
item1: 100,
item2: "foo".into(),
item3: 1.2345,
};
let bytes = to_vec(&s).unwrap();
let mut reader = CustomReader {
data: bytes,
read_index: 0,
};
let de: Serializable = BorshDeserialize::deserialize_reader(&mut reader).unwrap();
assert_eq!(de.item1, s.item1);
assert_eq!(de.item2, s.item2);
assert_eq!(de.item3, s.item3);
}
#[test]
fn test_custom_reader_with_insufficient_data() {
let s = Serializable {
item1: 100,
item2: "foo".into(),
item3: 1.2345,
};
let mut bytes = to_vec(&s).unwrap();
bytes.pop().unwrap();
let mut reader = CustomReader {
data: bytes,
read_index: 0,
};
assert_eq!(
<Serializable as BorshDeserialize>::deserialize_reader(&mut reader)
.unwrap_err()
.to_string(),
ERROR_UNEXPECTED_LENGTH_OF_INPUT
);
}
#[test]
fn test_custom_reader_with_too_much_data() {
let s = Serializable {
item1: 100,
item2: "foo".into(),
item3: 1.2345,
};
let mut bytes = to_vec(&s).unwrap();
bytes.push(1);
let mut reader = CustomReader {
data: bytes,
read_index: 0,
};
assert_eq!(
from_reader::<CustomReader, Serializable>(&mut reader)
.unwrap_err()
.to_string(),
ERROR_NOT_ALL_BYTES_READ
);
}
struct CustomReader {
data: Vec<u8>,
read_index: usize,
}
impl borsh::io::Read for CustomReader {
fn read(&mut self, buf: &mut [u8]) -> borsh::io::Result<usize> {
let len = buf.len().min(self.data.len() - self.read_index);
buf[0..len].copy_from_slice(&self.data[self.read_index..self.read_index + len]);
self.read_index += len;
Ok(len)
}
}
#[test]
fn test_custom_reader_that_doesnt_fill_slices() {
let s = Serializable {
item1: 100,
item2: "foo".into(),
item3: 1.2345,
};
let bytes = to_vec(&s).unwrap();
let mut reader = CustomReaderThatDoesntFillSlices {
data: bytes,
read_index: 0,
};
let de: Serializable = BorshDeserialize::deserialize_reader(&mut reader).unwrap();
assert_eq!(de.item1, s.item1);
assert_eq!(de.item2, s.item2);
assert_eq!(de.item3, s.item3);
}
struct CustomReaderThatDoesntFillSlices {
data: Vec<u8>,
read_index: usize,
}
impl borsh::io::Read for CustomReaderThatDoesntFillSlices {
fn read(&mut self, buf: &mut [u8]) -> borsh::io::Result<usize> {
let len = buf.len().min(self.data.len() - self.read_index);
let len = if len <= 1 { len } else { len / 2 };
buf[0..len].copy_from_slice(&self.data[self.read_index..self.read_index + len]);
self.read_index += len;
Ok(len)
}
}
#[test]
fn test_custom_reader_that_fails_preserves_error_information() {
let mut reader = CustomReaderThatFails;
let err = from_reader::<CustomReaderThatFails, Serializable>(&mut reader).unwrap_err();
assert_eq!(err.to_string(), "I don't like to run");
assert_eq!(err.kind(), borsh::io::ErrorKind::ConnectionAborted);
}
struct CustomReaderThatFails;
impl borsh::io::Read for CustomReaderThatFails {
fn read(&mut self, _buf: &mut [u8]) -> borsh::io::Result<usize> {
Err(borsh::io::Error::new(
borsh::io::ErrorKind::ConnectionAborted,
"I don't like to run",
))
}
}
|
