1 // Copyright 2016 Masaki Hara
2 // Copyright 2017 Fortanix, Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
5 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
7 // option. This file may not be copied, modified, or distributed
8 // except according to those terms.
9
10 #[cfg(feature = "num-bigint")]
11 use num_bigint::{BigUint, BigInt};
12
13 use super::super::Tag;
14 use super::super::tags::TAG_SEQUENCE;
15 use super::*;
16
17 #[test]
test_der_read_bool_ok()18 fn test_der_read_bool_ok() {
19 let tests : &[(bool, &[u8])] = &[
20 (false, &[1, 1, 0]),
21 (true, &[1, 1, 255]),
22 ];
23 for &(evalue, data) in tests {
24 let value = parse_der(data, |reader| {
25 reader.read_bool()
26 }).unwrap();
27 assert_eq!(value, evalue);
28 }
29 }
30
31 #[test]
test_der_read_bool_err()32 fn test_der_read_bool_err() {
33 let tests : &[&[u8]] = &[
34 &[], &[1], &[0, 0], &[0, 1, 0], &[2, 1, 0], &[33, 1, 0], &[65, 1, 0],
35 &[1, 0], &[1, 2, 0, 0], &[1, 128, 1, 1, 0, 0, 0],
36 &[1, 1, 1], &[1, 1, 191], &[1, 1, 254],
37 ];
38 for &data in tests {
39 parse_der(data, |reader| {
40 reader.read_bool()
41 }).unwrap_err();
42 }
43 }
44
45 #[test]
test_ber_read_bool_ok()46 fn test_ber_read_bool_ok() {
47 let tests : &[(bool, &[u8])] = &[
48 (false, &[1, 1, 0]),
49 (true, &[1, 1, 1]),
50 (true, &[1, 1, 191]),
51 (true, &[1, 1, 254]),
52 (true, &[1, 1, 255]),
53 ];
54 for &(evalue, data) in tests {
55 let value = parse_ber(data, |reader| {
56 reader.read_bool()
57 }).unwrap();
58 assert_eq!(value, evalue);
59 }
60 }
61
62 #[test]
test_ber_read_bool_err()63 fn test_ber_read_bool_err() {
64 let tests : &[&[u8]] = &[
65 &[], &[1], &[0, 0], &[0, 1, 0], &[2, 1, 0], &[33, 1, 0], &[65, 1, 0],
66 &[1, 0], &[1, 2, 0, 0], &[1, 128, 1, 1, 0, 0, 0],
67 ];
68 for &data in tests {
69 parse_ber(data, |reader| {
70 reader.read_bool()
71 }).unwrap_err();
72 }
73 }
74
75 #[test]
test_der_read_i64_ok()76 fn test_der_read_i64_ok() {
77 test_general_read_i64_ok(BERMode::Der);
78 }
79
80 #[test]
test_der_read_i64_err()81 fn test_der_read_i64_err() {
82 test_general_read_i64_err(BERMode::Der);
83 }
84
85 #[test]
test_ber_read_i64_ok()86 fn test_ber_read_i64_ok() {
87 test_general_read_i64_ok(BERMode::Ber);
88 }
89
90 #[test]
test_ber_read_i64_err()91 fn test_ber_read_i64_err() {
92 test_general_read_i64_err(BERMode::Ber);
93 }
94
test_general_read_i64_ok(mode: BERMode)95 fn test_general_read_i64_ok(mode: BERMode) {
96 let tests : &[(i64, &[u8])] = &[
97 (-9223372036854775808, &[2, 8, 128, 0, 0, 0, 0, 0, 0, 0]),
98 (-65537, &[2, 3, 254, 255, 255]),
99 (-65536, &[2, 3, 255, 0, 0]),
100 (-32769, &[2, 3, 255, 127, 255]),
101 (-32768, &[2, 2, 128, 0]),
102 (-129, &[2, 2, 255, 127]),
103 (-128, &[2, 1, 128]),
104 (-1, &[2, 1, 255]),
105 (0, &[2, 1, 0]),
106 (1, &[2, 1, 1]),
107 (127, &[2, 1, 127]),
108 (128, &[2, 2, 0, 128]),
109 (32767, &[2, 2, 127, 255]),
110 (32768, &[2, 3, 0, 128, 0]),
111 (65535, &[2, 3, 0, 255, 255]),
112 (65536, &[2, 3, 1, 0, 0]),
113 (9223372036854775807, &[2, 8, 127, 255, 255, 255, 255, 255, 255, 255]),
114 ];
115 for &(evalue, data) in tests {
116 let value = parse_ber_general(data, mode, |reader| {
117 reader.read_i64()
118 }).unwrap();
119 assert_eq!(value, evalue);
120 }
121 }
122
test_general_read_i64_err(mode: BERMode)123 fn test_general_read_i64_err(mode: BERMode) {
124 let tests : &[&[u8]] = &[
125 &[], &[2], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[34, 1, 0], &[66, 1, 0],
126 &[2, 0], &[2, 128, 2, 1, 0, 0, 0], &[2, 2, 0], &[2, 1, 1, 1],
127 &[2, 2, 255, 128], &[2, 2, 255, 200], &[2, 2, 0, 127], &[2, 2, 0, 56],
128 &[2, 3, 255, 151, 55], &[2, 3, 0, 1, 2],
129 &[2, 9, 255, 0, 0, 0, 0, 0, 0, 0, 0],
130 &[2, 9, 255, 127, 255, 255, 255, 255, 255, 255, 255],
131 &[2, 9, 0, 128, 0, 0, 0, 0, 0, 0, 0],
132 &[2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255],
133 ];
134 for &data in tests {
135 parse_ber_general(data, mode, |reader| {
136 reader.read_i64()
137 }).unwrap_err();
138 }
139 }
140
141 #[test]
test_der_read_u64_ok()142 fn test_der_read_u64_ok() {
143 test_general_read_u64_ok(BERMode::Der);
144 }
145
146 #[test]
test_der_read_u64_err()147 fn test_der_read_u64_err() {
148 test_general_read_u64_err(BERMode::Der);
149 }
150
151 #[test]
test_ber_read_u64_ok()152 fn test_ber_read_u64_ok() {
153 test_general_read_u64_ok(BERMode::Ber);
154 }
155
156 #[test]
test_ber_read_u64_err()157 fn test_ber_read_u64_err() {
158 test_general_read_u64_err(BERMode::Ber);
159 }
160
test_general_read_u64_ok(mode: BERMode)161 fn test_general_read_u64_ok(mode: BERMode) {
162 let tests : &[(u64, &[u8])] = &[
163 (0, &[2, 1, 0]),
164 (1, &[2, 1, 1]),
165 (127, &[2, 1, 127]),
166 (128, &[2, 2, 0, 128]),
167 (32767, &[2, 2, 127, 255]),
168 (32768, &[2, 3, 0, 128, 0]),
169 (65535, &[2, 3, 0, 255, 255]),
170 (65536, &[2, 3, 1, 0, 0]),
171 (9223372036854775807, &[2, 8, 127, 255, 255, 255, 255, 255, 255, 255]),
172 (18446744073709551615,
173 &[2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255]),
174 ];
175 for &(evalue, data) in tests {
176 let value = parse_ber_general(data, mode, |reader| {
177 reader.read_u64()
178 }).unwrap();
179 assert_eq!(value, evalue);
180 }
181 }
182
test_general_read_u64_err(mode: BERMode)183 fn test_general_read_u64_err(mode: BERMode) {
184 let tests : &[&[u8]] = &[
185 &[], &[2], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[34, 1, 0], &[66, 1, 0],
186 &[2, 0], &[2, 128, 2, 1, 0, 0, 0], &[2, 2, 0], &[2, 1, 1, 1],
187 &[2, 2, 255, 128], &[2, 2, 255, 200], &[2, 2, 0, 127], &[2, 2, 0, 56],
188 &[2, 3, 255, 151, 55], &[2, 3, 0, 1, 2],
189 &[2, 8, 128, 0, 0, 0, 0, 0, 0, 0], &[2, 3, 254, 255, 255],
190 &[2, 3, 255, 0, 0], &[2, 3, 255, 127, 255], &[2, 2, 128, 0],
191 &[2, 2, 255, 127], &[2, 1, 128], &[2, 1, 255],
192 &[2, 9, 1, 0, 0, 0, 0, 0, 0, 0, 0],
193 &[2, 9, 1, 128, 0, 0, 0, 0, 0, 0, 0],
194 ];
195 for &data in tests {
196 parse_ber_general(data, mode, |reader| {
197 reader.read_u64()
198 }).unwrap_err();
199 }
200 }
201
202 #[test]
test_der_read_i32_ok()203 fn test_der_read_i32_ok() {
204 test_general_read_i32_ok(BERMode::Der);
205 }
206
207 #[test]
test_der_read_i32_err()208 fn test_der_read_i32_err() {
209 test_general_read_i32_err(BERMode::Der);
210 }
211
212 #[test]
test_ber_read_i32_ok()213 fn test_ber_read_i32_ok() {
214 test_general_read_i32_ok(BERMode::Ber);
215 }
216
217 #[test]
test_ber_read_i32_err()218 fn test_ber_read_i32_err() {
219 test_general_read_i32_err(BERMode::Ber);
220 }
221
test_general_read_i32_ok(mode: BERMode)222 fn test_general_read_i32_ok(mode: BERMode) {
223 let tests : &[(i32, &[u8])] = &[
224 (-2147483648, &[2, 4, 128, 0, 0, 0]),
225 (-65537, &[2, 3, 254, 255, 255]),
226 (-65536, &[2, 3, 255, 0, 0]),
227 (-32769, &[2, 3, 255, 127, 255]),
228 (-32768, &[2, 2, 128, 0]),
229 (-129, &[2, 2, 255, 127]),
230 (-128, &[2, 1, 128]),
231 (-1, &[2, 1, 255]),
232 (0, &[2, 1, 0]),
233 (1, &[2, 1, 1]),
234 (127, &[2, 1, 127]),
235 (128, &[2, 2, 0, 128]),
236 (32767, &[2, 2, 127, 255]),
237 (32768, &[2, 3, 0, 128, 0]),
238 (65535, &[2, 3, 0, 255, 255]),
239 (65536, &[2, 3, 1, 0, 0]),
240 (2147483647, &[2, 4, 127, 255, 255, 255]),
241 ];
242 for &(evalue, data) in tests {
243 let value = parse_ber_general(data, mode, |reader| {
244 reader.read_i32()
245 }).unwrap();
246 assert_eq!(value, evalue);
247 }
248 }
249
test_general_read_i32_err(mode: BERMode)250 fn test_general_read_i32_err(mode: BERMode) {
251 let tests : &[&[u8]] = &[
252 &[], &[2], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[34, 1, 0], &[66, 1, 0],
253 &[2, 0], &[2, 128, 2, 1, 0, 0, 0], &[2, 2, 0], &[2, 1, 1, 1],
254 &[2, 2, 255, 128], &[2, 2, 255, 200], &[2, 2, 0, 127], &[2, 2, 0, 56],
255 &[2, 3, 255, 151, 55], &[2, 3, 0, 1, 2],
256 &[2, 5, 255, 0, 0, 0, 0],
257 &[2, 5, 255, 127, 255, 255, 255],
258 &[2, 5, 0, 128, 0, 0, 0],
259 &[2, 5, 0, 255, 255, 255, 255],
260 ];
261 for &data in tests {
262 parse_ber_general(data, mode, |reader| {
263 reader.read_i32()
264 }).unwrap_err();
265 }
266 }
267
268 #[test]
test_der_read_u32_err()269 fn test_der_read_u32_err() {
270 test_general_read_u32_err(BERMode::Der);
271 }
272
273 #[test]
test_ber_read_u32_ok()274 fn test_ber_read_u32_ok() {
275 test_general_read_u32_ok(BERMode::Ber);
276 }
277
278 #[test]
test_ber_read_u32_err()279 fn test_ber_read_u32_err() {
280 test_general_read_u32_err(BERMode::Ber);
281 }
282
test_general_read_u32_ok(mode: BERMode)283 fn test_general_read_u32_ok(mode: BERMode) {
284 let tests : &[(u32, &[u8])] = &[
285 (0, &[2, 1, 0]),
286 (1, &[2, 1, 1]),
287 (127, &[2, 1, 127]),
288 (128, &[2, 2, 0, 128]),
289 (32767, &[2, 2, 127, 255]),
290 (32768, &[2, 3, 0, 128, 0]),
291 (65535, &[2, 3, 0, 255, 255]),
292 (65536, &[2, 3, 1, 0, 0]),
293 (2147483647, &[2, 4, 127, 255, 255, 255]),
294 (4294967295, &[2, 5, 0, 255, 255, 255, 255]),
295 ];
296 for &(evalue, data) in tests {
297 let value = parse_ber_general(data, mode, |reader| {
298 reader.read_u32()
299 }).unwrap();
300 assert_eq!(value, evalue);
301 }
302 }
303
test_general_read_u32_err(mode: BERMode)304 fn test_general_read_u32_err(mode: BERMode) {
305 let tests : &[&[u8]] = &[
306 &[], &[2], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[34, 1, 0], &[66, 1, 0],
307 &[2, 0], &[2, 128, 2, 1, 0, 0, 0], &[2, 2, 0], &[2, 1, 1, 1],
308 &[2, 2, 255, 128], &[2, 2, 255, 200], &[2, 2, 0, 127], &[2, 2, 0, 56],
309 &[2, 3, 255, 151, 55], &[2, 3, 0, 1, 2],
310 &[2, 4, 128, 0, 0, 0], &[2, 3, 254, 255, 255], &[2, 3, 255, 0, 0],
311 &[2, 3, 255, 127, 255], &[2, 2, 128, 0], &[2, 2, 255, 127],
312 &[2, 1, 128], &[2, 1, 255],
313 &[2, 5, 1, 0, 0, 0, 0],
314 &[2, 5, 1, 128, 0, 0, 0],
315 ];
316 for &data in tests {
317 parse_ber_general(data, mode, |reader| {
318 reader.read_u32()
319 }).unwrap_err();
320 }
321 }
322
323 #[test]
test_der_read_i16_ok()324 fn test_der_read_i16_ok() {
325 test_general_read_i16_ok(BERMode::Der);
326 }
327
328 #[test]
test_der_read_i16_err()329 fn test_der_read_i16_err() {
330 test_general_read_i16_err(BERMode::Der);
331 }
332
333 #[test]
test_ber_read_i16_ok()334 fn test_ber_read_i16_ok() {
335 test_general_read_i16_ok(BERMode::Ber);
336 }
337
338 #[test]
test_ber_read_i16_err()339 fn test_ber_read_i16_err() {
340 test_general_read_i16_err(BERMode::Ber);
341 }
342
test_general_read_i16_ok(mode: BERMode)343 fn test_general_read_i16_ok(mode: BERMode) {
344 let tests : &[(i16, &[u8])] = &[
345 (-32768, &[2, 2, 128, 0]),
346 (-129, &[2, 2, 255, 127]),
347 (-128, &[2, 1, 128]),
348 (-1, &[2, 1, 255]),
349 (0, &[2, 1, 0]),
350 (1, &[2, 1, 1]),
351 (127, &[2, 1, 127]),
352 (128, &[2, 2, 0, 128]),
353 (32767, &[2, 2, 127, 255]),
354 ];
355 for &(evalue, data) in tests {
356 let value = parse_ber_general(data, mode, |reader| {
357 reader.read_i16()
358 }).unwrap();
359 assert_eq!(value, evalue);
360 }
361 }
362
test_general_read_i16_err(mode: BERMode)363 fn test_general_read_i16_err(mode: BERMode) {
364 let tests : &[&[u8]] = &[
365 &[], &[2], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[34, 1, 0], &[66, 1, 0],
366 &[2, 0], &[2, 128, 2, 1, 0, 0, 0], &[2, 2, 0], &[2, 1, 1, 1],
367 &[2, 2, 255, 128], &[2, 2, 255, 200], &[2, 2, 0, 127], &[2, 2, 0, 56],
368 &[2, 3, 255, 151, 55], &[2, 3, 0, 1, 2],
369 &[2, 3, 255, 0, 0], &[2, 3, 255, 127, 255],
370 &[2, 3, 0, 128, 0], &[2, 3, 0, 255, 255],
371 ];
372 for &data in tests {
373 parse_ber_general(data, mode, |reader| {
374 reader.read_i16()
375 }).unwrap_err();
376 }
377 }
378
379 #[test]
test_der_read_u16_ok()380 fn test_der_read_u16_ok() {
381 test_general_read_u16_ok(BERMode::Der);
382 }
383
384 #[test]
test_der_read_u16_err()385 fn test_der_read_u16_err() {
386 test_general_read_u16_err(BERMode::Der);
387 }
388
389 #[test]
test_ber_read_u16_ok()390 fn test_ber_read_u16_ok() {
391 test_general_read_u16_ok(BERMode::Ber);
392 }
393
394 #[test]
test_ber_read_u16_err()395 fn test_ber_read_u16_err() {
396 test_general_read_u16_err(BERMode::Ber);
397 }
398
test_general_read_u16_ok(mode: BERMode)399 fn test_general_read_u16_ok(mode: BERMode) {
400 let tests : &[(u16, &[u8])] = &[
401 (0, &[2, 1, 0]),
402 (1, &[2, 1, 1]),
403 (127, &[2, 1, 127]),
404 (128, &[2, 2, 0, 128]),
405 (32767, &[2, 2, 127, 255]),
406 (65535, &[2, 3, 0, 255, 255]),
407 ];
408 for &(evalue, data) in tests {
409 let value = parse_ber_general(data, mode, |reader| {
410 reader.read_u16()
411 }).unwrap();
412 assert_eq!(value, evalue);
413 }
414 }
415
test_general_read_u16_err(mode: BERMode)416 fn test_general_read_u16_err(mode: BERMode) {
417 let tests : &[&[u8]] = &[
418 &[], &[2], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[34, 1, 0], &[66, 1, 0],
419 &[2, 0], &[2, 128, 2, 1, 0, 0, 0], &[2, 2, 0], &[2, 1, 1, 1],
420 &[2, 2, 255, 128], &[2, 2, 255, 200], &[2, 2, 0, 127], &[2, 2, 0, 56],
421 &[2, 3, 255, 151, 55], &[2, 3, 0, 1, 2],
422 &[2, 2, 128, 0], &[2, 2, 255, 127], &[2, 1, 128], &[2, 1, 255],
423 &[2, 3, 1, 0, 0], &[2, 3, 1, 128, 0],
424 ];
425 for &data in tests {
426 parse_ber_general(data, mode, |reader| {
427 reader.read_u16()
428 }).unwrap_err();
429 }
430 }
431
432 #[test]
test_der_read_i8_ok()433 fn test_der_read_i8_ok() {
434 test_general_read_i8_ok(BERMode::Der);
435 }
436
437 #[test]
test_der_read_i8_err()438 fn test_der_read_i8_err() {
439 test_general_read_i8_err(BERMode::Der);
440 }
441
442 #[test]
test_ber_read_i8_ok()443 fn test_ber_read_i8_ok() {
444 test_general_read_i8_ok(BERMode::Ber);
445 }
446
447 #[test]
test_ber_read_i8_err()448 fn test_ber_read_i8_err() {
449 test_general_read_i8_err(BERMode::Ber);
450 }
451
test_general_read_i8_ok(mode: BERMode)452 fn test_general_read_i8_ok(mode: BERMode) {
453 let tests : &[(i8, &[u8])] = &[
454 (-128, &[2, 1, 128]),
455 (-1, &[2, 1, 255]),
456 (0, &[2, 1, 0]),
457 (1, &[2, 1, 1]),
458 (127, &[2, 1, 127]),
459 ];
460 for &(evalue, data) in tests {
461 let value = parse_ber_general(data, mode, |reader| {
462 reader.read_i8()
463 }).unwrap();
464 assert_eq!(value, evalue);
465 }
466 }
467
test_general_read_i8_err(mode: BERMode)468 fn test_general_read_i8_err(mode: BERMode) {
469 let tests : &[&[u8]] = &[
470 &[], &[2], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[34, 1, 0], &[66, 1, 0],
471 &[2, 0], &[2, 128, 2, 1, 0, 0, 0], &[2, 2, 0], &[2, 1, 1, 1],
472 &[2, 2, 255, 128], &[2, 2, 255, 200], &[2, 2, 0, 127], &[2, 2, 0, 56],
473 &[2, 3, 255, 151, 55], &[2, 3, 0, 1, 2],
474 &[2, 2, 255, 0], &[2, 2, 255, 127], &[2, 2, 0, 128], &[2, 2, 0, 255],
475 ];
476 for &data in tests {
477 parse_ber_general(data, mode, |reader| {
478 reader.read_i8()
479 }).unwrap_err();
480 }
481 }
482
483 #[test]
test_der_read_u8_ok()484 fn test_der_read_u8_ok() {
485 test_general_read_u8_ok(BERMode::Der);
486 }
487
488 #[test]
test_der_read_u8_err()489 fn test_der_read_u8_err() {
490 test_general_read_u8_err(BERMode::Der);
491 }
492
493 #[test]
test_ber_read_u8_ok()494 fn test_ber_read_u8_ok() {
495 test_general_read_u8_ok(BERMode::Ber);
496 }
497
498 #[test]
test_ber_read_u8_err()499 fn test_ber_read_u8_err() {
500 test_general_read_u8_err(BERMode::Ber);
501 }
502
test_general_read_u8_ok(mode: BERMode)503 fn test_general_read_u8_ok(mode: BERMode) {
504 let tests : &[(u8, &[u8])] = &[
505 (0, &[2, 1, 0]),
506 (1, &[2, 1, 1]),
507 (127, &[2, 1, 127]),
508 (255, &[2, 2, 0, 255]),
509 ];
510 for &(evalue, data) in tests {
511 let value = parse_ber_general(data, mode, |reader| {
512 reader.read_u8()
513 }).unwrap();
514 assert_eq!(value, evalue);
515 }
516 }
517
test_general_read_u8_err(mode: BERMode)518 fn test_general_read_u8_err(mode: BERMode) {
519 let tests : &[&[u8]] = &[
520 &[], &[2], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[34, 1, 0], &[66, 1, 0],
521 &[2, 0], &[2, 128, 2, 1, 0, 0, 0], &[2, 2, 0], &[2, 1, 1, 1],
522 &[2, 2, 255, 128], &[2, 2, 255, 200], &[2, 2, 0, 127], &[2, 2, 0, 56],
523 &[2, 3, 255, 151, 55], &[2, 3, 0, 1, 2],
524 &[2, 1, 128], &[2, 1, 255],
525 &[2, 2, 1, 0], &[2, 2, 1, 128],
526 ];
527 for &data in tests {
528 parse_ber_general(data, mode, |reader| {
529 reader.read_u8()
530 }).unwrap_err();
531 }
532 }
533
534 #[cfg(feature = "num-bigint")]
535 #[test]
test_der_read_bigint_ok()536 fn test_der_read_bigint_ok() {
537 test_general_read_bigint_ok(BERMode::Der);
538 }
539
540 #[cfg(feature = "num-bigint")]
541 #[test]
test_der_read_bigint_err()542 fn test_der_read_bigint_err() {
543 test_general_read_bigint_err(BERMode::Der);
544 }
545
546 #[cfg(feature = "num-bigint")]
547 #[test]
test_ber_read_bigint_ok()548 fn test_ber_read_bigint_ok() {
549 test_general_read_bigint_ok(BERMode::Ber);
550 }
551
552 #[cfg(feature = "num-bigint")]
553 #[test]
test_ber_read_bigint_err()554 fn test_ber_read_bigint_err() {
555 test_general_read_bigint_err(BERMode::Ber);
556 }
557
558 #[cfg(feature = "num-bigint")]
test_general_read_bigint_ok(mode: BERMode)559 fn test_general_read_bigint_ok(mode: BERMode) {
560 use num_traits::FromPrimitive;
561 let tests : &[(i64, &[u8])] = &[
562 (-9223372036854775808, &[2, 8, 128, 0, 0, 0, 0, 0, 0, 0]),
563 (-65537, &[2, 3, 254, 255, 255]),
564 (-65536, &[2, 3, 255, 0, 0]),
565 (-32769, &[2, 3, 255, 127, 255]),
566 (-32768, &[2, 2, 128, 0]),
567 (-129, &[2, 2, 255, 127]),
568 (-128, &[2, 1, 128]),
569 (-1, &[2, 1, 255]),
570 (0, &[2, 1, 0]),
571 (1, &[2, 1, 1]),
572 (127, &[2, 1, 127]),
573 (128, &[2, 2, 0, 128]),
574 (32767, &[2, 2, 127, 255]),
575 (32768, &[2, 3, 0, 128, 0]),
576 (65535, &[2, 3, 0, 255, 255]),
577 (65536, &[2, 3, 1, 0, 0]),
578 (9223372036854775807, &[2, 8, 127, 255, 255, 255, 255, 255, 255, 255]),
579 ];
580 for &(evalue, data) in tests {
581 let value = parse_ber_general(data, mode, |reader| {
582 reader.read_bigint()
583 }).unwrap();
584 assert_eq!(value, BigInt::from_i64(evalue).unwrap());
585 }
586
587 let tests : &[(BigInt, &[u8])] = &[
588 (BigInt::parse_bytes(
589 b"1234567890123456789012345678901234567890", 10).unwrap(),
590 &[2, 17, 3, 160, 201, 32, 117, 192, 219,
591 243, 184, 172, 188, 95, 150, 206, 63, 10, 210]),
592 (BigInt::parse_bytes(
593 b"-1234567890123456789012345678901234567890", 10).unwrap(),
594 &[2, 17, 252, 95, 54, 223, 138, 63, 36,
595 12, 71, 83, 67, 160, 105, 49, 192, 245, 46]),
596 (BigInt::parse_bytes(b"-18446744073709551616", 10).unwrap(),
597 &[2, 9, 255, 0, 0, 0, 0, 0, 0, 0, 0]),
598 (BigInt::parse_bytes(b"-9223372036854775809", 10).unwrap(),
599 &[2, 9, 255, 127, 255, 255, 255, 255, 255, 255, 255]),
600 (BigInt::parse_bytes(b"9223372036854775808", 10).unwrap(),
601 &[2, 9, 0, 128, 0, 0, 0, 0, 0, 0, 0]),
602 (BigInt::parse_bytes(b"18446744073709551615", 10).unwrap(),
603 &[2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255]),
604 ];
605 for &(ref evalue, data) in tests {
606 let value = parse_ber_general(data, mode, |reader| {
607 reader.read_bigint()
608 }).unwrap();
609 assert_eq!(&value, evalue);
610 }
611 }
612
613 #[cfg(feature = "num-bigint")]
test_general_read_bigint_err(mode: BERMode)614 fn test_general_read_bigint_err(mode: BERMode) {
615 let tests : &[&[u8]] = &[
616 &[], &[2], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[34, 1, 0], &[66, 1, 0],
617 &[2, 0], &[2, 128, 2, 1, 0, 0, 0], &[2, 2, 0], &[2, 1, 1, 1],
618 &[2, 2, 255, 128], &[2, 2, 255, 200], &[2, 2, 0, 127], &[2, 2, 0, 56],
619 &[2, 3, 255, 151, 55], &[2, 3, 0, 1, 2],
620 ];
621 for &data in tests {
622 parse_ber_general(data, mode, |reader| {
623 reader.read_bigint()
624 }).unwrap_err();
625 }
626 }
627
628 #[cfg(feature = "num-bigint")]
629 #[test]
test_der_read_biguint_ok()630 fn test_der_read_biguint_ok() {
631 test_general_read_biguint_ok(BERMode::Der);
632 }
633
634 #[cfg(feature = "num-bigint")]
635 #[test]
test_der_read_biguint_err()636 fn test_der_read_biguint_err() {
637 test_general_read_biguint_err(BERMode::Der);
638 }
639
640 #[cfg(feature = "num-bigint")]
641 #[test]
test_ber_read_biguint_ok()642 fn test_ber_read_biguint_ok() {
643 test_general_read_biguint_ok(BERMode::Ber);
644 }
645
646 #[cfg(feature = "num-bigint")]
647 #[test]
test_ber_read_biguint_err()648 fn test_ber_read_biguint_err() {
649 test_general_read_biguint_err(BERMode::Ber);
650 }
651
652 #[cfg(feature = "num-bigint")]
test_general_read_biguint_ok(mode: BERMode)653 fn test_general_read_biguint_ok(mode: BERMode) {
654 use num_traits::FromPrimitive;
655 let tests : &[(u64, &[u8])] = &[
656 (0, &[2, 1, 0]),
657 (1, &[2, 1, 1]),
658 (127, &[2, 1, 127]),
659 (128, &[2, 2, 0, 128]),
660 (32767, &[2, 2, 127, 255]),
661 (32768, &[2, 3, 0, 128, 0]),
662 (65535, &[2, 3, 0, 255, 255]),
663 (65536, &[2, 3, 1, 0, 0]),
664 (9223372036854775807, &[2, 8, 127, 255, 255, 255, 255, 255, 255, 255]),
665 (18446744073709551615,
666 &[2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255]),
667 ];
668 for &(evalue, data) in tests {
669 let value = parse_ber_general(data, mode, |reader| {
670 reader.read_biguint()
671 }).unwrap();
672 assert_eq!(value, BigUint::from_u64(evalue).unwrap());
673 }
674
675 let tests : &[(BigUint, &[u8])] = &[
676 (BigUint::parse_bytes(
677 b"1234567890123456789012345678901234567890", 10).unwrap(),
678 &[2, 17, 3, 160, 201, 32, 117, 192, 219,
679 243, 184, 172, 188, 95, 150, 206, 63, 10, 210]),
680 (BigUint::parse_bytes(b"9223372036854775808", 10).unwrap(),
681 &[2, 9, 0, 128, 0, 0, 0, 0, 0, 0, 0]),
682 (BigUint::parse_bytes(b"18446744073709551615", 10).unwrap(),
683 &[2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255]),
684 ];
685 for &(ref evalue, data) in tests {
686 let value = parse_ber_general(data, mode, |reader| {
687 reader.read_biguint()
688 }).unwrap();
689 assert_eq!(&value, evalue);
690 }
691 }
692
693 #[cfg(feature = "num-bigint")]
test_general_read_biguint_err(mode: BERMode)694 fn test_general_read_biguint_err(mode: BERMode) {
695 let tests : &[&[u8]] = &[
696 &[], &[2], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[34, 1, 0], &[66, 1, 0],
697 &[2, 0], &[2, 128, 2, 1, 0, 0, 0], &[2, 2, 0], &[2, 1, 1, 1],
698 &[2, 2, 255, 128], &[2, 2, 255, 200], &[2, 2, 0, 127], &[2, 2, 0, 56],
699 &[2, 3, 255, 151, 55], &[2, 3, 0, 1, 2],
700 &[2, 8, 128, 0, 0, 0, 0, 0, 0, 0], &[2, 3, 254, 255, 255],
701 &[2, 3, 255, 0, 0], &[2, 3, 255, 127, 255], &[2, 2, 128, 0],
702 &[2, 2, 255, 127], &[2, 1, 128], &[2, 1, 255],
703 &[2, 17, 252, 95, 54, 223, 138, 63, 36,
704 12, 71, 83, 67, 160, 105, 49, 192, 245, 46],
705 &[2, 9, 255, 0, 0, 0, 0, 0, 0, 0, 0],
706 &[2, 9, 255, 127, 255, 255, 255, 255, 255, 255, 255],
707 ];
708 for &data in tests {
709 parse_ber_general(data, mode, |reader| {
710 reader.read_biguint()
711 }).unwrap_err();
712 }
713 }
714
715 #[test]
test_der_read_bytes_ok()716 fn test_der_read_bytes_ok() {
717 let tests : &[(&[u8], &[u8])] = &[
718 (&[1, 0, 100, 255], &[4, 4, 1, 0, 100, 255]),
719 (&[], &[4, 0]),
720 (&[4, 4, 4, 4], &[4, 4, 4, 4, 4, 4]),
721 ];
722 for &(evalue, data) in tests {
723 let value = parse_der(data, |reader| {
724 reader.read_bytes()
725 }).unwrap();
726 assert_eq!(value, evalue);
727 }
728 }
729
730 #[test]
test_der_read_bytes_err()731 fn test_der_read_bytes_err() {
732 let tests : &[&[u8]] = &[
733 &[], &[4], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[36, 1, 0], &[68, 1, 0],
734 &[4, 4, 0], &[4, 1, 1, 1], &[36, 128, 1, 0, 0],
735 &[36, 128, 0, 0],
736 &[36, 128, 4, 2, 12, 34, 0, 0],
737 &[36, 128, 36, 128, 4, 3, 12, 34, 56, 0, 0, 0, 0],
738 &[36, 128, 36, 128, 36, 128, 36, 128, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0],
739 &[36, 128, 4, 1, 2, 36, 128, 4, 2, 3, 1, 0, 0, 0, 0],
740 &[36, 0],
741 &[36, 4, 4, 2, 12, 34],
742 &[36, 128, 36, 5, 4, 3, 12 ,34, 56, 0, 0],
743 &[36, 9, 36, 128, 4, 3, 12, 34, 56, 0, 0],
744 &[36, 7, 36, 5, 4, 3, 12 ,34, 56],
745 ];
746 for &data in tests {
747 parse_der(data, |reader| {
748 reader.read_bytes()
749 }).unwrap_err();
750 }
751 }
752
753 #[test]
test_ber_read_bytes_ok()754 fn test_ber_read_bytes_ok() {
755 let tests : &[(&[u8], &[u8])] = &[
756 (&[1, 0, 100, 255], &[4, 4, 1, 0, 100, 255]),
757 (&[], &[4, 0]),
758 (&[4, 4, 4, 4], &[4, 4, 4, 4, 4, 4]),
759 (&[], &[36, 128, 0, 0]),
760 (&[12, 34], &[36, 128, 4, 2, 12, 34, 0, 0]),
761 (&[12, 34, 56], &[36, 128, 36, 128, 4, 3, 12, 34, 56, 0, 0, 0, 0]),
762 (&[], &[36, 128, 36, 128, 36, 128, 36,
763 128, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
764 (&[2, 3, 1], &[36, 128, 4, 1, 2, 36, 128, 4, 2, 3, 1, 0, 0, 0, 0]),
765 (&[], &[36, 0]),
766 (&[12, 34], &[36, 4, 4, 2, 12, 34]),
767 (&[12, 34, 56], &[36, 128, 36, 5, 4, 3, 12 ,34, 56, 0, 0]),
768 (&[12, 34, 56], &[36, 9, 36, 128, 4, 3, 12, 34, 56, 0, 0]),
769 (&[12, 34, 56], &[36, 7, 36, 5, 4, 3, 12 ,34, 56]),
770 ];
771 for &(evalue, data) in tests {
772 let value = parse_ber(data, |reader| {
773 reader.read_bytes()
774 }).unwrap();
775 assert_eq!(value, evalue);
776 }
777 }
778
779 #[test]
test_ber_read_bytes_err()780 fn test_ber_read_bytes_err() {
781 let tests : &[&[u8]] = &[
782 &[], &[4], &[0, 0], &[0, 1, 0], &[1, 1, 0], &[36, 1, 0], &[68, 1, 0],
783 &[4, 4, 0], &[4, 1, 1, 1], &[4, 128, 1, 0, 0],
784 ];
785 for &data in tests {
786 parse_ber(data, |reader| {
787 reader.read_bytes()
788 }).unwrap_err();
789 }
790 }
791
792 #[test]
test_der_read_null_ok()793 fn test_der_read_null_ok() {
794 let value = parse_der(&[5, 0], |reader| {
795 reader.read_null()
796 }).unwrap();
797 assert_eq!(value, ());
798 }
799
800 #[test]
test_der_read_null_err()801 fn test_der_read_null_err() {
802 let tests : &[&[u8]] = &[
803 &[], &[5], &[0, 0], &[0, 1, 0], &[2, 1, 0], &[37, 0], &[69, 0],
804 &[5, 128, 0], &[37, 128, 0], &[5, 1, 0], &[5, 2, 0, 0],
805 &[5, 1], &[5, 0, 1],
806 ];
807 for &data in tests {
808 parse_der(data, |reader| {
809 reader.read_null()
810 }).unwrap_err();
811 }
812 }
813
814 #[test]
test_ber_read_null_ok()815 fn test_ber_read_null_ok() {
816 let value = parse_ber(&[5, 0], |reader| {
817 reader.read_null()
818 }).unwrap();
819 assert_eq!(value, ());
820 }
821
822 #[test]
test_ber_read_null_err()823 fn test_ber_read_null_err() {
824 let tests : &[&[u8]] = &[
825 &[], &[5], &[0, 0], &[0, 1, 0], &[2, 1, 0], &[37, 0], &[69, 0],
826 &[5, 128, 0], &[37, 128, 0], &[5, 1, 0], &[5, 2, 0, 0],
827 &[5, 1], &[5, 0, 1],
828 ];
829 for &data in tests {
830 parse_ber(data, |reader| {
831 reader.read_null()
832 }).unwrap_err();
833 }
834 }
835
836 #[test]
test_der_read_sequence_ok()837 fn test_der_read_sequence_ok() {
838 let tests : &[((i64, bool), &[u8])] = &[
839 ((10, true), &[48, 6, 2, 1, 10, 1, 1, 255]),
840 ((266, true), &[48, 7, 2, 2, 1, 10, 1, 1, 255]),
841 ];
842 for &(evalue, data) in tests {
843 let value = parse_der(data, |reader| {
844 reader.read_sequence(|reader| {
845 let i = reader.next().read_i64()?;
846 let b = reader.next().read_bool()?;
847 return Ok((i, b));
848 })
849 }).unwrap();
850 assert_eq!(value, evalue);
851 }
852
853 let tests : &[((), &[u8])] = &[
854 ((), &[48, 0]),
855 ];
856 for &(evalue, data) in tests {
857 let value = parse_der(data, |reader| {
858 reader.read_sequence(|_| {
859 Ok(())
860 })
861 }).unwrap();
862 assert_eq!(value, evalue);
863 }
864 }
865
866 #[test]
test_der_read_sequence_err()867 fn test_der_read_sequence_err() {
868 let tests : &[&[u8]] = &[
869 &[], &[48], &[0, 0], &[0, 1, 0],
870 &[49, 6, 2, 1, 10, 1, 1, 255],
871 &[16, 6, 2, 1, 10, 1, 1, 255],
872 &[112, 6, 2, 1, 10, 1, 1, 255],
873 &[48, 6, 2, 1, 10, 1, 1, 255, 0],
874 &[48, 6, 2, 2, 1, 10, 1, 1, 255],
875 &[48, 7, 2, 1, 10, 1, 1, 255, 0],
876 &[48, 7, 2, 1, 10, 1, 1, 255],
877 &[48, 8, 48, 6, 2, 1, 10, 1, 1, 255],
878 &[49, 128, 2, 1, 10, 1, 1, 255, 0, 0],
879 &[16, 128, 2, 1, 10, 1, 1, 255, 0, 0],
880 &[112, 128, 2, 1, 10, 1, 1, 255, 0, 0],
881 &[48, 128, 2, 1, 10, 1, 1, 255, 0, 0, 0],
882 &[48, 128, 48, 6, 2, 1, 10, 1, 1, 255, 0, 0],
883 &[48, 10, 48, 128, 2, 1, 10, 1, 1, 255, 0, 0],
884 &[48, 128, 48, 128, 2, 1, 10, 1, 1, 255, 0, 0, 0, 0],
885 &[48, 128, 2, 1, 10, 1, 1, 255, 0, 0],
886 &[48, 128, 2, 2, 1, 10, 1, 1, 255, 0, 0],
887 ];
888 for &data in tests {
889 parse_der(data, |reader| {
890 reader.read_sequence(|reader| {
891 let i = reader.next().read_i64()?;
892 let b = reader.next().read_bool()?;
893 return Ok((i, b));
894 })
895 }).unwrap_err();
896 }
897 }
898
899 #[test]
test_der_read_tagged_der_err()900 fn test_der_read_tagged_der_err() {
901 let tests : &[&[u8]] = &[
902 &[], &[48], &[0, 0], &[0, 1, 0],
903 &[48, 6, 2, 1, 10, 1, 1, 255, 0],
904 &[48, 6, 2, 2, 1, 10, 1, 1, 255],
905 &[48, 7, 2, 1, 10, 1, 1, 255],
906 &[48, 128, 2, 1, 10, 1, 1, 255, 0, 0, 0],
907
908 // Otherwise valid indefinite-length encodings
909 &[48, 128, 48, 6, 2, 1, 10, 1, 1, 255, 0, 0],
910 &[48, 128, 48, 128, 2, 1, 10, 1, 1, 255, 0, 0, 0, 0],
911 &[48, 128, 2, 1, 10, 1, 1, 255, 0, 0],
912 &[48, 128, 2, 2, 1, 10, 1, 1, 255, 0, 0],
913 ];
914 for &data in tests {
915 parse_der(data, |reader| {
916 reader.read_tagged_der()
917 }).unwrap_err();
918 }
919 }
920
921 #[test]
test_ber_read_sequence_ok()922 fn test_ber_read_sequence_ok() {
923 let tests : &[((i64, bool),
924 TaggedDerValue,
925 &[u8])] = &[
926 // Definite-length encoding
927 ((10, true),
928 TaggedDerValue::from_tag_and_bytes(
929 TAG_SEQUENCE,
930 [2, 1, 10, 1, 1, 255].to_vec()),
931 &[48, 6, 2, 1, 10, 1, 1, 255]),
932 // Definite-length encoding
933 ((266, true),
934 TaggedDerValue::from_tag_and_bytes(
935 TAG_SEQUENCE,
936 [2, 2, 1, 10, 1, 1, 255].to_vec()),
937 &[48, 7, 2, 2, 1, 10, 1, 1, 255]),
938 // Indefinite-length encoding
939 ((10, true),
940 TaggedDerValue::from_tag_and_bytes(
941 TAG_SEQUENCE,
942 [2, 1, 10, 1, 1, 255, 0, 0].to_vec()),
943 &[48, 128, 2, 1, 10, 1, 1, 255, 0, 0]),
944 // Indefinite-length encoding
945 ((266, true),
946 TaggedDerValue::from_tag_and_bytes(
947 TAG_SEQUENCE,
948 [2, 2, 1, 10, 1, 1, 255, 0, 0].to_vec()),
949 &[48, 128, 2, 2, 1, 10, 1, 1, 255, 0, 0]),
950 ];
951 for &(evalue, ref ervalue, data) in tests {
952 let value = parse_ber(data, |reader| {
953 reader.read_sequence(|reader| {
954 let i = reader.next().read_i64()?;
955 let b = reader.next().read_bool()?;
956 return Ok((i, b));
957 })
958 }).unwrap();
959 assert_eq!(value, evalue);
960 let rvalue = parse_ber(data, |reader| {
961 reader.read_tagged_der()
962 }).unwrap();
963 assert_eq!(&rvalue, ervalue);
964 }
965
966 let tests : &[((), &[u8])] = &[
967 ((), &[48, 0]),
968 ((), &[48, 128, 0, 0]),
969 ];
970 for &(evalue, data) in tests {
971 let value = parse_ber(data, |reader| {
972 reader.read_sequence(|_| {
973 Ok(())
974 })
975 }).unwrap();
976 assert_eq!(value, evalue);
977 }
978 }
979
980 #[test]
test_ber_read_sequence_err()981 fn test_ber_read_sequence_err() {
982 let tests : &[&[u8]] = &[
983 &[], &[48], &[0, 0], &[0, 1, 0],
984 &[49, 6, 2, 1, 10, 1, 1, 255],
985 &[16, 6, 2, 1, 10, 1, 1, 255],
986 &[112, 6, 2, 1, 10, 1, 1, 255],
987 &[48, 6, 2, 1, 10, 1, 1, 255, 0],
988 &[48, 6, 2, 2, 1, 10, 1, 1, 255],
989 &[48, 7, 2, 1, 10, 1, 1, 255, 0],
990 &[48, 7, 2, 1, 10, 1, 1, 255],
991 &[48, 8, 48, 6, 2, 1, 10, 1, 1, 255],
992 &[49, 128, 2, 1, 10, 1, 1, 255, 0, 0],
993 &[16, 128, 2, 1, 10, 1, 1, 255, 0, 0],
994 &[112, 128, 2, 1, 10, 1, 1, 255, 0, 0],
995 &[48, 128, 2, 1, 10, 1, 1, 255, 0, 0, 0],
996 &[48, 128, 48, 6, 2, 1, 10, 1, 1, 255, 0, 0],
997 ];
998 for &data in tests {
999 parse_ber(data, |reader| {
1000 reader.read_sequence(|reader| {
1001 let i = reader.next().read_i64()?;
1002 let b = reader.next().read_bool()?;
1003 return Ok((i, b));
1004 })
1005 }).unwrap_err();
1006 }
1007 }
1008
1009 #[test]
test_der_read_set_ok()1010 fn test_der_read_set_ok() {
1011 let tests : &[((i64, Vec<u8>, i64, Vec<u8>), &[u8])] = &[
1012 ((456789, b"Foo".to_vec(), 456790, b"Bar".to_vec()), &[
1013 49, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1014 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111]),
1015 ];
1016 for &(ref evalue, data) in tests {
1017 let value = parse_der(data, |reader| {
1018 reader.read_set(|reader| {
1019 let a = reader.next(&[Tag::context(28)])?
1020 .read_tagged_implicit(Tag::context(28), |reader| {
1021 reader.read_i64()
1022 })?;
1023 let b = reader.next(&[Tag::context(345678)])?
1024 .read_tagged(Tag::context(345678), |reader| {
1025 reader.read_bytes()
1026 })?;
1027 let c = reader.next(&[Tag::context(27)])?
1028 .read_tagged(Tag::context(27), |reader| {
1029 reader.read_i64()
1030 })?;
1031 let d = reader.next(&[Tag::context(345677)])?
1032 .read_tagged(Tag::context(345677), |reader| {
1033 reader.read_bytes()
1034 })?;
1035 return Ok((a, b, c, d));
1036 })
1037 }).unwrap();
1038 assert_eq!(&value, evalue);
1039 }
1040 }
1041
1042 #[test]
test_der_read_set_err()1043 fn test_der_read_set_err() {
1044 let tests : &[&[u8]] = &[
1045 &[], &[49], &[0, 0], &[0, 1, 0],
1046 &[17, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1047 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1048 &[113, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1049 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1050 &[48, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1051 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1052 &[49, 33, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1053 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1054 &[49, 33, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1055 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111, 0],
1056 &[49, 31, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1057 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1058 &[49, 31, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1059 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111],
1060 &[49, 22, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1061 77, 5, 4, 3, 66, 97, 114],
1062 &[49, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1063 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111,
1064 191, 149, 140, 79, 5, 4, 3, 70, 111, 111],
1065 &[49, 128, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1066 77, 5, 4, 3, 66, 97, 114, 191, 149,
1067 140, 78, 5, 4, 3, 70, 111, 111, 0, 0],
1068 &[49, 32, 156, 3, 6, 248, 85, 187, 5, 2, 3, 6, 248, 86, 191, 149, 140,
1069 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1070 &[49, 32, 187, 5, 2, 3, 6, 248, 86, 191, 149, 140, 77, 5, 4, 3, 66, 97,
1071 114, 156, 3, 6, 248, 85, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1072 &[49, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1073 78, 5, 4, 3, 70, 111, 111, 191, 149, 140, 77, 5, 4, 3, 66, 97, 114],
1074 ];
1075 for &data in tests {
1076 parse_der(data, |reader| {
1077 reader.read_set(|reader| {
1078 let a = reader.next(&[Tag::context(28)])?
1079 .read_tagged_implicit(Tag::context(28), |reader| {
1080 reader.read_i64()
1081 })?;
1082 let b = reader.next(&[Tag::context(345678)])?
1083 .read_tagged(Tag::context(345678), |reader| {
1084 reader.read_bytes()
1085 })?;
1086 let c = reader.next(&[Tag::context(27)])?
1087 .read_tagged(Tag::context(27), |reader| {
1088 reader.read_i64()
1089 })?;
1090 let d = reader.next(&[Tag::context(345677)])?
1091 .read_tagged(Tag::context(345677), |reader| {
1092 reader.read_bytes()
1093 })?;
1094 return Ok((a, b, c, d));
1095 })
1096 }).unwrap_err();
1097 }
1098 }
1099
1100 #[test]
test_ber_read_set_ok()1101 fn test_ber_read_set_ok() {
1102 let tests : &[((i64, Vec<u8>, i64, Vec<u8>), &[u8])] = &[
1103 ((456789, b"Foo".to_vec(), 456790, b"Bar".to_vec()), &[
1104 49, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1105 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111]),
1106 ((456789, b"Foo".to_vec(), 456790, b"Bar".to_vec()), &[
1107 49, 128, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1108 77, 5, 4, 3, 66, 97, 114, 191, 149,
1109 140, 78, 5, 4, 3, 70, 111, 111, 0, 0]),
1110 ((456789, b"Foo".to_vec(), 456790, b"Bar".to_vec()), &[
1111 49, 32, 156, 3, 6, 248, 85, 187, 5, 2, 3, 6, 248, 86, 191, 149, 140,
1112 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111]),
1113 ((456789, b"Foo".to_vec(), 456790, b"Bar".to_vec()), &[
1114 49, 32, 187, 5, 2, 3, 6, 248, 86, 191, 149, 140, 77, 5, 4, 3, 66, 97,
1115 114, 156, 3, 6, 248, 85, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111]),
1116 ((456789, b"Foo".to_vec(), 456790, b"Bar".to_vec()), &[
1117 49, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1118 78, 5, 4, 3, 70, 111, 111, 191, 149, 140, 77, 5, 4, 3, 66, 97, 114]),
1119 ];
1120 for &(ref evalue, data) in tests {
1121 let value = parse_ber(data, |reader| {
1122 reader.read_set(|reader| {
1123 let a = reader.next(&[Tag::context(28)])?
1124 .read_tagged_implicit(Tag::context(28), |reader| {
1125 reader.read_i64()
1126 })?;
1127 let b = reader.next(&[Tag::context(345678)])?
1128 .read_tagged(Tag::context(345678), |reader| {
1129 reader.read_bytes()
1130 })?;
1131 let c = reader.next(&[Tag::context(27)])?
1132 .read_tagged(Tag::context(27), |reader| {
1133 reader.read_i64()
1134 })?;
1135 let d = reader.next(&[Tag::context(345677)])?
1136 .read_tagged(Tag::context(345677), |reader| {
1137 reader.read_bytes()
1138 })?;
1139 return Ok((a, b, c, d));
1140 })
1141 }).unwrap();
1142 assert_eq!(&value, evalue);
1143 }
1144 }
1145
1146 #[test]
test_ber_read_set_err()1147 fn test_ber_read_set_err() {
1148 let tests : &[&[u8]] = &[
1149 &[], &[49], &[0, 0], &[0, 1, 0],
1150 &[17, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1151 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1152 &[113, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1153 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1154 &[48, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1155 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1156 &[49, 33, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1157 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1158 &[49, 33, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1159 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111, 0],
1160 &[49, 31, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1161 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111],
1162 &[49, 31, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1163 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111],
1164 &[49, 22, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1165 77, 5, 4, 3, 66, 97, 114],
1166 &[49, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
1167 77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111,
1168 191, 149, 140, 79, 5, 4, 3, 70, 111, 111],
1169 ];
1170 for &data in tests {
1171 parse_ber(data, |reader| {
1172 reader.read_set(|reader| {
1173 let a = reader.next(&[Tag::context(28)])?
1174 .read_tagged_implicit(Tag::context(28), |reader| {
1175 reader.read_i64()
1176 })?;
1177 let b = reader.next(&[Tag::context(345678)])?
1178 .read_tagged(Tag::context(345678), |reader| {
1179 reader.read_bytes()
1180 })?;
1181 let c = reader.next(&[Tag::context(27)])?
1182 .read_tagged(Tag::context(27), |reader| {
1183 reader.read_i64()
1184 })?;
1185 let d = reader.next(&[Tag::context(345677)])?
1186 .read_tagged(Tag::context(345677), |reader| {
1187 reader.read_bytes()
1188 })?;
1189 return Ok((a, b, c, d));
1190 })
1191 }).unwrap_err();
1192 }
1193 }
1194
1195 #[test]
test_der_read_set_of_ok()1196 fn test_der_read_set_of_ok() {
1197 use std::collections::HashSet;
1198 let tests : &[(&[i64], &[u8])] = &[
1199 (&[-129, -128, 127, 128], &[
1200 49, 14, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127]),
1201 (&[-128, 127, 128], &[
1202 49, 10, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128]),
1203 (&[-129, -128, 127, 128, 32768], &[
1204 49, 19, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127,
1205 2, 3, 0, 128, 0]),
1206 ];
1207 for &(evalue, data) in tests {
1208 let value = parse_der(data, |reader| {
1209 reader.collect_set_of(|reader| {
1210 reader.read_i64()
1211 })
1212 }).unwrap();
1213 let value_set = value.iter().collect::<HashSet<_>>();
1214 let evalue_set = evalue.iter().collect::<HashSet<_>>();
1215 assert_eq!(value_set, evalue_set);
1216 }
1217 }
1218
1219 #[test]
test_der_read_set_of_err()1220 fn test_der_read_set_of_err() {
1221 let tests : &[&[u8]] = &[
1222 &[], &[49], &[0, 0], &[0, 1, 0],
1223 &[17, 14, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127],
1224 &[113, 14, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127],
1225 &[48, 14, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127],
1226 &[49, 15, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127],
1227 &[49, 15, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127, 0],
1228 &[49, 13, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127],
1229 &[49, 13, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255],
1230 &[49, 128, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127, 0, 0],
1231 &[49, 14, 2, 1, 128, 2, 1, 127, 2, 2, 0, 128, 2, 2, 255, 127],
1232 &[49, 14, 2, 1, 127, 2, 2, 0, 128, 2, 1, 128, 2, 2, 255, 127],
1233 &[49, 14, 2, 1, 127, 2, 1, 128, 2, 2, 255, 127, 2, 2, 0, 128],
1234 &[49, 14, 2, 2, 255, 127, 2, 1, 128, 2, 2, 0, 128, 2, 1, 127],
1235 ];
1236 for &data in tests {
1237 parse_der(data, |reader| {
1238 reader.read_set(|reader| {
1239 let a = reader.next(&[Tag::context(28)])?
1240 .read_tagged_implicit(Tag::context(28), |reader| {
1241 reader.read_i64()
1242 })?;
1243 let b = reader.next(&[Tag::context(345678)])?
1244 .read_tagged(Tag::context(345678), |reader| {
1245 reader.read_bytes()
1246 })?;
1247 let c = reader.next(&[Tag::context(27)])?
1248 .read_tagged(Tag::context(27), |reader| {
1249 reader.read_i64()
1250 })?;
1251 let d = reader.next(&[Tag::context(345677)])?
1252 .read_tagged(Tag::context(345677), |reader| {
1253 reader.read_bytes()
1254 })?;
1255 return Ok((a, b, c, d));
1256 })
1257 }).unwrap_err();
1258 }
1259 }
1260
1261 #[test]
test_ber_read_set_of_ok()1262 fn test_ber_read_set_of_ok() {
1263 use std::collections::HashSet;
1264 let tests : &[(&[i64], &[u8])] = &[
1265 (&[-129, -128, 127, 128], &[
1266 49, 14, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127]),
1267 (&[-128, 127, 128], &[
1268 49, 10, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128]),
1269 (&[-129, -128, 127, 128, 32768], &[
1270 49, 19, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127,
1271 2, 3, 0, 128, 0]),
1272 (&[-129, -128, 127, 128], &[
1273 49, 128, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127,
1274 0, 0]),
1275 (&[-129, -128, 127, 128], &[
1276 49, 14, 2, 1, 128, 2, 1, 127, 2, 2, 0, 128, 2, 2, 255, 127]),
1277 (&[-129, -128, 127, 128], &[
1278 49, 14, 2, 1, 127, 2, 2, 0, 128, 2, 1, 128, 2, 2, 255, 127]),
1279 (&[-129, -128, 127, 128], &[
1280 49, 14, 2, 1, 127, 2, 1, 128, 2, 2, 255, 127, 2, 2, 0, 128]),
1281 (&[-129, -128, 127, 128], &[
1282 49, 14, 2, 2, 255, 127, 2, 1, 128, 2, 2, 0, 128, 2, 1, 127]),
1283 ];
1284 for &(evalue, data) in tests {
1285 let value = parse_ber(data, |reader| {
1286 reader.collect_set_of(|reader| {
1287 reader.read_i64()
1288 })
1289 }).unwrap();
1290 let value_set = value.iter().collect::<HashSet<_>>();
1291 let evalue_set = evalue.iter().collect::<HashSet<_>>();
1292 assert_eq!(value_set, evalue_set);
1293 }
1294 }
1295
1296 #[test]
test_ber_read_set_of_err()1297 fn test_ber_read_set_of_err() {
1298 let tests : &[&[u8]] = &[
1299 &[], &[49], &[0, 0], &[0, 1, 0],
1300 &[17, 14, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127],
1301 &[113, 14, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127],
1302 &[48, 14, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127],
1303 &[49, 15, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127],
1304 &[49, 15, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127, 0],
1305 &[49, 13, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127],
1306 &[49, 13, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255],
1307 ];
1308 for &data in tests {
1309 parse_ber(data, |reader| {
1310 reader.read_set(|reader| {
1311 let a = reader.next(&[Tag::context(28)])?
1312 .read_tagged_implicit(Tag::context(28), |reader| {
1313 reader.read_i64()
1314 })?;
1315 let b = reader.next(&[Tag::context(345678)])?
1316 .read_tagged(Tag::context(345678), |reader| {
1317 reader.read_bytes()
1318 })?;
1319 let c = reader.next(&[Tag::context(27)])?
1320 .read_tagged(Tag::context(27), |reader| {
1321 reader.read_i64()
1322 })?;
1323 let d = reader.next(&[Tag::context(345677)])?
1324 .read_tagged(Tag::context(345677), |reader| {
1325 reader.read_bytes()
1326 })?;
1327 return Ok((a, b, c, d));
1328 })
1329 }).unwrap_err();
1330 }
1331 }
1332
1333 #[test]
test_der_read_tagged_ok()1334 fn test_der_read_tagged_ok() {
1335 let tests : &[(i64, &[u8])] = &[
1336 (10, &[163, 3, 2, 1, 10]),
1337 (266, &[163, 4, 2, 2, 1, 10]),
1338 ];
1339 for &(evalue, data) in tests {
1340 let value = parse_der(data, |reader| {
1341 reader.read_tagged(Tag::context(3), |reader| {
1342 reader.read_i64()
1343 })
1344 }).unwrap();
1345 assert_eq!(value, evalue);
1346 }
1347
1348 let tests : &[((i64, bool), &[u8])] = &[
1349 ((10, false), &[163, 8, 48, 6, 2, 1, 10, 1, 1, 0]),
1350 ((266, false), &[163, 9, 48, 7, 2, 2, 1, 10, 1, 1, 0]),
1351 ];
1352 for &(evalue, data) in tests {
1353 let value = parse_der(data, |reader| {
1354 reader.read_tagged(Tag::context(3), |reader| {
1355 reader.read_sequence(|reader| {
1356 let i = reader.next().read_i64()?;
1357 let b = reader.next().read_bool()?;
1358 return Ok((i, b));
1359 })
1360 })
1361 }).unwrap();
1362 assert_eq!(value, evalue);
1363 }
1364 }
1365
1366 #[test]
test_der_read_tagged_err()1367 fn test_der_read_tagged_err() {
1368 let tests : &[&[u8]] = &[
1369 &[], &[163], &[0, 0], &[0, 1, 0], &[160, 3, 2, 1, 10],
1370 &[35, 3, 2, 1, 10], &[131, 3, 2, 1, 10],
1371 &[131, 1, 10],
1372 &[163, 128, 2, 1, 10, 0, 0],
1373 ];
1374 for &data in tests {
1375 parse_der(data, |reader| {
1376 reader.read_tagged(Tag::context(3), |reader| {
1377 reader.read_sequence(|reader| {
1378 let i = reader.next().read_i64()?;
1379 let b = reader.next().read_bool()?;
1380 return Ok((i, b));
1381 })
1382 })
1383 }).unwrap_err();
1384 }
1385
1386 let tests : &[&[u8]] = &[
1387 &[], &[163], &[0, 0], &[0, 1, 0],
1388 &[160, 8, 48, 6, 2, 1, 10, 1, 1, 0],
1389 &[35, 8, 48, 6, 2, 1, 10, 1, 1, 0],
1390 &[131, 8, 48, 6, 2, 1, 10, 1, 1, 0],
1391 &[163, 8, 48, 6, 2, 1, 10, 1, 1, 0, 0],
1392 &[163, 8, 48, 6, 2, 1, 10, 1, 1],
1393 &[163, 9, 48, 7, 2, 2, 1, 10, 1, 1, 0, 0],
1394 &[163, 9, 48, 7, 2, 2, 1, 10, 1, 1],
1395 &[163, 6, 2, 1, 10, 1, 1, 0],
1396 &[163, 7, 2, 2, 1, 10, 1, 1, 0],
1397 &[163, 128, 48, 6, 2, 1, 10, 1, 1, 0, 0, 0, 0],
1398 &[163, 128, 48, 6, 2, 1, 10, 1, 1, 0, 0, 0],
1399 &[163, 128, 48, 6, 2, 1, 10, 1, 1, 0, 0],
1400 &[163, 128, 48, 7, 2, 2, 1, 10, 1, 1, 0, 0, 0, 0],
1401 &[163, 128, 48, 7, 2, 2, 1, 10, 1, 1, 0, 0, 0],
1402 &[163, 128, 48, 7, 2, 2, 1, 10, 1, 1, 0, 0],
1403 ];
1404 for &data in tests {
1405 parse_der(data, |reader| {
1406 reader.read_tagged(Tag::context(3), |reader| {
1407 reader.read_i64()
1408 })
1409 }).unwrap_err();
1410 }
1411 }
1412
1413 #[test]
test_ber_read_tagged_ok()1414 fn test_ber_read_tagged_ok() {
1415 let tests : &[(i64, &[u8])] = &[
1416 (10, &[163, 3, 2, 1, 10]),
1417 (266, &[163, 4, 2, 2, 1, 10]),
1418 (10, &[163, 128, 2, 1, 10, 0, 0]),
1419 ];
1420 for &(evalue, data) in tests {
1421 let value = parse_ber(data, |reader| {
1422 reader.read_tagged(Tag::context(3), |reader| {
1423 reader.read_i64()
1424 })
1425 }).unwrap();
1426 assert_eq!(value, evalue);
1427 }
1428
1429 let tests : &[((i64, bool), &[u8])] = &[
1430 ((10, false), &[163, 8, 48, 6, 2, 1, 10, 1, 1, 0]),
1431 ((266, false), &[163, 9, 48, 7, 2, 2, 1, 10, 1, 1, 0]),
1432 ((10, false), &[163, 128, 48, 6, 2, 1, 10, 1, 1, 0, 0, 0]),
1433 ((266, false), &[163, 128, 48, 7, 2, 2, 1, 10, 1, 1, 0, 0, 0]),
1434 ];
1435 for &(evalue, data) in tests {
1436 let value = parse_ber(data, |reader| {
1437 reader.read_tagged(Tag::context(3), |reader| {
1438 reader.read_sequence(|reader| {
1439 let i = reader.next().read_i64()?;
1440 let b = reader.next().read_bool()?;
1441 return Ok((i, b));
1442 })
1443 })
1444 }).unwrap();
1445 assert_eq!(value, evalue);
1446 }
1447 }
1448
1449 #[test]
test_ber_read_tagged_err()1450 fn test_ber_read_tagged_err() {
1451 let tests : &[&[u8]] = &[
1452 &[], &[163], &[0, 0], &[0, 1, 0], &[160, 3, 2, 1, 10],
1453 &[35, 3, 2, 1, 10], &[131, 3, 2, 1, 10],
1454 &[131, 1, 10],
1455 ];
1456 for &data in tests {
1457 parse_ber(data, |reader| {
1458 reader.read_tagged(Tag::context(3), |reader| {
1459 reader.read_sequence(|reader| {
1460 let i = reader.next().read_i64()?;
1461 let b = reader.next().read_bool()?;
1462 return Ok((i, b));
1463 })
1464 })
1465 }).unwrap_err();
1466 }
1467
1468 let tests : &[&[u8]] = &[
1469 &[], &[163], &[0, 0], &[0, 1, 0],
1470 &[160, 8, 48, 6, 2, 1, 10, 1, 1, 0],
1471 &[35, 8, 48, 6, 2, 1, 10, 1, 1, 0],
1472 &[131, 8, 48, 6, 2, 1, 10, 1, 1, 0],
1473 &[163, 8, 48, 6, 2, 1, 10, 1, 1, 0, 0],
1474 &[163, 8, 48, 6, 2, 1, 10, 1, 1],
1475 &[163, 9, 48, 7, 2, 2, 1, 10, 1, 1, 0, 0],
1476 &[163, 9, 48, 7, 2, 2, 1, 10, 1, 1],
1477 &[163, 6, 2, 1, 10, 1, 1, 0],
1478 &[163, 7, 2, 2, 1, 10, 1, 1, 0],
1479 &[163, 128, 48, 6, 2, 1, 10, 1, 1, 0, 0, 0, 0],
1480 &[163, 128, 48, 6, 2, 1, 10, 1, 1, 0, 0],
1481 &[163, 128, 48, 7, 2, 2, 1, 10, 1, 1, 0, 0, 0, 0],
1482 &[163, 128, 48, 7, 2, 2, 1, 10, 1, 1, 0, 0],
1483 ];
1484 for &data in tests {
1485 parse_ber(data, |reader| {
1486 reader.read_tagged(Tag::context(3), |reader| {
1487 reader.read_i64()
1488 })
1489 }).unwrap_err();
1490 }
1491 }
1492
1493 #[test]
test_der_read_tagged_implicit_ok()1494 fn test_der_read_tagged_implicit_ok() {
1495 let tests : &[(i64, &[u8])] = &[
1496 (10, &[131, 1, 10]),
1497 (266, &[131, 2, 1, 10]),
1498 ];
1499 for &(evalue, data) in tests {
1500 let value = parse_der(data, |reader| {
1501 reader.read_tagged_implicit(Tag::context(3), |reader| {
1502 reader.read_i64()
1503 })
1504 }).unwrap();
1505 assert_eq!(value, evalue);
1506 }
1507
1508 let tests : &[((i64, bool), &[u8])] = &[
1509 ((10, false), &[163, 6, 2, 1, 10, 1, 1, 0]),
1510 ((266, false), &[163, 7, 2, 2, 1, 10, 1, 1, 0]),
1511 ];
1512 for &(evalue, data) in tests {
1513 let value = parse_der(data, |reader| {
1514 reader.read_tagged_implicit(Tag::context(3), |reader| {
1515 reader.read_sequence(|reader| {
1516 let i = reader.next().read_i64()?;
1517 let b = reader.next().read_bool()?;
1518 return Ok((i, b));
1519 })
1520 })
1521 }).unwrap();
1522 assert_eq!(value, evalue);
1523 }
1524 }
1525
1526 #[test]
test_der_read_tagged_implicit_err()1527 fn test_der_read_tagged_implicit_err() {
1528 let tests : &[&[u8]] = &[
1529 &[], &[131], &[0, 0], &[0, 1, 0], &[128, 3, 2, 1, 10],
1530 &[3, 3, 2, 1, 10], &[163, 3, 2, 1, 10],
1531 &[163, 3, 2, 1, 10],
1532 &[131, 128, 1, 10, 0, 0],
1533 &[163, 128, 2, 1, 10, 0, 0],
1534 ];
1535 for &data in tests {
1536 parse_der(data, |reader| {
1537 reader.read_tagged(Tag::context(3), |reader| {
1538 reader.read_sequence(|reader| {
1539 let i = reader.next().read_i64()?;
1540 let b = reader.next().read_bool()?;
1541 return Ok((i, b));
1542 })
1543 })
1544 }).unwrap_err();
1545 }
1546
1547 let tests : &[&[u8]] = &[
1548 &[], &[163], &[0, 0], &[0, 1, 0],
1549 &[160, 6, 2, 1, 10, 1, 1, 0],
1550 &[35, 6, 2, 1, 10, 1, 1, 0],
1551 &[131, 6, 2, 1, 10, 1, 1, 0],
1552 &[163, 6, 2, 1, 10, 1, 1, 0, 0],
1553 &[163, 6, 2, 1, 10, 1, 1],
1554 &[163, 7, 2, 2, 1, 10, 1, 1, 0, 0],
1555 &[163, 7, 2, 2, 1, 10, 1, 1],
1556 &[163, 8, 48, 6, 2, 1, 10, 1, 1, 0],
1557 &[163, 9, 48, 7, 2, 2, 1, 10, 1, 1, 0],
1558 &[163, 128, 2, 1, 10, 1, 1, 0, 0, 0, 0],
1559 &[163, 128, 2, 1, 10, 1, 1, 0, 0, 0],
1560 &[163, 128, 2, 1, 10, 1, 1, 0, 0],
1561 &[163, 128, 2, 2, 1, 10, 1, 1, 0, 0, 0, 0],
1562 &[163, 128, 2, 2, 1, 10, 1, 1, 0, 0, 0],
1563 &[163, 128, 2, 2, 1, 10, 1, 1, 0, 0],
1564 ];
1565 for &data in tests {
1566 parse_der(data, |reader| {
1567 reader.read_tagged(Tag::context(3), |reader| {
1568 reader.read_i64()
1569 })
1570 }).unwrap_err();
1571 }
1572 }
1573
1574 #[test]
test_ber_read_tagged_implicit_ok()1575 fn test_ber_read_tagged_implicit_ok() {
1576 let tests : &[(i64, &[u8])] = &[
1577 (10, &[131, 1, 10]),
1578 (266, &[131, 2, 1, 10]),
1579 ];
1580 for &(evalue, data) in tests {
1581 let value = parse_ber(data, |reader| {
1582 reader.read_tagged_implicit(Tag::context(3), |reader| {
1583 reader.read_i64()
1584 })
1585 }).unwrap();
1586 assert_eq!(value, evalue);
1587 }
1588
1589 let tests : &[((i64, bool), &[u8])] = &[
1590 ((10, false), &[163, 6, 2, 1, 10, 1, 1, 0]),
1591 ((266, false), &[163, 7, 2, 2, 1, 10, 1, 1, 0]),
1592 ((10, false), &[163, 128, 2, 1, 10, 1, 1, 0, 0, 0]),
1593 ((266, false), &[163, 128, 2, 2, 1, 10, 1, 1, 0, 0, 0]),
1594 ];
1595 for &(evalue, data) in tests {
1596 let value = parse_ber(data, |reader| {
1597 reader.read_tagged_implicit(Tag::context(3), |reader| {
1598 reader.read_sequence(|reader| {
1599 let i = reader.next().read_i64()?;
1600 let b = reader.next().read_bool()?;
1601 return Ok((i, b));
1602 })
1603 })
1604 }).unwrap();
1605 assert_eq!(value, evalue);
1606 }
1607 }
1608
1609 #[test]
test_ber_read_tagged_implicit_err()1610 fn test_ber_read_tagged_implicit_err() {
1611 let tests : &[&[u8]] = &[
1612 &[], &[131], &[0, 0], &[0, 1, 0], &[128, 3, 2, 1, 10],
1613 &[3, 3, 2, 1, 10], &[163, 3, 2, 1, 10],
1614 &[163, 3, 2, 1, 10],
1615 &[131, 128, 1, 10, 0, 0],
1616 &[163, 128, 2, 1, 10, 0, 0],
1617 ];
1618 for &data in tests {
1619 parse_ber(data, |reader| {
1620 reader.read_tagged(Tag::context(3), |reader| {
1621 reader.read_sequence(|reader| {
1622 let i = reader.next().read_i64()?;
1623 let b = reader.next().read_bool()?;
1624 return Ok((i, b));
1625 })
1626 })
1627 }).unwrap_err();
1628 }
1629
1630 let tests : &[&[u8]] = &[
1631 &[], &[163], &[0, 0], &[0, 1, 0],
1632 &[160, 6, 2, 1, 10, 1, 1, 0],
1633 &[35, 6, 2, 1, 10, 1, 1, 0],
1634 &[131, 6, 2, 1, 10, 1, 1, 0],
1635 &[163, 6, 2, 1, 10, 1, 1, 0, 0],
1636 &[163, 6, 2, 1, 10, 1, 1],
1637 &[163, 7, 2, 2, 1, 10, 1, 1, 0, 0],
1638 &[163, 7, 2, 2, 1, 10, 1, 1],
1639 &[163, 8, 48, 6, 2, 1, 10, 1, 1, 0],
1640 &[163, 9, 48, 7, 2, 2, 1, 10, 1, 1, 0],
1641 &[163, 128, 2, 1, 10, 1, 1, 0, 0, 0, 0],
1642 &[163, 128, 2, 1, 10, 1, 1, 0, 0],
1643 &[163, 128, 2, 2, 1, 10, 1, 1, 0, 0, 0, 0],
1644 &[163, 128, 2, 2, 1, 10, 1, 1, 0, 0],
1645 ];
1646 for &data in tests {
1647 parse_ber(data, |reader| {
1648 reader.read_tagged(Tag::context(3), |reader| {
1649 reader.read_i64()
1650 })
1651 }).unwrap_err();
1652 }
1653 }
1654