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