#![deny(missing_docs)]
mod decoder;
mod encoder;
pub mod identifier;
pub mod error;
pub use decoder::from_slice;
pub use encoder::to_vec;
pub use error::Result;
#[cfg(test)]
mod tests {
use super::*;
use core::types::*;
use serde_derive::{Deserialize, Serialize};
use typenum::consts::*;
use core::identifier::constant::*;
#[test]
fn bool() {
assert_eq!(true, from_slice(&to_vec(&true).unwrap()).unwrap());
assert_eq!(false, from_slice(&to_vec(&false).unwrap()).unwrap());
}
#[test]
fn octet_string() {
let a = OctetString::from(vec![1u8, 2, 3, 4, 5]);
let b = OctetString::from(vec![5u8, 4, 3, 2, 1]);
assert_eq!(
a,
from_slice(&to_vec(&a).expect("encoding")).expect("decoding")
);
assert_eq!(b, from_slice(&to_vec(&b).unwrap()).unwrap());
}
#[test]
fn universal_string() {
let name = "Jones";
assert_eq!(
name,
from_slice::<String>(&*to_vec(&name).unwrap()).unwrap()
);
}
macro_rules! integer_tests {
($($integer:ident)*) => {
$(
#[test]
fn $integer() {
let min = <$integer>::min_value();
let max = <$integer>::max_value();
assert_eq!(min, from_slice(&to_vec(&min).unwrap()).unwrap());
assert_eq!(max, from_slice(&to_vec(&max).unwrap()).unwrap());
}
)*
}
}
integer_tests!(i8 i16 i32 i64 i128 u8 u16 u32 u64 u128);
#[test]
fn sequence() {
#[derive(Debug, Default, Deserialize, Serialize, PartialEq)]
struct Bools {
a: bool,
b: bool,
c: bool,
}
let raw = &[
0x30,
9,
1, 1, 0xff,
1, 1, 0,
1, 1, 0xff,
][..];
let default = Bools {
a: true,
b: false,
c: true,
};
assert_eq!(default, from_slice(&raw).unwrap());
assert_eq!(raw, &*to_vec(&default).unwrap());
let bools_vec = vec![true, false, true];
assert_eq!(bools_vec, from_slice::<Vec<bool>>(&raw).unwrap());
assert_eq!(raw, &*to_vec(&bools_vec).unwrap());
}
#[test]
fn choice() {
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
enum Foo {
Ein,
Zwei,
Drei,
}
impl Enumerable for Foo {}
let ein = Enumerated::new(Foo::Ein);
let zwei = Enumerated::new(Foo::Zwei);
let drei = Enumerated::new(Foo::Drei);
assert_eq!(ein, from_slice(&to_vec(&ein).unwrap()).unwrap());
assert_eq!(zwei, from_slice(&to_vec(&zwei).unwrap()).unwrap());
assert_eq!(drei, from_slice(&to_vec(&drei).unwrap()).unwrap());
}
#[test]
fn choice_newtype_variant() {
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
enum Foo {
Bar(Implicit<Context, U0, bool>),
Baz(Implicit<Context, U1, OctetString>),
}
let bar = Foo::Bar(Implicit::new(true));
let baz = Foo::Baz(Implicit::new(OctetString::from(vec![1, 2, 3, 4, 5])));
assert_eq!(bar, from_slice(&to_vec(&bar).unwrap()).unwrap());
assert_eq!(baz, from_slice(&to_vec(&baz).unwrap()).unwrap());
}
#[test]
fn sequence_in_sequence_in_choice() {
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
enum FooExtern {
Bar(Implicit<Context, U0, BarData>),
}
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
struct BarData {
data: OctetString,
}
let bar_extern = FooExtern::Bar(Implicit::new(BarData {
data: OctetString::from(vec![1, 2, 3, 4]),
}));
let extern_encoded = to_vec(&bar_extern).unwrap();
assert_eq!(bar_extern, from_slice(&extern_encoded).unwrap());
}
#[test]
fn response() {
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
struct Response {
status: Status,
body: Body,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
enum Status {
Success(Implicit<Context, U0, ()>),
Error(Implicit<Context, U1, u8>),
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
struct Body {
data: OctetString,
}
let response = Response {
status: Status::Success(Implicit::new(())),
body: Body {
data: OctetString::from(vec![1, 2, 3, 4, 5]),
},
};
assert_eq!(response, from_slice(&to_vec(&response).unwrap()).unwrap());
}
#[test]
fn option() {
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
struct Struct {
a: Option<u8>,
b: Option<u8>,
}
let data = Struct { a: None, b: Some(100) };
assert_eq!(data, from_slice(&to_vec(&data).unwrap()).unwrap());
}
#[test]
fn object_identifier() {
use core::types::ObjectIdentifier;
let iso = ObjectIdentifier::new(vec![1, 2]).unwrap();
let us_ansi = ObjectIdentifier::new(vec![1, 2, 840]).unwrap();
let rsa = ObjectIdentifier::new(vec![1, 2, 840, 113549]).unwrap();
let pkcs = ObjectIdentifier::new(vec![1, 2, 840, 113549, 1]).unwrap();
assert_eq!(iso.clone(), from_slice(&to_vec(&iso).unwrap()).unwrap());
assert_eq!(
us_ansi.clone(),
from_slice(&to_vec(&us_ansi).unwrap()).unwrap()
);
assert_eq!(rsa.clone(), from_slice(&to_vec(&rsa).unwrap()).unwrap());
assert_eq!(pkcs.clone(), from_slice(&to_vec(&pkcs).unwrap()).unwrap());
}
#[test]
fn long_sequence() {
let vec = vec![5u8; 0xffff];
assert_eq!(vec, from_slice::<Vec<u8>>(&to_vec(&vec).unwrap()).unwrap());
}
#[test]
fn sequence_with_option() {
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
struct Foo {
a: u8,
b: Option<u8>,
}
let some = Foo { a: 1, b: Some(2) };
let none = Foo { a: 1, b: None };
assert_eq!(some, from_slice(&to_vec(&some).unwrap()).unwrap());
assert_eq!(none, from_slice(&to_vec(&none).unwrap()).unwrap());
}
#[test]
fn bit_string() {
use core::types::BitString;
let bits = BitString::from_bytes(&[0x0A, 0x3B, 0x5F, 0x29, 0x1C, 0xD0]);
assert_eq!(bits, from_slice(&to_vec(&bits).unwrap()).unwrap());
}
#[test]
fn implicit_prefix() {
type MyInteger = core::types::Implicit<Context, U0, u64>;
let new_int = MyInteger::new(5);
assert_eq!(new_int, from_slice(&to_vec(&new_int).unwrap()).unwrap());
}
#[test]
fn explicit_prefix() {
type MyInteger = core::types::Explicit<Context, U0, u64>;
let new_int = MyInteger::new(5);
assert_eq!(new_int, from_slice(&to_vec(&new_int).unwrap()).unwrap());
}
#[test]
fn nested_enum() {
env_logger::init();
#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum Alpha {
A(Implicit<Context, U0, Charlie>),
B(Implicit<Context, U1, Charlie>),
}
#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum Bravo {
A,
B,
}
impl Enumerable for Bravo {}
type Charlie = Enumerated<Bravo>;
let input = Alpha::A(Implicit::new(Enumerated::new(Bravo::B)));
assert_eq!(input, from_slice(&to_vec(&input).unwrap()).unwrap())
}
}