use std::collections::HashMap;
use crate::{
file::{self, Section, SectionId},
parse::section,
};
mod try_from {
use std::{borrow::Cow, collections::HashMap, convert::TryFrom};
use super::{bodies, headers};
use crate::{
file::{self, SectionBodyIdsLut, SectionId},
parse::{
section,
tests::util::{name_event, newline_event, section_header, value_event},
Event,
},
File,
};
#[test]
fn empty() {
let config = File::try_from("").unwrap();
assert_eq!(config.section_id_counter, 0);
assert!(config.section_lookup_tree.is_empty());
assert!(config.sections.is_empty());
assert!(config.section_order.is_empty());
}
#[test]
fn single_section() {
let mut config = File::try_from("[core]\na=b\nc=d").unwrap();
let expected_separators = {
let mut map = HashMap::new();
map.insert(SectionId(0), section_header("core", None));
map
};
assert_eq!(headers(&config.sections), expected_separators);
assert_eq!(config.section_id_counter, 1);
let expected_lookup_tree = {
let mut tree = HashMap::new();
tree.insert(
section::Name(Cow::Borrowed("core".into())),
vec![SectionBodyIdsLut::Terminal(vec![SectionId(0)])],
);
tree
};
assert_eq!(config.section_lookup_tree, expected_lookup_tree);
let expected_sections = {
let mut sections = HashMap::new();
sections.insert(
SectionId(0),
file::section::Body(
vec![
newline_event(),
name_event("a"),
Event::KeyValueSeparator,
value_event("b"),
newline_event(),
name_event("c"),
Event::KeyValueSeparator,
value_event("d"),
]
.into(),
),
);
sections
};
assert_eq!(bodies(&config.sections), expected_sections);
assert_eq!(config.section_order.make_contiguous(), &[SectionId(0)]);
}
#[test]
fn single_subsection() {
let mut config = File::try_from("[core.sub]\na=b\nc=d").unwrap();
let expected_separators = {
let mut map = HashMap::new();
map.insert(SectionId(0), section_header("core", (".", "sub")));
map
};
assert_eq!(headers(&config.sections), expected_separators);
assert_eq!(config.section_id_counter, 1);
let expected_lookup_tree = {
let mut tree = HashMap::new();
let mut inner_tree = HashMap::new();
inner_tree.insert(Cow::Borrowed("sub".into()), vec![SectionId(0)]);
tree.insert(
section::Name(Cow::Borrowed("core".into())),
vec![SectionBodyIdsLut::NonTerminal(inner_tree)],
);
tree
};
assert_eq!(config.section_lookup_tree, expected_lookup_tree);
let expected_sections = {
let mut sections = HashMap::new();
sections.insert(
SectionId(0),
file::section::Body(
vec![
newline_event(),
name_event("a"),
Event::KeyValueSeparator,
value_event("b"),
newline_event(),
name_event("c"),
Event::KeyValueSeparator,
value_event("d"),
]
.into(),
),
);
sections
};
assert_eq!(bodies(&config.sections), expected_sections);
assert_eq!(config.section_order.make_contiguous(), &[SectionId(0)]);
}
#[test]
fn multiple_sections() {
let mut config = File::try_from("[core]\na=b\nc=d\n[other]e=f").unwrap();
let expected_separators = {
let mut map = HashMap::new();
map.insert(SectionId(0), section_header("core", None));
map.insert(SectionId(1), section_header("other", None));
map
};
assert_eq!(headers(&config.sections), expected_separators);
assert_eq!(config.section_id_counter, 2);
let expected_lookup_tree = {
let mut tree = HashMap::new();
tree.insert(
section::Name(Cow::Borrowed("core".into())),
vec![SectionBodyIdsLut::Terminal(vec![SectionId(0)])],
);
tree.insert(
section::Name(Cow::Borrowed("other".into())),
vec![SectionBodyIdsLut::Terminal(vec![SectionId(1)])],
);
tree
};
assert_eq!(config.section_lookup_tree, expected_lookup_tree);
let expected_sections = {
let mut sections = HashMap::new();
sections.insert(
SectionId(0),
file::section::Body(
vec![
newline_event(),
name_event("a"),
Event::KeyValueSeparator,
value_event("b"),
newline_event(),
name_event("c"),
Event::KeyValueSeparator,
value_event("d"),
newline_event(),
]
.into(),
),
);
sections.insert(
SectionId(1),
file::section::Body(vec![name_event("e"), Event::KeyValueSeparator, value_event("f")].into()),
);
sections
};
assert_eq!(bodies(&config.sections), expected_sections);
assert_eq!(config.section_order.make_contiguous(), &[SectionId(0), SectionId(1)]);
}
#[test]
fn multiple_duplicate_sections() {
let mut config = File::try_from("[core]\na=b\nc=d\n[core]e=f").unwrap();
let expected_separators = {
let mut map = HashMap::new();
map.insert(SectionId(0), section_header("core", None));
map.insert(SectionId(1), section_header("core", None));
map
};
assert_eq!(headers(&config.sections), expected_separators);
assert_eq!(config.section_id_counter, 2);
let expected_lookup_tree = {
let mut tree = HashMap::new();
tree.insert(
section::Name(Cow::Borrowed("core".into())),
vec![SectionBodyIdsLut::Terminal(vec![SectionId(0), SectionId(1)])],
);
tree
};
assert_eq!(config.section_lookup_tree, expected_lookup_tree);
let expected_sections = {
let mut sections = HashMap::new();
sections.insert(
SectionId(0),
file::section::Body(
vec![
newline_event(),
name_event("a"),
Event::KeyValueSeparator,
value_event("b"),
newline_event(),
name_event("c"),
Event::KeyValueSeparator,
value_event("d"),
newline_event(),
]
.into(),
),
);
sections.insert(
SectionId(1),
file::section::Body(vec![name_event("e"), Event::KeyValueSeparator, value_event("f")].into()),
);
sections
};
assert_eq!(bodies(&config.sections), expected_sections);
assert_eq!(config.section_order.make_contiguous(), &[SectionId(0), SectionId(1)]);
}
}
fn headers<'a>(sections: &HashMap<SectionId, Section<'a>>) -> HashMap<SectionId, section::Header<'a>> {
sections.iter().map(|(k, v)| (*k, v.header.clone())).collect()
}
fn bodies<'a>(sections: &HashMap<SectionId, Section<'a>>) -> HashMap<SectionId, file::section::Body<'a>> {
sections.iter().map(|(k, v)| (*k, v.body.clone())).collect()
}