Source code
Revision control
Copy as Markdown
Other Tools
use crate::FromStr;
use crate::{BareItem, Decimal, Dictionary, InnerList, Item, List, Num, Parameters};
use crate::{ParseMore, ParseValue, Parser};
use std::error::Error;
use std::iter::FromIterator;
#[test]
fn parse() -> Result<(), Box<dyn Error>> {
let input = "\"some_value\"".as_bytes();
let parsed_item = Item::new(BareItem::String("some_value".to_owned()));
let expected = parsed_item;
assert_eq!(expected, Parser::parse_item(input)?);
let input = "12.35;a ".as_bytes();
let params = Parameters::from_iter(vec![("a".to_owned(), BareItem::Boolean(true))]);
let expected = Item::with_params(Decimal::from_str("12.35")?.into(), params);
assert_eq!(expected, Parser::parse_item(input)?);
Ok(())
}
#[test]
fn parse_errors() -> Result<(), Box<dyn Error>> {
let input = "\"some_value¢\"".as_bytes();
assert_eq!(
Err("parse: non-ascii characters in input"),
Parser::parse_item(input)
);
let input = "\"some_value\" trailing_text".as_bytes();
assert_eq!(
Err("parse: trailing characters after parsed value"),
Parser::parse_item(input)
);
assert_eq!(
Err("parse_bare_item: empty item"),
Parser::parse_item("".as_bytes())
);
Ok(())
}
#[test]
fn parse_list_of_numbers() -> Result<(), Box<dyn Error>> {
let mut input = "1,42".chars().peekable();
let item1 = Item::new(1.into());
let item2 = Item::new(42.into());
let expected_list: List = vec![item1.into(), item2.into()];
assert_eq!(expected_list, List::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_list_with_multiple_spaces() -> Result<(), Box<dyn Error>> {
let mut input = "1 , 42".chars().peekable();
let item1 = Item::new(1.into());
let item2 = Item::new(42.into());
let expected_list: List = vec![item1.into(), item2.into()];
assert_eq!(expected_list, List::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_list_of_lists() -> Result<(), Box<dyn Error>> {
let mut input = "(1 2), (42 43)".chars().peekable();
let item1 = Item::new(1.into());
let item2 = Item::new(2.into());
let item3 = Item::new(42.into());
let item4 = Item::new(43.into());
let inner_list_1 = InnerList::new(vec![item1, item2]);
let inner_list_2 = InnerList::new(vec![item3, item4]);
let expected_list: List = vec![inner_list_1.into(), inner_list_2.into()];
assert_eq!(expected_list, List::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_list_empty_inner_list() -> Result<(), Box<dyn Error>> {
let mut input = "()".chars().peekable();
let inner_list = InnerList::new(vec![]);
let expected_list: List = vec![inner_list.into()];
assert_eq!(expected_list, List::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_list_empty() -> Result<(), Box<dyn Error>> {
let mut input = "".chars().peekable();
let expected_list: List = vec![];
assert_eq!(expected_list, List::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_list_of_lists_with_param_and_spaces() -> Result<(), Box<dyn Error>> {
let mut input = "( 1 42 ); k=*".chars().peekable();
let item1 = Item::new(1.into());
let item2 = Item::new(42.into());
let inner_list_param =
Parameters::from_iter(vec![("k".to_owned(), BareItem::Token("*".to_owned()))]);
let inner_list = InnerList::with_params(vec![item1, item2], inner_list_param);
let expected_list: List = vec![inner_list.into()];
assert_eq!(expected_list, List::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_list_of_items_and_lists_with_param() -> Result<(), Box<dyn Error>> {
let mut input = "12, 14, (a b); param=\"param_value_1\", ()"
.chars()
.peekable();
let item1 = Item::new(12.into());
let item2 = Item::new(14.into());
let item3 = Item::new(BareItem::Token("a".to_owned()));
let item4 = Item::new(BareItem::Token("b".to_owned()));
let inner_list_param = Parameters::from_iter(vec![(
"param".to_owned(),
BareItem::String("param_value_1".to_owned()),
)]);
let inner_list = InnerList::with_params(vec![item3, item4], inner_list_param);
let empty_inner_list = InnerList::new(vec![]);
let expected_list: List = vec![
item1.into(),
item2.into(),
inner_list.into(),
empty_inner_list.into(),
];
assert_eq!(expected_list, List::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_list_errors() -> Result<(), Box<dyn Error>> {
let mut input = ",".chars().peekable();
assert_eq!(
Err("parse_bare_item: item type can't be identified"),
List::parse(&mut input)
);
let mut input = "a, b c".chars().peekable();
assert_eq!(
Err("parse_list: trailing characters after list member"),
List::parse(&mut input)
);
let mut input = "a,".chars().peekable();
assert_eq!(Err("parse_list: trailing comma"), List::parse(&mut input));
let mut input = "a , ".chars().peekable();
assert_eq!(Err("parse_list: trailing comma"), List::parse(&mut input));
let mut input = "a\t \t ,\t ".chars().peekable();
assert_eq!(Err("parse_list: trailing comma"), List::parse(&mut input));
let mut input = "a\t\t,\t\t\t".chars().peekable();
assert_eq!(Err("parse_list: trailing comma"), List::parse(&mut input));
let mut input = "(a b),".chars().peekable();
assert_eq!(Err("parse_list: trailing comma"), List::parse(&mut input));
let mut input = "(1, 2, (a b)".chars().peekable();
assert_eq!(
Err("parse_inner_list: bad delimitation"),
List::parse(&mut input)
);
Ok(())
}
#[test]
fn parse_inner_list_errors() -> Result<(), Box<dyn Error>> {
let mut input = "c b); a=1".chars().peekable();
assert_eq!(
Err("parse_inner_list: input does not start with '('"),
Parser::parse_inner_list(&mut input)
);
Ok(())
}
#[test]
fn parse_inner_list_with_param_and_spaces() -> Result<(), Box<dyn Error>> {
let mut input = "(c b); a=1".chars().peekable();
let inner_list_param = Parameters::from_iter(vec![("a".to_owned(), 1.into())]);
let item1 = Item::new(BareItem::Token("c".to_owned()));
let item2 = Item::new(BareItem::Token("b".to_owned()));
let expected = InnerList::with_params(vec![item1, item2], inner_list_param);
assert_eq!(expected, Parser::parse_inner_list(&mut input)?);
Ok(())
}
#[test]
fn parse_item_int_with_space() -> Result<(), Box<dyn Error>> {
let mut input = "12 ".chars().peekable();
assert_eq!(Item::new(12.into()), Item::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_item_decimal_with_bool_param_and_space() -> Result<(), Box<dyn Error>> {
let mut input = "12.35;a ".chars().peekable();
let param = Parameters::from_iter(vec![("a".to_owned(), BareItem::Boolean(true))]);
assert_eq!(
Item::with_params(Decimal::from_str("12.35")?.into(), param),
Item::parse(&mut input)?
);
Ok(())
}
#[test]
fn parse_item_number_with_param() -> Result<(), Box<dyn Error>> {
let param = Parameters::from_iter(vec![("a1".to_owned(), BareItem::Token("*".to_owned()))]);
assert_eq!(
Item::with_params(BareItem::String("12.35".to_owned()), param),
Item::parse(&mut "\"12.35\";a1=*".chars().peekable())?
);
Ok(())
}
#[test]
fn parse_item_errors() -> Result<(), Box<dyn Error>> {
assert_eq!(
Err("parse_bare_item: empty item"),
Item::parse(&mut "".chars().peekable())
);
Ok(())
}
#[test]
fn parse_dict_empty() -> Result<(), Box<dyn Error>> {
assert_eq!(
Dictionary::new(),
Dictionary::parse(&mut "".chars().peekable())?
);
Ok(())
}
#[test]
fn parse_dict_errors() -> Result<(), Box<dyn Error>> {
let mut input = "abc=123;a=1;b=2 def".chars().peekable();
assert_eq!(
Err("parse_dict: trailing characters after dictionary member"),
Dictionary::parse(&mut input)
);
let mut input = "abc=123;a=1,".chars().peekable();
assert_eq!(
Err("parse_dict: trailing comma"),
Dictionary::parse(&mut input)
);
Ok(())
}
#[test]
fn parse_dict_with_spaces_and_params() -> Result<(), Box<dyn Error>> {
let mut input = "abc=123;a=1;b=2, def=456, ghi=789;q=9;r=\"+w\""
.chars()
.peekable();
let item1_params =
Parameters::from_iter(vec![("a".to_owned(), 1.into()), ("b".to_owned(), 2.into())]);
let item3_params = Parameters::from_iter(vec![
("q".to_owned(), 9.into()),
("r".to_owned(), BareItem::String("+w".to_owned())),
]);
let item1 = Item::with_params(123.into(), item1_params);
let item2 = Item::new(456.into());
let item3 = Item::with_params(789.into(), item3_params);
let expected_dict = Dictionary::from_iter(vec![
("abc".to_owned(), item1.into()),
("def".to_owned(), item2.into()),
("ghi".to_owned(), item3.into()),
]);
assert_eq!(expected_dict, Dictionary::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_dict_empty_value() -> Result<(), Box<dyn Error>> {
let mut input = "a=()".chars().peekable();
let inner_list = InnerList::new(vec![]);
let expected_dict = Dictionary::from_iter(vec![("a".to_owned(), inner_list.into())]);
assert_eq!(expected_dict, Dictionary::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_dict_with_token_param() -> Result<(), Box<dyn Error>> {
let mut input = "a=1, b;foo=*, c=3".chars().peekable();
let item2_params =
Parameters::from_iter(vec![("foo".to_owned(), BareItem::Token("*".to_owned()))]);
let item1 = Item::new(1.into());
let item2 = Item::with_params(BareItem::Boolean(true), item2_params);
let item3 = Item::new(3.into());
let expected_dict = Dictionary::from_iter(vec![
("a".to_owned(), item1.into()),
("b".to_owned(), item2.into()),
("c".to_owned(), item3.into()),
]);
assert_eq!(expected_dict, Dictionary::parse(&mut input)?);
Ok(())
}
#[test]
fn parse_dict_multiple_spaces() -> Result<(), Box<dyn Error>> {
// input1, input2, input3 must be parsed into the same structure
let item1 = Item::new(1.into());
let item2 = Item::new(2.into());
let expected_dict = Dictionary::from_iter(vec![
("a".to_owned(), item1.into()),
("b".to_owned(), item2.into()),
]);
let mut input1 = "a=1 , b=2".chars().peekable();
let mut input2 = "a=1\t,\tb=2".chars().peekable();
let mut input3 = "a=1, b=2".chars().peekable();
assert_eq!(expected_dict, Dictionary::parse(&mut input1)?);
assert_eq!(expected_dict, Dictionary::parse(&mut input2)?);
assert_eq!(expected_dict, Dictionary::parse(&mut input3)?);
Ok(())
}
#[test]
fn parse_bare_item() -> Result<(), Box<dyn Error>> {
assert_eq!(
BareItem::Boolean(false),
Parser::parse_bare_item(&mut "?0".chars().peekable())?
);
assert_eq!(
BareItem::String("test string".to_owned()),
Parser::parse_bare_item(&mut "\"test string\"".chars().peekable())?
);
assert_eq!(
BareItem::Token("*token".to_owned()),
Parser::parse_bare_item(&mut "*token".chars().peekable())?
);
assert_eq!(
BareItem::ByteSeq("base_64 encoding test".to_owned().into_bytes()),
Parser::parse_bare_item(&mut ":YmFzZV82NCBlbmNvZGluZyB0ZXN0:".chars().peekable())?
);
assert_eq!(
BareItem::Decimal(Decimal::from_str("-3.55")?),
Parser::parse_bare_item(&mut "-3.55".chars().peekable())?
);
Ok(())
}
#[test]
fn parse_bare_item_errors() -> Result<(), Box<dyn Error>> {
assert_eq!(
Err("parse_bare_item: item type can't be identified"),
Parser::parse_bare_item(&mut "!?0".chars().peekable())
);
assert_eq!(
Err("parse_bare_item: item type can't be identified"),
Parser::parse_bare_item(&mut "_11abc".chars().peekable())
);
assert_eq!(
Err("parse_bare_item: item type can't be identified"),
Parser::parse_bare_item(&mut " ".chars().peekable())
);
Ok(())
}
#[test]
fn parse_bool() -> Result<(), Box<dyn Error>> {
let mut input = "?0gk".chars().peekable();
assert_eq!(false, Parser::parse_bool(&mut input)?);
assert_eq!(input.collect::<String>(), "gk");
assert_eq!(false, Parser::parse_bool(&mut "?0".chars().peekable())?);
assert_eq!(true, Parser::parse_bool(&mut "?1".chars().peekable())?);
Ok(())
}
#[test]
fn parse_bool_errors() -> Result<(), Box<dyn Error>> {
assert_eq!(
Err("parse_bool: first character is not '?'"),
Parser::parse_bool(&mut "".chars().peekable())
);
assert_eq!(
Err("parse_bool: invalid variant"),
Parser::parse_bool(&mut "?".chars().peekable())
);
Ok(())
}
#[test]
fn parse_string() -> Result<(), Box<dyn Error>> {
let mut input = "\"some string\" ;not string".chars().peekable();
assert_eq!("some string".to_owned(), Parser::parse_string(&mut input)?);
assert_eq!(input.collect::<String>(), " ;not string");
assert_eq!(
"test".to_owned(),
Parser::parse_string(&mut "\"test\"".chars().peekable())?
);
assert_eq!(
r#"te\st"#.to_owned(),
Parser::parse_string(&mut "\"te\\\\st\"".chars().peekable())?
);
assert_eq!(
"".to_owned(),
Parser::parse_string(&mut "\"\"".chars().peekable())?
);
assert_eq!(
"some string".to_owned(),
Parser::parse_string(&mut "\"some string\"".chars().peekable())?
);
Ok(())
}
#[test]
fn parse_string_errors() -> Result<(), Box<dyn Error>> {
assert_eq!(
Err("parse_string: first character is not '\"'"),
Parser::parse_string(&mut "test".chars().peekable())
);
assert_eq!(
Err("parse_string: last input character is '\\'"),
Parser::parse_string(&mut "\"\\".chars().peekable())
);
assert_eq!(
Err("parse_string: disallowed character after '\\'"),
Parser::parse_string(&mut "\"\\l\"".chars().peekable())
);
assert_eq!(
Err("parse_string: not a visible character"),
Parser::parse_string(&mut "\"\u{1f}\"".chars().peekable())
);
assert_eq!(
Err("parse_string: no closing '\"'"),
Parser::parse_string(&mut "\"smth".chars().peekable())
);
Ok(())
}
#[test]
fn parse_token() -> Result<(), Box<dyn Error>> {
let mut input = "*some:token}not token".chars().peekable();
assert_eq!("*some:token".to_owned(), Parser::parse_token(&mut input)?);
assert_eq!(input.collect::<String>(), "}not token");
assert_eq!(
"token".to_owned(),
Parser::parse_token(&mut "token".chars().peekable())?
);
assert_eq!(
"a_b-c.d3:f%00/*".to_owned(),
Parser::parse_token(&mut "a_b-c.d3:f%00/*".chars().peekable())?
);
assert_eq!(
"TestToken".to_owned(),
Parser::parse_token(&mut "TestToken".chars().peekable())?
);
assert_eq!(
"some".to_owned(),
Parser::parse_token(&mut "some@token".chars().peekable())?
);
assert_eq!(
"*TestToken*".to_owned(),
Parser::parse_token(&mut "*TestToken*".chars().peekable())?
);
assert_eq!(
"*".to_owned(),
Parser::parse_token(&mut "*[@:token".chars().peekable())?
);
assert_eq!(
"test".to_owned(),
Parser::parse_token(&mut "test token".chars().peekable())?
);
Ok(())
}
#[test]
fn parse_token_errors() -> Result<(), Box<dyn Error>> {
let mut input = "765token".chars().peekable();
assert_eq!(
Err("parse_token: first character is not ALPHA or '*'"),
Parser::parse_token(&mut input)
);
assert_eq!(input.collect::<String>(), "765token");
assert_eq!(
Err("parse_token: first character is not ALPHA or '*'"),
Parser::parse_token(&mut "7token".chars().peekable())
);
assert_eq!(
Err("parse_token: empty input string"),
Parser::parse_token(&mut "".chars().peekable())
);
Ok(())
}
#[test]
fn parse_byte_sequence() -> Result<(), Box<dyn Error>> {
let mut input = ":aGVsbG8:rest_of_str".chars().peekable();
assert_eq!(
"hello".to_owned().into_bytes(),
Parser::parse_byte_sequence(&mut input)?
);
assert_eq!("rest_of_str", input.collect::<String>());
assert_eq!(
"hello".to_owned().into_bytes(),
Parser::parse_byte_sequence(&mut ":aGVsbG8:".chars().peekable())?
);
assert_eq!(
"test_encode".to_owned().into_bytes(),
Parser::parse_byte_sequence(&mut ":dGVzdF9lbmNvZGU:".chars().peekable())?
);
assert_eq!(
"new:year tree".to_owned().into_bytes(),
Parser::parse_byte_sequence(&mut ":bmV3OnllYXIgdHJlZQ==:".chars().peekable())?
);
assert_eq!(
"".to_owned().into_bytes(),
Parser::parse_byte_sequence(&mut "::".chars().peekable())?
);
Ok(())
}
#[test]
fn parse_byte_sequence_errors() -> Result<(), Box<dyn Error>> {
assert_eq!(
Err("parse_byte_seq: first char is not ':'"),
Parser::parse_byte_sequence(&mut "aGVsbG8".chars().peekable())
);
assert_eq!(
Err("parse_byte_seq: invalid char in byte sequence"),
Parser::parse_byte_sequence(&mut ":aGVsb G8=:".chars().peekable())
);
assert_eq!(
Err("parse_byte_seq: no closing ':'"),
Parser::parse_byte_sequence(&mut ":aGVsbG8=".chars().peekable())
);
Ok(())
}
#[test]
fn parse_number_int() -> Result<(), Box<dyn Error>> {
let mut input = "-733333333332d.14".chars().peekable();
assert_eq!(
Num::Integer(-733333333332),
Parser::parse_number(&mut input)?
);
assert_eq!("d.14", input.collect::<String>());
assert_eq!(
Num::Integer(42),
Parser::parse_number(&mut "42".chars().peekable())?
);
assert_eq!(
Num::Integer(-42),
Parser::parse_number(&mut "-42".chars().peekable())?
);
assert_eq!(
Num::Integer(-42),
Parser::parse_number(&mut "-042".chars().peekable())?
);
assert_eq!(
Num::Integer(0),
Parser::parse_number(&mut "0".chars().peekable())?
);
assert_eq!(
Num::Integer(0),
Parser::parse_number(&mut "00".chars().peekable())?
);
assert_eq!(
Num::Integer(123456789012345),
Parser::parse_number(&mut "123456789012345".chars().peekable())?
);
assert_eq!(
Num::Integer(-123456789012345),
Parser::parse_number(&mut "-123456789012345".chars().peekable())?
);
assert_eq!(
Num::Integer(2),
Parser::parse_number(&mut "2,3".chars().peekable())?
);
assert_eq!(
Num::Integer(4),
Parser::parse_number(&mut "4-2".chars().peekable())?
);
assert_eq!(
Num::Integer(-999999999999999),
Parser::parse_number(&mut "-999999999999999".chars().peekable())?
);
assert_eq!(
Num::Integer(999999999999999),
Parser::parse_number(&mut "999999999999999".chars().peekable())?
);
Ok(())
}
#[test]
fn parse_number_decimal() -> Result<(), Box<dyn Error>> {
let mut input = "00.42 test string".chars().peekable();
assert_eq!(
Num::Decimal(Decimal::from_str("0.42")?),
Parser::parse_number(&mut input)?
);
assert_eq!(" test string", input.collect::<String>());
assert_eq!(
Num::Decimal(Decimal::from_str("1.5")?),
Parser::parse_number(&mut "1.5.4.".chars().peekable())?
);
assert_eq!(
Num::Decimal(Decimal::from_str("1.8")?),
Parser::parse_number(&mut "1.8.".chars().peekable())?
);
assert_eq!(
Num::Decimal(Decimal::from_str("1.7")?),
Parser::parse_number(&mut "1.7.0".chars().peekable())?
);
assert_eq!(
Num::Decimal(Decimal::from_str("3.14")?),
Parser::parse_number(&mut "3.14".chars().peekable())?
);
assert_eq!(
Num::Decimal(Decimal::from_str("-3.14")?),
Parser::parse_number(&mut "-3.14".chars().peekable())?
);
assert_eq!(
Num::Decimal(Decimal::from_str("123456789012.1")?),
Parser::parse_number(&mut "123456789012.1".chars().peekable())?
);
assert_eq!(
Num::Decimal(Decimal::from_str("1234567890.112")?),
Parser::parse_number(&mut "1234567890.112".chars().peekable())?
);
Ok(())
}
#[test]
fn parse_number_errors() -> Result<(), Box<dyn Error>> {
let mut input = ":aGVsbG8:rest".chars().peekable();
assert_eq!(
Err("parse_number: input number does not start with a digit"),
Parser::parse_number(&mut input)
);
assert_eq!(":aGVsbG8:rest", input.collect::<String>());
let mut input = "-11.5555 test string".chars().peekable();
assert_eq!(
Err("parse_number: invalid decimal fraction length"),
Parser::parse_number(&mut input)
);
assert_eq!(" test string", input.collect::<String>());
assert_eq!(
Err("parse_number: input number does not start with a digit"),
Parser::parse_number(&mut "--0".chars().peekable())
);
assert_eq!(
Err("parse_number: decimal too long, illegal position for decimal point"),
Parser::parse_number(&mut "1999999999999.1".chars().peekable())
);
assert_eq!(
Err("parse_number: decimal ends with '.'"),
Parser::parse_number(&mut "19888899999.".chars().peekable())
);
assert_eq!(
Err("parse_number: integer too long, length > 15"),
Parser::parse_number(&mut "1999999999999999".chars().peekable())
);
assert_eq!(
Err("parse_number: decimal too long, length > 16"),
Parser::parse_number(&mut "19999999999.99991".chars().peekable())
);
assert_eq!(
Err("parse_number: input number does not start with a digit"),
Parser::parse_number(&mut "- 42".chars().peekable())
);
assert_eq!(
Err("parse_number: input number does not start with a digit"),
Parser::parse_number(&mut "- 42".chars().peekable())
);
assert_eq!(
Err("parse_number: decimal ends with '.'"),
Parser::parse_number(&mut "1..4".chars().peekable())
);
assert_eq!(
Err("parse_number: input number lacks a digit"),
Parser::parse_number(&mut "-".chars().peekable())
);
assert_eq!(
Err("parse_number: decimal ends with '.'"),
Parser::parse_number(&mut "-5. 14".chars().peekable())
);
assert_eq!(
Err("parse_number: decimal ends with '.'"),
Parser::parse_number(&mut "7. 1".chars().peekable())
);
assert_eq!(
Err("parse_number: invalid decimal fraction length"),
Parser::parse_number(&mut "-7.3333333333".chars().peekable())
);
assert_eq!(
Err("parse_number: decimal too long, illegal position for decimal point"),
Parser::parse_number(&mut "-7333333333323.12".chars().peekable())
);
Ok(())
}
#[test]
fn parse_params_string() -> Result<(), Box<dyn Error>> {
let mut input = ";b=\"param_val\"".chars().peekable();
let expected = Parameters::from_iter(vec![(
"b".to_owned(),
BareItem::String("param_val".to_owned()),
)]);
assert_eq!(expected, Parser::parse_parameters(&mut input)?);
Ok(())
}
#[test]
fn parse_params_bool() -> Result<(), Box<dyn Error>> {
let mut input = ";b;a".chars().peekable();
let expected = Parameters::from_iter(vec![
("b".to_owned(), BareItem::Boolean(true)),
("a".to_owned(), BareItem::Boolean(true)),
]);
assert_eq!(expected, Parser::parse_parameters(&mut input)?);
Ok(())
}
#[test]
fn parse_params_mixed_types() -> Result<(), Box<dyn Error>> {
let mut input = ";key1=?0;key2=746.15".chars().peekable();
let expected = Parameters::from_iter(vec![
("key1".to_owned(), BareItem::Boolean(false)),
("key2".to_owned(), Decimal::from_str("746.15")?.into()),
]);
assert_eq!(expected, Parser::parse_parameters(&mut input)?);
Ok(())
}
#[test]
fn parse_params_with_spaces() -> Result<(), Box<dyn Error>> {
let mut input = "; key1=?0; key2=11111".chars().peekable();
let expected = Parameters::from_iter(vec![
("key1".to_owned(), BareItem::Boolean(false)),
("key2".to_owned(), 11111.into()),
]);
assert_eq!(expected, Parser::parse_parameters(&mut input)?);
Ok(())
}
#[test]
fn parse_params_empty() -> Result<(), Box<dyn Error>> {
assert_eq!(
Parameters::new(),
Parser::parse_parameters(&mut " key1=?0; key2=11111".chars().peekable())?
);
assert_eq!(
Parameters::new(),
Parser::parse_parameters(&mut "".chars().peekable())?
);
assert_eq!(
Parameters::new(),
Parser::parse_parameters(&mut "[;a=1".chars().peekable())?
);
assert_eq!(
Parameters::new(),
Parser::parse_parameters(&mut String::new().chars().peekable())?
);
Ok(())
}
#[test]
fn parse_key() -> Result<(), Box<dyn Error>> {
assert_eq!(
"a".to_owned(),
Parser::parse_key(&mut "a=1".chars().peekable())?
);
assert_eq!(
"a1".to_owned(),
Parser::parse_key(&mut "a1=10".chars().peekable())?
);
assert_eq!(
"*1".to_owned(),
Parser::parse_key(&mut "*1=10".chars().peekable())?
);
assert_eq!(
"f".to_owned(),
Parser::parse_key(&mut "f[f=10".chars().peekable())?
);
Ok(())
}
#[test]
fn parse_key_errors() -> Result<(), Box<dyn Error>> {
assert_eq!(
Err("parse_key: first character is not lcalpha or '*'"),
Parser::parse_key(&mut "[*f=10".chars().peekable())
);
Ok(())
}
#[test]
fn parse_more_list() -> Result<(), Box<dyn Error>> {
let item1 = Item::new(1.into());
let item2 = Item::new(2.into());
let item3 = Item::new(42.into());
let inner_list_1 = InnerList::new(vec![item1, item2]);
let expected_list: List = vec![inner_list_1.into(), item3.into()];
let mut parsed_header = Parser::parse_list("(1 2)".as_bytes())?;
let _ = parsed_header.parse_more("42".as_bytes())?;
assert_eq!(expected_list, parsed_header);
Ok(())
}
#[test]
fn parse_more_dict() -> Result<(), Box<dyn Error>> {
let item2_params =
Parameters::from_iter(vec![("foo".to_owned(), BareItem::Token("*".to_owned()))]);
let item1 = Item::new(1.into());
let item2 = Item::with_params(BareItem::Boolean(true), item2_params);
let item3 = Item::new(3.into());
let expected_dict = Dictionary::from_iter(vec![
("a".to_owned(), item1.into()),
("b".to_owned(), item2.into()),
("c".to_owned(), item3.into()),
]);
let mut parsed_header = Parser::parse_dictionary("a=1, b;foo=*\t\t".as_bytes())?;
let _ = parsed_header.parse_more(" c=3".as_bytes())?;
assert_eq!(expected_dict, parsed_header);
Ok(())
}
#[test]
fn parse_more_errors() -> Result<(), Box<dyn Error>> {
let parsed_dict_header =
Parser::parse_dictionary("a=1, b;foo=*".as_bytes())?.parse_more(",a".as_bytes());
assert!(parsed_dict_header.is_err());
let parsed_list_header =
Parser::parse_list("a, b;foo=*".as_bytes())?.parse_more("(a, 2)".as_bytes());
assert!(parsed_list_header.is_err());
Ok(())
}