rasn 0.28.2

A safe no_std ASN.1 codec framework.
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

use rasn::prelude::*;

#[derive(Debug, AsnType, rasn::Encode, rasn::Decode, PartialEq)]
#[rasn(delegate, size("1..=255"))]
struct SimpleNumericString(pub NumericString);

#[derive(Debug, AsnType, rasn::Encode, rasn::Decode, PartialEq)]
#[rasn(delegate, from("0..=9"), size("1..=255"))]
struct SimpleConstrainedNumericString(pub NumericString);

#[derive(Debug, AsnType, rasn::Encode, rasn::Decode, PartialEq)]
#[rasn(delegate, from("0..=2"), size("1..=255"))]
struct Simple123NumericString(pub NumericString);

#[test]
fn round_trip_numeric_string_aper() {
    let string = SimpleNumericString(
        NumericString::from_bytes(b"12345 12345 12345 0")
            .expect("Failed to construct NumericString"),
    );
    let encoded = rasn::aper::encode(&string).expect("Failed to encode");
    assert_eq!(&encoded, &[18, 35, 69, 96, 35, 69, 96, 35, 69, 96, 16]);
    let decoded: SimpleNumericString = rasn::aper::decode(&encoded).expect("Failed to decode");
    assert_eq!(decoded, string);
}

#[test]
fn round_trip_numeric_string_uper() {
    let string = SimpleNumericString(
        NumericString::from_bytes(b"12345 12345 12345 0")
            .expect("Failed to construct NumericString"),
    );
    let encoded = rasn::uper::encode(&string).expect("Failed to encode");
    assert_eq!(&encoded, &[18, 35, 69, 96, 35, 69, 96, 35, 69, 96, 16]);
    let decoded: SimpleNumericString = rasn::uper::decode(&encoded).expect("Failed to decode");
    assert_eq!(decoded, string);
}

#[test]
fn round_trip_constrained_numeric_string_aper() {
    let string = SimpleConstrainedNumericString(
        NumericString::from_bytes(b"123451234512345").expect("Failed to construct NumericString"),
    );
    let encoded = rasn::aper::encode(&string).expect("Failed to encode");
    assert_eq!(&encoded, &[14, 18, 52, 81, 35, 69, 18, 52, 80]);
    let decoded: SimpleConstrainedNumericString =
        rasn::aper::decode(&encoded).expect("Failed to decode");
    assert_eq!(decoded, string);
}

#[test]
fn round_trip_constrained_numeric_string_uper() {
    let string = SimpleConstrainedNumericString(
        NumericString::from_bytes(b"123451234512345").expect("Failed to construct NumericString"),
    );
    let encoded = rasn::uper::encode(&string).expect("Failed to encode");
    assert_eq!(&encoded, &[14, 18, 52, 81, 35, 69, 18, 52, 80]);
    let decoded: SimpleConstrainedNumericString =
        rasn::uper::decode(&encoded).expect("Failed to decode");
    assert_eq!(decoded, string);
}

#[test]
fn round_trip_limited_charset_numeric_string_aper() {
    let string = Simple123NumericString(
        NumericString::from_bytes(b"120120120").expect("Failed to construct NumericString"),
    );
    let encoded = rasn::aper::encode(&string).expect("Failed to encode");
    assert_eq!(&encoded, &[8, 97, 134, 0]);
    let decoded: Simple123NumericString = rasn::aper::decode(&encoded).expect("Failed to decode");
    assert_eq!(decoded, string);
}

#[test]
fn round_trip_limited_charset_numeric_string_uper() {
    let string = Simple123NumericString(
        NumericString::from_bytes(b"120120120").expect("Failed to construct NumericString"),
    );
    let encoded = rasn::uper::encode(&string).expect("Failed to encode");
    assert_eq!(&encoded, &[8, 97, 134, 0]);
    let decoded: Simple123NumericString = rasn::uper::decode(&encoded).expect("Failed to decode");
    assert_eq!(decoded, string);
}