519 lines
18 KiB
Rust
519 lines
18 KiB
Rust
use asn1_rs::*;
|
|
use hex_literal::hex;
|
|
use nom::Needed;
|
|
#[cfg(feature = "datetime")]
|
|
use time::macros::datetime;
|
|
|
|
#[test]
|
|
fn from_ber_any() {
|
|
let input = &hex!("02 01 02 ff ff");
|
|
let (rem, result) = Any::from_ber(input).expect("parsing failed");
|
|
// dbg!(&result);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
assert_eq!(result.header.tag(), Tag::Integer);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_bitstring() {
|
|
//
|
|
// correct DER encoding
|
|
//
|
|
let input = &hex!("03 04 06 6e 5d c0");
|
|
let (rem, result) = BitString::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(result.unused_bits, 6);
|
|
assert_eq!(&result.data[..], &input[3..]);
|
|
//
|
|
// correct encoding, but wrong padding bits (not all set to 0)
|
|
//
|
|
let input = &hex!("03 04 06 6e 5d e0");
|
|
let (rem, result) = BitString::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(result.unused_bits, 6);
|
|
assert_eq!(&result.data[..], &input[3..]);
|
|
//
|
|
// long form of length (invalid, < 127)
|
|
//
|
|
let input = &hex!("03 81 04 06 6e 5d c0");
|
|
let (rem, result) = BitString::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(result.unused_bits, 6);
|
|
assert_eq!(&result.data[..], &input[4..]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_embedded_pdv() {
|
|
let input = &hex!("2b 0d a0 07 81 05 2a 03 04 05 06 82 02 aa a0");
|
|
let (rem, result) = EmbeddedPdv::from_ber(input).expect("parsing failed");
|
|
assert_eq!(rem, &[]);
|
|
assert_eq!(
|
|
result.identification,
|
|
PdvIdentification::Syntax(Oid::from(&[1, 2, 3, 4, 5, 6]).unwrap())
|
|
);
|
|
assert_eq!(result.data_value, &[0xaa, 0xa0]);
|
|
}
|
|
|
|
#[test]
|
|
fn embedded_pdv_variants() {
|
|
// identification: syntaxes
|
|
let input = &hex!("2b 11 a0 0c a0 0a 80 02 2a 03 81 04 2a 03 04 05 82 01 00");
|
|
let (rem, res) = EmbeddedPdv::from_ber(input).expect("parsing EMBEDDED PDV failed");
|
|
assert!(rem.is_empty());
|
|
assert!(matches!(
|
|
res.identification,
|
|
PdvIdentification::Syntaxes { .. }
|
|
));
|
|
// identification: syntax
|
|
let input = &hex!("2b 09 a0 04 81 02 2a 03 82 01 00");
|
|
let (rem, res) = EmbeddedPdv::from_ber(input).expect("parsing EMBEDDED PDV failed");
|
|
assert!(rem.is_empty());
|
|
assert!(matches!(res.identification, PdvIdentification::Syntax(_)));
|
|
// identification: presentation-context-id
|
|
let input = &hex!("2b 08 a0 03 82 01 02 82 01 00");
|
|
let (rem, res) = EmbeddedPdv::from_ber(input).expect("parsing EMBEDDED PDV failed");
|
|
assert!(rem.is_empty());
|
|
assert!(matches!(
|
|
res.identification,
|
|
PdvIdentification::PresentationContextId(_)
|
|
));
|
|
// identification: context-negotiation
|
|
let input = &hex!("2b 10 a0 0b a3 09 80 01 2a 81 04 2a 03 04 05 82 01 00");
|
|
let (rem, res) = EmbeddedPdv::from_ber(input).expect("parsing EMBEDDED PDV failed");
|
|
assert!(rem.is_empty());
|
|
assert!(matches!(
|
|
res.identification,
|
|
PdvIdentification::ContextNegotiation { .. }
|
|
));
|
|
// identification: transfer-syntax
|
|
let input = &hex!("2b 0b a0 06 84 04 2a 03 04 05 82 01 00");
|
|
let (rem, res) = EmbeddedPdv::from_ber(input).expect("parsing EMBEDDED PDV failed");
|
|
assert!(rem.is_empty());
|
|
assert!(matches!(
|
|
res.identification,
|
|
PdvIdentification::TransferSyntax(_)
|
|
));
|
|
// identification: fixed
|
|
let input = &hex!("2b 07 a0 02 85 00 82 01 00");
|
|
let (rem, res) = EmbeddedPdv::from_ber(input).expect("parsing EMBEDDED PDV failed");
|
|
assert!(rem.is_empty());
|
|
assert!(matches!(res.identification, PdvIdentification::Fixed));
|
|
// identification: invalid
|
|
let input = &hex!("2b 07 a0 02 86 00 82 01 00");
|
|
let e = EmbeddedPdv::from_ber(input).expect_err("parsing should fail");
|
|
assert!(matches!(e, Err::Error(Error::InvalidValue { .. })));
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_endofcontent() {
|
|
let input = &hex!("00 00");
|
|
let (rem, _result) = EndOfContent::from_ber(input).expect("parsing failed");
|
|
assert_eq!(rem, &[]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_generalizedtime() {
|
|
let input = &hex!("18 0F 32 30 30 32 31 32 31 33 31 34 32 39 32 33 5A FF");
|
|
let (rem, result) = GeneralizedTime::from_ber(input).expect("parsing failed");
|
|
assert_eq!(rem, &[0xff]);
|
|
#[cfg(feature = "datetime")]
|
|
{
|
|
let datetime = datetime! {2002-12-13 14:29:23 UTC};
|
|
|
|
assert_eq!(result.utc_datetime(), Ok(datetime));
|
|
}
|
|
let _ = result;
|
|
// local time with fractional seconds
|
|
let input = b"\x18\x1019851106210627.3";
|
|
let (rem, result) = GeneralizedTime::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(result.0.millisecond, Some(300));
|
|
assert_eq!(result.0.tz, ASN1TimeZone::Undefined);
|
|
#[cfg(feature = "datetime")]
|
|
{
|
|
let datetime = datetime! {1985-11-06 21:06:27.300_000_000 UTC};
|
|
assert_eq!(result.utc_datetime(), Ok(datetime));
|
|
}
|
|
let _ = result;
|
|
// coordinated universal time with fractional seconds
|
|
let input = b"\x18\x1119851106210627.3Z";
|
|
let (rem, result) = GeneralizedTime::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(result.0.millisecond, Some(300));
|
|
assert_eq!(result.0.tz, ASN1TimeZone::Z);
|
|
#[cfg(feature = "datetime")]
|
|
{
|
|
let datetime = datetime! {1985-11-06 21:06:27.300_000_000 UTC};
|
|
assert_eq!(result.utc_datetime(), Ok(datetime));
|
|
}
|
|
let _ = result;
|
|
// coordinated universal time with fractional seconds
|
|
let input = b"\x18\x1219851106210627.03Z";
|
|
let (rem, result) = GeneralizedTime::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(result.0.millisecond, Some(30));
|
|
assert_eq!(result.0.tz, ASN1TimeZone::Z);
|
|
#[cfg(feature = "datetime")]
|
|
{
|
|
let datetime = datetime! {1985-11-06 21:06:27.03 UTC};
|
|
assert_eq!(result.utc_datetime(), Ok(datetime));
|
|
}
|
|
let _ = result;
|
|
// local time with fractional seconds, and with local time 5 hours retarded in relation to coordinated universal time.
|
|
let input = b"\x18\x1519851106210627.3-0500";
|
|
let (rem, result) = GeneralizedTime::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(result.0.millisecond, Some(300));
|
|
assert_eq!(result.0.tz, ASN1TimeZone::Offset(-5, 0));
|
|
#[cfg(feature = "datetime")]
|
|
{
|
|
let datetime = datetime! {1985-11-06 21:06:27.300_000_000 -05:00};
|
|
assert_eq!(result.utc_datetime(), Ok(datetime));
|
|
}
|
|
let _ = result;
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_int() {
|
|
let input = &hex!("02 01 02 ff ff");
|
|
let (rem, result) = u8::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result, 2);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_relative_oid() {
|
|
let input = &hex!("0d 04 c2 7b 03 02");
|
|
let (rem, result) = Oid::from_ber_relative(input).expect("parsing failed");
|
|
assert_eq!(result, Oid::from_relative(&[8571, 3, 2]).unwrap());
|
|
assert_eq!(rem, &[]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_length_incomplete() {
|
|
let input = &hex!("30");
|
|
let res = u8::from_ber(input).expect_err("parsing should have failed");
|
|
assert_eq!(res, nom::Err::Incomplete(Needed::new(1)));
|
|
let input = &hex!("02");
|
|
let res = u8::from_ber(input).expect_err("parsing should have failed");
|
|
assert_eq!(res, nom::Err::Incomplete(Needed::new(1)));
|
|
let input = &hex!("02 05");
|
|
let res = u8::from_ber(input).expect_err("parsing should have failed");
|
|
assert_eq!(res, nom::Err::Incomplete(Needed::new(5)));
|
|
let input = &hex!("02 85");
|
|
let res = u8::from_ber(input).expect_err("parsing should have failed");
|
|
assert_eq!(res, nom::Err::Incomplete(Needed::new(5)));
|
|
let input = &hex!("02 85 ff");
|
|
let res = u8::from_ber(input).expect_err("parsing should have failed");
|
|
assert_eq!(res, nom::Err::Incomplete(Needed::new(4)));
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_length_invalid() {
|
|
let input = &hex!("02 ff 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10");
|
|
let res = u8::from_ber(input).expect_err("parsing should have failed");
|
|
assert_eq!(res, nom::Err::Error(Error::InvalidLength));
|
|
let input = &hex!("02 85 ff ff ff ff ff 00");
|
|
let res = u8::from_ber(input).expect_err("parsing should have failed");
|
|
assert!(res.is_incomplete());
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_octetstring() {
|
|
let input = &hex!("04 05 41 41 41 41 41");
|
|
let (rem, result) = OctetString::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result.as_ref(), b"AAAAA");
|
|
assert_eq!(rem, &[]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_real_binary() {
|
|
const EPSILON: f32 = 0.00001;
|
|
// binary, base = 2
|
|
let input = &hex!("09 03 80 ff 01 ff ff");
|
|
let (rem, result) = Real::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result, Real::binary(1.0, 2, -1));
|
|
assert!((result.f32() - 0.5).abs() < EPSILON);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
// binary, base = 2 and scale factor
|
|
let input = &hex!("09 03 94 ff 0d ff ff");
|
|
let (rem, result) = Real::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result, Real::binary(26.0, 2, -3).with_enc_base(8));
|
|
assert!((result.f32() - 3.25).abs() < EPSILON);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
// binary, base = 16
|
|
let input = &hex!("09 03 a0 fe 01 ff ff");
|
|
let (rem, result) = Real::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result, Real::binary(1.0, 2, -8).with_enc_base(16));
|
|
assert!((result.f32() - 0.00390625).abs() < EPSILON);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
// binary, exponent = 0
|
|
let input = &hex!("09 03 80 00 01 ff ff");
|
|
let (rem, result) = Real::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result, Real::binary(1.0, 2, 0));
|
|
assert!((result.f32() - 1.0).abs() < EPSILON);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
// 2 octets for exponent and negative exponent
|
|
let input = &hex!("09 04 a1 ff 01 03 ff ff");
|
|
let (rem, result) = Real::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result, Real::binary(3.0, 2, -1020).with_enc_base(16));
|
|
let epsilon = 1e-311_f64;
|
|
assert!((result.f64() - 2.67e-307).abs() < epsilon);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_real_f32() {
|
|
const EPSILON: f32 = 0.00001;
|
|
// binary, base = 2
|
|
let input = &hex!("09 03 80 ff 01 ff ff");
|
|
let (rem, result) = <f32>::from_ber(input).expect("parsing failed");
|
|
assert!((result - 0.5).abs() < EPSILON);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_real_f64() {
|
|
const EPSILON: f64 = 0.00001;
|
|
// binary, base = 2
|
|
let input = &hex!("09 03 80 ff 01 ff ff");
|
|
let (rem, result) = <f64>::from_ber(input).expect("parsing failed");
|
|
assert!((result - 0.5).abs() < EPSILON);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_real_special() {
|
|
// 0
|
|
let input = &hex!("09 00 ff ff");
|
|
let (rem, result) = Real::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result, Real::from(0.0));
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
// infinity
|
|
let input = &hex!("09 01 40 ff ff");
|
|
let (rem, result) = Real::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result, Real::Infinity);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
// negative infinity
|
|
let input = &hex!("09 01 41 ff ff");
|
|
let (rem, result) = Real::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result, Real::NegInfinity);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
}
|
|
|
|
#[test]
|
|
#[allow(clippy::approx_constant)]
|
|
fn from_ber_real_string() {
|
|
// text representation, NR3
|
|
let input = &hex!("09 07 03 33 31 34 45 2D 32 ff ff");
|
|
let (rem, result) = Real::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result, Real::from(3.14));
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
}
|
|
|
|
#[test]
|
|
#[allow(clippy::approx_constant)]
|
|
fn from_ber_real_string_primitive() {
|
|
// text representation, NR3
|
|
let input = &hex!("09 07 03 33 31 34 45 2D 32 ff ff");
|
|
let (rem, result) = f32::from_ber(input).expect("parsing failed");
|
|
assert!((result - 3.14).abs() < 0.01);
|
|
assert_eq!(rem, &[0xff, 0xff]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_sequence() {
|
|
let input = &hex!("30 05 02 03 01 00 01");
|
|
let (rem, result) = Sequence::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result.as_ref(), &input[2..]);
|
|
assert_eq!(rem, &[]);
|
|
//
|
|
let (_, i) = Sequence::from_ber_and_then(input, Integer::from_ber).expect("parsing failed");
|
|
assert_eq!(i.as_u32(), Ok(0x10001));
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_sequence_vec() {
|
|
let input = &hex!("30 05 02 03 01 00 01");
|
|
let (rem, result) = <Vec<u32>>::from_ber(input).expect("parsing failed");
|
|
assert_eq!(&result, &[65537]);
|
|
assert_eq!(rem, &[]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_sequence_of_vec() {
|
|
let input = &hex!("30 05 02 03 01 00 01");
|
|
let (rem, result) = <Sequence>::from_ber(input).expect("parsing failed");
|
|
let v = result
|
|
.ber_sequence_of::<u32, _>()
|
|
.expect("ber_sequence_of failed");
|
|
assert_eq!(rem, &[]);
|
|
assert_eq!(&v, &[65537]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_iter_sequence() {
|
|
let input = &hex!("30 0a 02 03 01 00 01 02 03 01 00 01");
|
|
let (rem, result) = Sequence::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result.as_ref(), &input[2..]);
|
|
assert_eq!(rem, &[]);
|
|
let v = result
|
|
.ber_iter()
|
|
.collect::<Result<Vec<u32>>>()
|
|
.expect("could not iterate sequence");
|
|
assert_eq!(&v, &[65537, 65537]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_set() {
|
|
let input = &hex!("31 05 02 03 01 00 01");
|
|
let (rem, result) = Set::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result.as_ref(), &input[2..]);
|
|
assert_eq!(rem, &[]);
|
|
//
|
|
let (_, i) = Set::from_ber_and_then(input, Integer::from_ber).expect("parsing failed");
|
|
assert_eq!(i.as_u32(), Ok(0x10001));
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_set_of_vec() {
|
|
let input = &hex!("31 05 02 03 01 00 01");
|
|
let (rem, result) = <Set>::from_ber(input).expect("parsing failed");
|
|
let v = result.ber_set_of::<u32, _>().expect("ber_set_of failed");
|
|
assert_eq!(rem, &[]);
|
|
assert_eq!(&v, &[65537]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_iter_set() {
|
|
let input = &hex!("31 0a 02 03 01 00 01 02 03 01 00 01");
|
|
let (rem, result) = Set::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result.as_ref(), &input[2..]);
|
|
assert_eq!(rem, &[]);
|
|
let v = result
|
|
.ber_iter()
|
|
.collect::<Result<Vec<u32>>>()
|
|
.expect("could not iterate set");
|
|
assert_eq!(&v, &[65537, 65537]);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_tag_custom() {
|
|
// canonical tag encoding
|
|
let input = &hex!("8f 02 12 34");
|
|
let (rem, any) = Any::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(any.tag(), Tag(15));
|
|
// non-canonical tag encoding
|
|
let input = &hex!("9f 0f 02 12 34");
|
|
let (rem, any) = Any::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(any.tag(), Tag(15));
|
|
assert_eq!(any.header.raw_tag(), Some(&[0x9f, 0x0f][..]));
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_tag_incomplete() {
|
|
let input = &hex!("9f a2 a2");
|
|
let res = Any::from_ber(input).expect_err("parsing should have failed");
|
|
assert_eq!(res, nom::Err::Error(Error::InvalidTag));
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_tag_overflow() {
|
|
let input = &hex!("9f a2 a2 a2 a2 a2 a2 22 01 00");
|
|
let res = Any::from_ber(input).expect_err("parsing should have failed");
|
|
assert_eq!(res, nom::Err::Error(Error::InvalidTag));
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_tag_long() {
|
|
let input = &hex!("9f a2 22 01 00");
|
|
let (rem, any) = Any::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(any.tag(), Tag(0x1122));
|
|
assert_eq!(any.header.raw_tag(), Some(&[0x9f, 0xa2, 0x22][..]));
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_iter_sequence_incomplete() {
|
|
let input = &hex!("30 09 02 03 01 00 01 02 03 01 00");
|
|
let (rem, result) = Sequence::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result.as_ref(), &input[2..]);
|
|
assert_eq!(rem, &[]);
|
|
let mut iter = result.ber_iter::<u32, Error>();
|
|
assert_eq!(iter.next(), Some(Ok(65537)));
|
|
assert_eq!(iter.next(), Some(Err(Error::Incomplete(Needed::new(1)))));
|
|
assert_eq!(iter.next(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_set_of() {
|
|
let input = &hex!("31 05 02 03 01 00 01");
|
|
let (rem, result) = SetOf::<u32>::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result.as_ref(), &[0x10001]);
|
|
assert_eq!(rem, &[]);
|
|
// not constructed
|
|
let input = &hex!("11 05 02 03 01 00 01");
|
|
let err = SetOf::<u32>::from_ber(input).expect_err("should have failed");
|
|
assert_eq!(err, Err::Error(Error::ConstructExpected));
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_tagged_explicit_optional() {
|
|
let input = &hex!("a0 03 02 01 02");
|
|
let (rem, result) =
|
|
Option::<TaggedExplicit<u32, Error, 0>>::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert!(result.is_some());
|
|
let tagged = result.unwrap();
|
|
assert_eq!(tagged.tag(), Tag(0));
|
|
assert_eq!(tagged.as_ref(), &2);
|
|
let (rem, result) =
|
|
Option::<TaggedExplicit<u32, Error, 1>>::from_ber(input).expect("parsing failed");
|
|
assert!(result.is_none());
|
|
assert_eq!(rem, input);
|
|
|
|
// using OptTaggedExplicit
|
|
let (rem, result) =
|
|
OptTaggedExplicit::<u32, Error, 0>::from_ber(input).expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert!(result.is_some());
|
|
let tagged = result.unwrap();
|
|
assert_eq!(tagged.tag(), Tag(0));
|
|
assert_eq!(tagged.as_ref(), &2);
|
|
|
|
// using OptTaggedParser
|
|
let (rem, result) = OptTaggedParser::from(0)
|
|
.parse_ber(input, |_, data| Integer::from_ber(data))
|
|
.expect("parsing failed");
|
|
assert!(rem.is_empty());
|
|
assert_eq!(result, Some(Integer::from(2)));
|
|
}
|
|
|
|
/// Generic tests on methods, and coverage tests
|
|
#[test]
|
|
fn from_ber_tagged_optional_cov() {
|
|
let p =
|
|
|input| OptTaggedParser::from(1).parse_ber::<_, Error, _>(input, |_, data| Ok((data, ())));
|
|
// empty input
|
|
let input = &[];
|
|
let (_, r) = p(input).expect("parsing failed");
|
|
assert!(r.is_none());
|
|
// wrong tag
|
|
let input = &hex!("a0 03 02 01 02");
|
|
let (_, r) = p(input).expect("parsing failed");
|
|
assert!(r.is_none());
|
|
// wrong class
|
|
let input = &hex!("e1 03 02 01 02");
|
|
let r = p(input);
|
|
assert!(r.is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn from_ber_universalstring() {
|
|
let input = &hex!("1C 10 00000061 00000062 00000063 00000064");
|
|
let (rem, result) = UniversalString::from_ber(input).expect("parsing failed");
|
|
assert_eq!(result.as_ref(), "abcd");
|
|
assert_eq!(rem, &[]);
|
|
}
|