synta 0.2.4

ASN.1 parser, decoder, and encoder library with DER/BER support and C FFI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

//! Tests for length encoding and decoding

extern crate alloc;

use synta::Length;

#[test]
fn test_short_form_encoding() {
    for len in 0..128 {
        let length = Length::Definite(len);
        let mut buffer = alloc::vec::Vec::new();
        length.encode(&mut buffer).unwrap();
        assert_eq!(buffer, vec![len as u8]);
    }
}

#[test]
fn test_short_form_decoding() {
    for len in 0..128 {
        let bytes = [len as u8];
        let (length, consumed) = Length::decode(&bytes, 0).unwrap();
        assert_eq!(length, Length::Definite(len));
        assert_eq!(consumed, 1);
    }
}

#[test]
fn test_long_form_encoding() {
    // 200 = 0xC8, requires 1 byte
    let length = Length::Definite(200);
    let mut buffer = alloc::vec::Vec::new();
    length.encode(&mut buffer).unwrap();
    assert_eq!(buffer, vec![0x81, 0xC8]);

    // 500 = 0x01F4, requires 2 bytes
    let length = Length::Definite(500);
    let mut buffer = alloc::vec::Vec::new();
    length.encode(&mut buffer).unwrap();
    assert_eq!(buffer, vec![0x82, 0x01, 0xF4]);

    // 70000 = 0x011170, requires 3 bytes
    let length = Length::Definite(70000);
    let mut buffer = alloc::vec::Vec::new();
    length.encode(&mut buffer).unwrap();
    assert_eq!(buffer, vec![0x83, 0x01, 0x11, 0x70]);
}

#[test]
fn test_long_form_decoding() {
    let bytes = [0x81, 0xC8];
    let (length, consumed) = Length::decode(&bytes, 0).unwrap();
    assert_eq!(length, Length::Definite(200));
    assert_eq!(consumed, 2);

    let bytes = [0x82, 0x01, 0xF4];
    let (length, consumed) = Length::decode(&bytes, 0).unwrap();
    assert_eq!(length, Length::Definite(500));
    assert_eq!(consumed, 3);

    let bytes = [0x83, 0x01, 0x11, 0x70];
    let (length, consumed) = Length::decode(&bytes, 0).unwrap();
    assert_eq!(length, Length::Definite(70000));
    assert_eq!(consumed, 4);
}

#[test]
fn test_indefinite_form() {
    let length = Length::Indefinite;
    let mut buffer = alloc::vec::Vec::new();
    length.encode(&mut buffer).unwrap();
    assert_eq!(buffer, vec![0x80]);

    let (decoded, consumed) = Length::decode(&buffer, 0).unwrap();
    assert_eq!(decoded, Length::Indefinite);
    assert_eq!(consumed, 1);
}

#[test]
fn test_roundtrip() {
    let test_cases = vec![0, 1, 127, 128, 255, 256, 65535, 65536, 1_000_000];

    for len in test_cases {
        let length = Length::Definite(len);
        let mut buffer = alloc::vec::Vec::new();
        length.encode(&mut buffer).unwrap();

        let (decoded, consumed) = Length::decode(&buffer, 0).unwrap();
        assert_eq!(decoded, length);
        assert_eq!(consumed, buffer.len());
    }
}

#[test]
fn test_encoded_len() {
    assert_eq!(Length::Definite(0).encoded_len().unwrap(), 1);
    assert_eq!(Length::Definite(127).encoded_len().unwrap(), 1);
    assert_eq!(Length::Definite(128).encoded_len().unwrap(), 2);
    assert_eq!(Length::Definite(255).encoded_len().unwrap(), 2);
    assert_eq!(Length::Definite(256).encoded_len().unwrap(), 3);
    assert_eq!(Length::Indefinite.encoded_len().unwrap(), 1);
}