asnfuzzgen_codecs/per/aper/encode/
mod.rs

1//! ASN.1 Aper Encoder module.
2
3use bitvec::prelude::*;
4
5use crate::per::PerCodecData;
6
7#[allow(unused)]
8use crate::per::common::encode::*;
9
10use crate::PerCodecError;
11
12/// Encode a Choice Index
13///
14/// During Encoding a 'CHOICE' Type to help decoding, the 'CHOICE' Index is encoded first, followed
15/// by the actual encoding of the 'CHOICE' variant.
16pub fn encode_choice_idx(
17    data: &mut PerCodecData,
18    lb: i128,
19    ub: i128,
20    is_extensible: bool,
21    idx: i128,
22    extended: bool,
23) -> Result<(), PerCodecError> {
24
25    encode_choice_idx_common(data, lb, ub, is_extensible, idx, extended, true)
26}
27
28/// Encode sequence header
29pub fn encode_sequence_header(
30    data: &mut PerCodecData,
31    is_extensible: bool,
32    optionals: &BitSlice<u8, Msb0>,
33    extended: bool,
34) -> Result<(), PerCodecError> {
35
36    encode_sequence_header_common(data, is_extensible, optionals, extended, true)
37}
38
39/// Encode an INTEGER
40///
41/// This API is also used by other `encode` functions to encode an integer value.
42///
43/// Note: The maximum (and minimum) value to be decoded is limited to an `i128` value. For the
44/// protocols that are currently supported this limit is acceptable.
45pub fn encode_integer(
46    data: &mut PerCodecData,
47    lb: Option<i128>,
48    ub: Option<i128>,
49    is_extensible: bool,
50    value: i128,
51    extended: bool,
52) -> Result<(), PerCodecError> {
53
54    encode_integer_common(data, lb, ub, is_extensible, value, extended, true)
55}
56
57/// Encode a BOOLEAN Value
58///
59/// Encodes a boolean value into the passed `PerCodecData` structure.
60pub fn encode_bool(data: &mut PerCodecData, value: bool) -> Result<(), PerCodecError> {
61
62    encode_bool_common(data, value, true)
63}
64
65/// Encode an ENUMERATED Value
66pub fn encode_enumerated(
67    data: &mut PerCodecData,
68    lb: Option<i128>,
69    ub: Option<i128>,
70    is_extensible: bool,
71    value: i128,
72    extended: bool,
73) -> Result<(), PerCodecError> {
74
75    encode_enumerated_common(data, lb, ub, is_extensible, value, extended, true)
76}
77
78/// Encode a Bit String
79pub fn encode_bitstring(
80    data: &mut PerCodecData,
81    lb: Option<i128>,
82    ub: Option<i128>,
83    is_extensible: bool,
84    bit_string: &BitSlice<u8, Msb0>,
85    extended: bool,
86) -> Result<(), PerCodecError> {
87
88    encode_bitstring_common(data, lb, ub, is_extensible, bit_string, extended, true)
89}
90
91/// Encode an OCTET STRING
92pub fn encode_octetstring(
93    data: &mut PerCodecData,
94    lb: Option<i128>,
95    ub: Option<i128>,
96    is_extensible: bool,
97    octet_string: &Vec<u8>,
98    extended: bool,
99) -> Result<(), PerCodecError> {
100
101    encode_octet_string_common(data, lb, ub, is_extensible, octet_string, extended, true)
102}
103
104// Encode a Length Determinent
105pub fn encode_length_determinent(
106    data: &mut PerCodecData,
107    lb: Option<i128>,
108    ub: Option<i128>,
109    normally_small: bool,
110    value: usize,
111) -> Result<(), PerCodecError> {
112
113    encode_length_determinent_common(data, lb, ub, normally_small, value, true)
114}
115
116/// Encode a VisibleString CharacterString Type.
117pub fn encode_visible_string(
118    data: &mut PerCodecData,
119    lb: Option<i128>,
120    ub: Option<i128>,
121    is_extensible: bool,
122    value: &String,
123    extended: bool,
124) -> Result<(), PerCodecError> {
125
126    encode_string_common(data, lb, ub, is_extensible, value, extended, true)
127}
128
129/// Encode a PrintableString CharacterString Type.
130pub fn encode_printable_string(
131    data: &mut PerCodecData,
132    lb: Option<i128>,
133    ub: Option<i128>,
134    is_extensible: bool,
135    value: &String,
136    extended: bool,
137) -> Result<(), PerCodecError> {
138
139    encode_string_common(data, lb, ub, is_extensible, value, extended, true)
140}
141
142/// Encode a UTF8String CharacterString Type.
143pub fn encode_utf8_string(
144    data: &mut PerCodecData,
145    lb: Option<i128>,
146    ub: Option<i128>,
147    is_extensible: bool,
148    value: &String,
149    extended: bool,
150) -> Result<(), PerCodecError> {
151
152    encode_string_common(data, lb, ub, is_extensible, value, extended, true)
153}
154
155#[cfg(test)]
156mod tests {
157
158    use super::*;
159
160    #[test]
161    fn encode_bool_always_success() {
162        let mut data = PerCodecData::new_aper();
163
164        let result = encode_bool(&mut data, true);
165        assert!(result.is_ok());
166        assert_eq!(data.bits.len(), 1);
167        assert_eq!(data.bits[0], true);
168    }
169
170    #[test]
171    fn int_too_small() {
172        assert!(encode_integer(
173            &mut PerCodecData::new_aper(),
174            Some(1),
175            None,
176            false,
177            0,
178            false
179        )
180        .is_err());
181    }
182
183    #[test]
184    fn int_too_big() {
185        assert!(encode_integer(
186            &mut PerCodecData::new_aper(),
187            Some(-1),
188            Some(0),
189            false,
190            1,
191            false
192        )
193        .is_err());
194    }
195
196    #[test]
197    fn octetstring_too_small() {
198        assert!(encode_octetstring(
199            &mut PerCodecData::new_aper(),
200            Some(2),
201            None,
202            false,
203            &vec![0],
204            false
205        )
206        .is_err());
207    }
208    #[test]
209    fn octetstring_too_big() {
210        assert!(encode_octetstring(
211            &mut PerCodecData::new_aper(),
212            None,
213            Some(1),
214            false,
215            &vec![0, 0],
216            false
217        )
218        .is_err());
219    }
220
221    #[test]
222    fn string_too_small() {
223        assert!(encode_visible_string(
224            &mut PerCodecData::new_aper(),
225            Some(2),
226            None,
227            false,
228            &"a".to_string(),
229            false
230        )
231        .is_err());
232    }
233
234    #[test]
235    fn string_too_big() {
236        assert!(encode_visible_string(
237            &mut PerCodecData::new_aper(),
238            None,
239            Some(1),
240            false,
241            &"aa".to_string(),
242            false
243        )
244        .is_err());
245    }
246
247    #[test]
248    fn length_too_small() {
249        assert!(
250            encode_length_determinent(&mut PerCodecData::new_aper(), Some(2), None, false, 1,)
251                .is_err()
252        );
253    }
254    #[test]
255    fn length_too_big() {
256        assert!(
257            encode_length_determinent(&mut PerCodecData::new_aper(), None, Some(1), false, 2,)
258                .is_err()
259        );
260    }
261
262    #[test]
263    fn big_length_too_big() {
264        assert!(encode_length_determinent(
265            &mut PerCodecData::new_aper(),
266            None,
267            Some(65536),
268            false,
269            65537,
270        )
271        .is_err());
272    }
273
274    #[test]
275    fn bitstring_too_small() {
276        assert!(encode_bitstring(
277            &mut PerCodecData::new_aper(),
278            Some(2),
279            None,
280            false,
281            bits![u8, Msb0; 0],
282            false
283        )
284        .is_err());
285    }
286
287    #[test]
288    fn bitstring_too_big() {
289        assert!(encode_bitstring(
290            &mut PerCodecData::new_aper(),
291            None,
292            Some(1),
293            false,
294            bits![u8, Msb0; 0, 0],
295            false
296        )
297        .is_err());
298    }
299}
asnfuzzgen_codecs/per/aper/encode/mod.rs

asnfuzzgen_codecs/per/aper/encode/
mod.rs
