From 616ebfa378dc518e5d19b57fe8a345b80ed86d98 Mon Sep 17 00:00:00 2001 From: Yuheng Chen Date: Wed, 27 May 2015 02:50:51 +0800 Subject: [PATCH] Refactory YAML document loader --- saphyr/src/parser.rs | 154 ++++++------------ saphyr/src/scanner.rs | 2 - saphyr/src/yaml.rs | 155 +++++++++++++++++- saphyr/tests/spec_test.rs | 66 -------- saphyr/tests/spec_test.rs.inc | 291 ++++++++++++---------------------- 5 files changed, 291 insertions(+), 377 deletions(-) delete mode 100644 saphyr/tests/spec_test.rs diff --git a/saphyr/src/parser.rs b/saphyr/src/parser.rs index cb95203..4ffab44 100644 --- a/saphyr/src/parser.rs +++ b/saphyr/src/parser.rs @@ -1,5 +1,5 @@ use scanner::*; -use yaml::*; +// use yaml::*; #[derive(Clone, Copy, PartialEq, Debug, Eq)] pub enum State { @@ -99,129 +99,107 @@ impl> Parser { self.states.push(state); } - pub fn parse(&mut self) -> ParseResult { + fn parse(&mut self, recv: &mut R) + -> ParseResult { if self.scanner.stream_ended() || self.state == State::End { return Ok(Event::StreamEnd); } - let ev = self.state_machine(); - println!("EV {:?}", ev); - ev + let ev = try!(self.state_machine()); + // println!("EV {:?}", ev); + recv.on_event(&ev); + Ok(ev) } - pub fn load(&mut self) -> Result { + pub fn load(&mut self, recv: &mut R, multi: bool) + -> Result<(), ScanError> { if !self.scanner.stream_started() { - let ev = try!(self.parse()); + let ev = try!(self.parse(recv)); assert_eq!(ev, Event::StreamStart); } if self.scanner.stream_ended() { // XXX has parsed? - return Ok(Yaml::Null); + recv.on_event(&Event::StreamEnd); + return Ok(()); } - let ev = try!(self.parse()); - if ev == Event::StreamEnd { - return Ok(Yaml::Null); - } - self.load_document(&ev) - } - - pub fn load_multidoc(&mut self) -> Result, ScanError> { - if !self.scanner.stream_started() { - let ev = try!(self.parse()); - assert_eq!(ev, Event::StreamStart); - } - - if self.scanner.stream_ended() { - // XXX has parsed? - return Ok(Vec::new()); - } - let mut docs: Vec = Vec::new(); loop { - let ev = try!(self.parse()); + let ev = try!(self.parse(recv)); if ev == Event::StreamEnd { - return Ok(docs); + recv.on_event(&Event::StreamEnd); + return Ok(()); + } + try!(self.load_document(&ev, recv)); + if !multi { + break; } - docs.push(try!(self.load_document(&ev))); } - unreachable!(); + Ok(()) } - fn load_document(&mut self, first_ev: &Event) -> Result { + fn load_document(&mut self, first_ev: &Event, recv: &mut R) + -> Result<(), ScanError> { assert_eq!(first_ev, &Event::DocumentStart); - let ev = try!(self.parse()); - let doc = try!(self.load_node(&ev)); + let ev = try!(self.parse(recv)); + try!(self.load_node(&ev, recv)); + // DOCUMENT-END is expected. - let ev = try!(self.parse()); + let ev = try!(self.parse(recv)); assert_eq!(ev, Event::DocumentEnd); - Ok(doc) + Ok(()) } - fn load_node(&mut self, first_ev: &Event) -> Result { + fn load_node(&mut self, first_ev: &Event, recv: &mut R) + -> Result<(), ScanError> { match *first_ev { Event::Scalar(ref v, style) => { - // TODO scalar - if style != TScalarStyle::Plain { - Ok(Yaml::String(v.clone())) - } else { - match v.as_ref() { - "~" => Ok(Yaml::Null), - "true" => Ok(Yaml::Boolean(true)), - "false" => Ok(Yaml::Boolean(false)), - // try parsing as f64 - _ if v.parse::().is_ok() => Ok(Yaml::Number(v.clone())), - _ => Ok(Yaml::String(v.clone())) - } - } + Ok(()) }, Event::SequenceStart => { - self.load_sequence(first_ev) + self.load_sequence(first_ev, recv) }, Event::MappingStart => { - self.load_mapping(first_ev) + self.load_mapping(first_ev, recv) }, // TODO more events _ => { unreachable!(); } } } - fn load_mapping(&mut self, first_ev: &Event) -> Result { - let mut ev = try!(self.parse()); - let mut map = Hash::new(); + fn load_mapping(&mut self, first_ev: &Event, recv: &mut R) + -> Result<(), ScanError> { + let mut ev = try!(self.parse(recv)); while ev != Event::MappingEnd { // key - let key = try!(self.load_node(&ev)); + try!(self.load_node(&ev, recv)); // value - ev = try!(self.parse()); - let value = try!(self.load_node(&ev)); - - map.insert(key, value); + ev = try!(self.parse(recv)); + try!(self.load_node(&ev, recv)); // next event - ev = try!(self.parse()); + ev = try!(self.parse(recv)); } - Ok(Yaml::Hash(map)) + Ok(()) } - fn load_sequence(&mut self, first_ev: &Event) -> Result { - let mut ev = try!(self.parse()); - let mut vec = Vec::new(); + fn load_sequence(&mut self, first_ev: &Event, recv: &mut R) + -> Result<(), ScanError> { + let mut ev = try!(self.parse(recv)); while ev != Event::SequenceEnd { - let entry = try!(self.load_node(&ev)); - vec.push(entry); + let entry = try!(self.load_node(&ev, recv)); // next event - ev = try!(self.parse()); + ev = try!(self.parse(recv)); } - Ok(Yaml::Array(vec)) + Ok(()) } fn state_machine(&mut self) -> ParseResult { let next_tok = self.peek(); - println!("cur_state {:?}, next tok: {:?}", self.state, next_tok); + //println!("cur_state {:?}, next tok: {:?}", self.state, next_tok); match self.state { State::StreamStart => self.stream_start(), @@ -526,43 +504,5 @@ impl> Parser { #[cfg(test)] mod test { use super::*; - #[test] - fn test_parser() { - let s: String = " -# comment -a0 bb: val -a1: - b1: 4 - b2: d -a2: 4 # i'm comment -a3: [1, 2, 3] -a4: - - - a1 - - a2 - - 2 -a5: 'single_quoted' -a6: \"double_quoted\" -a7: 你好 -".to_string(); - let mut parser = Parser::new(s.chars()); - let out = parser.load().unwrap(); - assert_eq!(out["a7"].as_str().unwrap(), "你好"); - } - - #[test] - fn test_multi_doc() { - let s = -" -'a scalar' ---- -'a scalar' ---- -'a scalar' -"; - let mut p = Parser::new(s.chars()); - let out = p.load_multidoc().unwrap(); - assert_eq!(out.len(), 3); - - } } diff --git a/saphyr/src/scanner.rs b/saphyr/src/scanner.rs index 5171f97..3f55eda 100644 --- a/saphyr/src/scanner.rs +++ b/saphyr/src/scanner.rs @@ -620,7 +620,6 @@ impl> Scanner { let start_mark = self.mark; while self.mark.col == indent && !is_z(self.ch()) { - println!("--> {:?}", self.ch()); // We are at the beginning of a non-empty line. trailing_blank = is_blank(self.ch()); if !literal && !leading_break.is_empty() @@ -640,7 +639,6 @@ impl> Scanner { leading_blank = is_blank(self.ch()); while !is_breakz(self.ch()) { - println!("----> {:?}", self.ch()); string.push(self.ch()); self.skip(); self.lookahead(1); diff --git a/saphyr/src/yaml.rs b/saphyr/src/yaml.rs index 4371a20..d6e3abc 100644 --- a/saphyr/src/yaml.rs +++ b/saphyr/src/yaml.rs @@ -2,6 +2,9 @@ use std::collections::BTreeMap; use std::ops::Index; use std::string; use std::str::FromStr; +use std::mem; +use parser::*; +use scanner::{TScalarStyle, ScanError}; #[derive(Clone, PartialEq, PartialOrd, Debug, Eq, Ord)] pub enum Yaml { @@ -20,6 +23,103 @@ pub enum Yaml { pub type Array = Vec; pub type Hash = BTreeMap; +pub struct YamlLoader { + docs: Vec, + // states + doc_stack: Vec, + key_stack: Vec, +} + +impl EventReceiver for YamlLoader { + fn on_event(&mut self, ev: &Event) { + println!("EV {:?}", ev); + match *ev { + Event::DocumentStart => { + // do nothing + }, + Event::DocumentEnd => { + match self.doc_stack.len() { + // empty document + 0 => self.docs.push(Yaml::BadValue), + 1 => self.docs.push(self.doc_stack.pop().unwrap()), + _ => unreachable!() + } + }, + Event::SequenceStart => { + self.doc_stack.push(Yaml::Array(Vec::new())); + }, + Event::SequenceEnd => { + let node = self.doc_stack.pop().unwrap(); + self.insert_new_node(node); + }, + Event::MappingStart => { + self.doc_stack.push(Yaml::Hash(Hash::new())); + self.key_stack.push(Yaml::BadValue); + }, + Event::MappingEnd => { + self.key_stack.pop().unwrap(); + let node = self.doc_stack.pop().unwrap(); + self.insert_new_node(node); + }, + Event::Scalar(ref v, style) => { + let node = if style != TScalarStyle::Plain { + Yaml::String(v.clone()) + } else { + match v.as_ref() { + "~" => Yaml::Null, + "true" => Yaml::Boolean(true), + "false" => Yaml::Boolean(false), + // try parsing as f64 + _ if v.parse::().is_ok() => Yaml::Number(v.clone()), + _ => Yaml::String(v.clone()) + } + }; + + self.insert_new_node(node); + }, + _ => { /* ignore */ } + } + // println!("DOC {:?}", self.doc_stack); + } +} + +impl YamlLoader { + fn insert_new_node(&mut self, node: Yaml) { + if !self.doc_stack.is_empty() { + let parent = self.doc_stack.last_mut().unwrap(); + match *parent { + Yaml::Array(ref mut v) => v.push(node), + Yaml::Hash(ref mut h) => { + let mut cur_key = self.key_stack.last_mut().unwrap(); + // current node is a key + if cur_key.is_badvalue() { + *cur_key = node; + // current node is a value + } else { + let mut newkey = Yaml::BadValue; + mem::swap(&mut newkey, cur_key); + h.insert(newkey, node); + } + }, + _ => unreachable!(), + } + } else { + self.doc_stack.push(node); + } + } + + pub fn load_from_str(source: &str) -> Result, ScanError>{ + let mut loader = YamlLoader { + docs: Vec::new(), + doc_stack: Vec::new(), + key_stack: Vec::new(), + }; + let mut parser = Parser::new(source.chars()); + try!(parser.load(&mut loader, true)); + Ok(loader.docs) + } +} + macro_rules! define_as ( ($name:ident, $t:ident, $yt:ident) => ( pub fn $name(&self) -> Option<$t> { @@ -102,10 +202,11 @@ impl Index for Yaml { } + #[cfg(test)] mod test { use parser::Parser; - use yaml::Yaml; + use yaml::*; #[test] fn test_coerce() { let s = "--- @@ -113,13 +214,51 @@ a: 1 b: 2.2 c: [1, 2] "; - let mut parser = Parser::new(s.chars()); - let out = parser.load().unwrap(); - assert_eq!(out["a"].as_number::().unwrap(), 1); - assert_eq!(out["b"].as_number::().unwrap(), 2.2f32); - assert_eq!(out["c"][1].as_number::().unwrap(), 2); - assert!(out["d"][0].is_badvalue()); - //assert_eq!(out.as_hash().unwrap()[&Yaml::String("a".to_string())].as_i64().unwrap(), 1i64); + let out = YamlLoader::load_from_str(&s).unwrap(); + let doc = &out[0]; + assert_eq!(doc["a"].as_number::().unwrap(), 1); + assert_eq!(doc["b"].as_number::().unwrap(), 2.2f32); + assert_eq!(doc["c"][1].as_number::().unwrap(), 2); + assert!(doc["d"][0].is_badvalue()); } + + #[test] + fn test_parser() { + let s: String = " +# comment +a0 bb: val +a1: + b1: 4 + b2: d +a2: 4 # i'm comment +a3: [1, 2, 3] +a4: + - - a1 + - a2 + - 2 +a5: 'single_quoted' +a6: \"double_quoted\" +a7: 你好 +".to_string(); + let out = YamlLoader::load_from_str(&s).unwrap(); + let doc = &out[0]; + println!("DOC {:?}", doc); + assert_eq!(doc["a7"].as_str().unwrap(), "你好"); + } + + #[test] + fn test_multi_doc() { + let s = +" +'a scalar' +--- +'a scalar' +--- +'a scalar' +"; + let out = YamlLoader::load_from_str(&s).unwrap(); + assert_eq!(out.len(), 3); + } + } diff --git a/saphyr/tests/spec_test.rs b/saphyr/tests/spec_test.rs deleted file mode 100644 index c5910b0..0000000 --- a/saphyr/tests/spec_test.rs +++ /dev/null @@ -1,66 +0,0 @@ -#![allow(dead_code)] -extern crate yaml_rust; - -use yaml_rust::parser::Parser; -use yaml_rust::yaml::Yaml; - - -#[derive(Clone, PartialEq, PartialOrd, Debug)] -enum TestEvent { - OnDocumentStart, - OnDocumentEnd, - OnSequenceStart, - OnSequenceEnd, - OnMapStart, - OnMapEnd, - OnScalar, - OnAlias, - OnNull, -} - -fn yaml_to_test_events(docs: &Vec) -> Vec { - println!("DOCS {:?}", docs); - fn next(root: &Yaml, evs: &mut Vec) { - match *root { - Yaml::BadValue => { panic!("unexpected BadValue"); }, - Yaml::Null => { evs.push(TestEvent::OnNull); }, - Yaml::Array(ref v) => { - evs.push(TestEvent::OnSequenceStart); - for e in v { - next(e, evs); - } - evs.push(TestEvent::OnSequenceEnd); - }, - Yaml::Hash(ref v) => { - evs.push(TestEvent::OnMapStart); - for (k, v) in v { - next(k, evs); - next(v, evs); - } - evs.push(TestEvent::OnMapEnd); - }, - _ => { evs.push(TestEvent::OnScalar); } - } - } - let mut evs: Vec = Vec::new(); - for doc in docs { - evs.push(TestEvent::OnDocumentStart); - next(doc, &mut evs); - evs.push(TestEvent::OnDocumentEnd); - } - evs -} - -macro_rules! assert_next { - ($v:expr, $p:pat) => ( - match $v.next().unwrap() { - $p => {}, - e => { panic!("unexpected event: {:?}", e); } - } - ) -} - -// auto generated from handler_spec_test.cpp -include!("specexamples.rs.inc"); -include!("spec_test.rs.inc"); - diff --git a/saphyr/tests/spec_test.rs.inc b/saphyr/tests/spec_test.rs.inc index 3282454..a359e7b 100644 --- a/saphyr/tests/spec_test.rs.inc +++ b/saphyr/tests/spec_test.rs.inc @@ -1,7 +1,6 @@ #[test] fn test_ex2_1_seq_scalars() { - let mut p = Parser::new(EX2_1.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_1).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -13,8 +12,7 @@ fn test_ex2_1_seq_scalars() { #[test] fn test_ex2_2_mapping_scalars_to_scalars() { - let mut p = Parser::new(EX2_2.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_2).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -29,8 +27,7 @@ fn test_ex2_2_mapping_scalars_to_scalars() { #[test] fn test_ex2_3_mapping_scalars_to_sequences() { - let mut p = Parser::new(EX2_3.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_3).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -51,8 +48,7 @@ fn test_ex2_3_mapping_scalars_to_sequences() { #[test] fn test_ex2_4_sequence_of_mappings() { - let mut p = Parser::new(EX2_4.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_4).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnMapStart); @@ -77,8 +73,7 @@ fn test_ex2_4_sequence_of_mappings() { #[test] fn test_ex2_5_sequence_of_sequences() { - let mut p = Parser::new(EX2_5.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_5).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnSequenceStart); @@ -102,8 +97,7 @@ fn test_ex2_5_sequence_of_sequences() { #[test] fn test_ex2_6_mapping_of_mappings() { - let mut p = Parser::new(EX2_6.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_6).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -126,8 +120,7 @@ fn test_ex2_6_mapping_of_mappings() { #[test] fn test_ex2_7_two_documents_in_a_stream() { - let mut p = Parser::new(EX2_7.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_7).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -145,8 +138,7 @@ fn test_ex2_7_two_documents_in_a_stream() { #[test] fn test_ex2_8_play_by_play_feed() { - let mut p = Parser::new(EX2_8.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_8).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -171,8 +163,7 @@ fn test_ex2_8_play_by_play_feed() { #[test] fn test_ex2_9_single_document_with_two_comments() { - let mut p = Parser::new(EX2_9.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_9).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -191,8 +182,7 @@ fn test_ex2_9_single_document_with_two_comments() { #[test] fn test_ex2_10_simple_anchor() { - let mut p = Parser::new(EX2_10.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_10).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -211,8 +201,7 @@ fn test_ex2_10_simple_anchor() { #[test] fn test_ex2_11_mapping_between_sequences() { - let mut p = Parser::new(EX2_11.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_11).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnSequenceStart); @@ -237,8 +226,7 @@ fn test_ex2_11_mapping_between_sequences() { #[test] fn test_ex2_12_compact_nested_mapping() { - let mut p = Parser::new(EX2_12.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_12).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnMapStart); @@ -265,8 +253,7 @@ fn test_ex2_12_compact_nested_mapping() { #[test] fn test_ex2_13_in_literals_newlines_are_preserved() { - let mut p = Parser::new(EX2_13.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_13).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -274,8 +261,7 @@ fn test_ex2_13_in_literals_newlines_are_preserved() { #[test] fn test_ex2_14_in_folded_scalars_newlines_become_spaces() { - let mut p = Parser::new(EX2_14.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_14).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -283,8 +269,7 @@ fn test_ex2_14_in_folded_scalars_newlines_become_spaces() { #[test] fn test_ex2_15_folded_newlines_are_preserved_for_more_indented_and_blank_lines() { - let mut p = Parser::new(EX2_15.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_15).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -292,8 +277,7 @@ fn test_ex2_15_folded_newlines_are_preserved_for_more_indented_and_blank_lines() #[test] fn test_ex2_16_indentation_determines_scope() { - let mut p = Parser::new(EX2_16.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_16).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -308,8 +292,7 @@ fn test_ex2_16_indentation_determines_scope() { #[test] fn test_ex2_17_quoted_scalars() { - let mut p = Parser::new(EX2_17.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_17).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -330,8 +313,7 @@ fn test_ex2_17_quoted_scalars() { #[test] fn test_ex2_18_multi_line_flow_scalars() { - let mut p = Parser::new(EX2_18.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_18).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -344,8 +326,7 @@ fn test_ex2_18_multi_line_flow_scalars() { #[test] fn test_ex2_23_various_explicit_tags() { - let mut p = Parser::new(EX2_23.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_23).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -360,8 +341,7 @@ fn test_ex2_23_various_explicit_tags() { #[test] fn test_ex2_24_global_tags() { - let mut p = Parser::new(EX2_24.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_24).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnMapStart); @@ -400,8 +380,7 @@ fn test_ex2_24_global_tags() { #[test] fn test_ex2_25_unordered_sets() { - let mut p = Parser::new(EX2_25.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_25).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -416,8 +395,7 @@ fn test_ex2_25_unordered_sets() { #[test] fn test_ex2_26_ordered_mappings() { - let mut p = Parser::new(EX2_26.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_26).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnMapStart); @@ -438,8 +416,7 @@ fn test_ex2_26_ordered_mappings() { #[test] fn test_ex2_27_invoice() { - let mut p = Parser::new(EX2_27.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_27).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -501,8 +478,7 @@ fn test_ex2_27_invoice() { #[test] fn test_ex2_28_log_file() { - let mut p = Parser::new(EX2_28.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX2_28).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -556,8 +532,7 @@ fn test_ex2_28_log_file() { #[test] fn test_ex5_3_block_structure_indicators() { - let mut p = Parser::new(EX5_3.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX5_3).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -578,8 +553,7 @@ fn test_ex5_3_block_structure_indicators() { #[test] fn test_ex5_4_flow_structure_indicators() { - let mut p = Parser::new(EX5_4.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX5_4).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -600,8 +574,7 @@ fn test_ex5_4_flow_structure_indicators() { #[test] fn test_ex5_6_node_property_indicators() { - let mut p = Parser::new(EX5_6.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX5_6).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -614,8 +587,7 @@ fn test_ex5_6_node_property_indicators() { #[test] fn test_ex5_7_block_scalar_indicators() { - let mut p = Parser::new(EX5_7.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX5_7).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -628,8 +600,7 @@ fn test_ex5_7_block_scalar_indicators() { #[test] fn test_ex5_8_quoted_scalar_indicators() { - let mut p = Parser::new(EX5_8.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX5_8).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -642,8 +613,7 @@ fn test_ex5_8_quoted_scalar_indicators() { #[test] fn test_ex5_11_line_break_characters() { - let mut p = Parser::new(EX5_11.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX5_11).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -651,8 +621,7 @@ fn test_ex5_11_line_break_characters() { #[test] fn test_ex5_12_tabs_and_spaces() { - let mut p = Parser::new(EX5_12.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX5_12).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -665,8 +634,7 @@ fn test_ex5_12_tabs_and_spaces() { #[test] fn test_ex5_13_escaped_characters() { - let mut p = Parser::new(EX5_13.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX5_13).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -674,8 +642,7 @@ fn test_ex5_13_escaped_characters() { #[test] fn test_ex6_1_indentation_spaces() { - let mut p = Parser::new(EX6_1.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_1).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -695,8 +662,7 @@ fn test_ex6_1_indentation_spaces() { #[test] fn test_ex6_2_indentation_indicators() { - let mut p = Parser::new(EX6_2.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_2).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -713,8 +679,7 @@ fn test_ex6_2_indentation_indicators() { #[test] fn test_ex6_3_separation_spaces() { - let mut p = Parser::new(EX6_3.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_3).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnMapStart); @@ -731,8 +696,7 @@ fn test_ex6_3_separation_spaces() { #[test] fn test_ex6_4_line_prefixes() { - let mut p = Parser::new(EX6_4.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_4).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -747,8 +711,7 @@ fn test_ex6_4_line_prefixes() { #[test] fn test_ex6_5_empty_lines() { - let mut p = Parser::new(EX6_5.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_5).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -761,8 +724,7 @@ fn test_ex6_5_empty_lines() { #[test] fn test_ex6_6_line_folding() { - let mut p = Parser::new(EX6_6.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_6).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -770,8 +732,7 @@ fn test_ex6_6_line_folding() { #[test] fn test_ex6_7_block_folding() { - let mut p = Parser::new(EX6_7.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_7).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -779,8 +740,7 @@ fn test_ex6_7_block_folding() { #[test] fn test_ex6_8_flow_folding() { - let mut p = Parser::new(EX6_8.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_8).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -788,8 +748,7 @@ fn test_ex6_8_flow_folding() { #[test] fn test_ex6_9_separated_comment() { - let mut p = Parser::new(EX6_9.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_9).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -800,8 +759,7 @@ fn test_ex6_9_separated_comment() { #[test] fn test_ex6_12_separation_spaces_ii() { - let mut p = Parser::new(EX6_12.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_12).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnMapStart); @@ -822,8 +780,7 @@ fn test_ex6_12_separation_spaces_ii() { #[test] fn test_ex6_13_reserved_directives() { - let mut p = Parser::new(EX6_13.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_13).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -831,8 +788,7 @@ fn test_ex6_13_reserved_directives() { #[test] fn test_ex6_14_yaml_directive() { - let mut p = Parser::new(EX6_14.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_14).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -840,8 +796,7 @@ fn test_ex6_14_yaml_directive() { #[test] fn test_ex6_16_tag_directive() { - let mut p = Parser::new(EX6_16.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_16).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -849,8 +804,7 @@ fn test_ex6_16_tag_directive() { #[test] fn test_ex6_18_primary_tag_handle() { - let mut p = Parser::new(EX6_18.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_18).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -861,8 +815,7 @@ fn test_ex6_18_primary_tag_handle() { #[test] fn test_ex6_19_secondary_tag_handle() { - let mut p = Parser::new(EX6_19.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_19).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -870,8 +823,7 @@ fn test_ex6_19_secondary_tag_handle() { #[test] fn test_ex6_20_tag_handles() { - let mut p = Parser::new(EX6_20.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_20).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -879,8 +831,7 @@ fn test_ex6_20_tag_handles() { #[test] fn test_ex6_21_local_tag_prefix() { - let mut p = Parser::new(EX6_21.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_21).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -891,8 +842,7 @@ fn test_ex6_21_local_tag_prefix() { #[test] fn test_ex6_22_global_tag_prefix() { - let mut p = Parser::new(EX6_22.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_22).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -902,8 +852,7 @@ fn test_ex6_22_global_tag_prefix() { #[test] fn test_ex6_23_node_properties() { - let mut p = Parser::new(EX6_23.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_23).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -916,8 +865,7 @@ fn test_ex6_23_node_properties() { #[test] fn test_ex6_24_verbatim_tags() { - let mut p = Parser::new(EX6_24.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_24).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -928,8 +876,7 @@ fn test_ex6_24_verbatim_tags() { #[test] fn test_ex6_26_tag_shorthands() { - let mut p = Parser::new(EX6_26.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_26).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -941,8 +888,7 @@ fn test_ex6_26_tag_shorthands() { #[test] fn test_ex6_28_non_specific_tags() { - let mut p = Parser::new(EX6_28.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_28).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -954,8 +900,7 @@ fn test_ex6_28_non_specific_tags() { #[test] fn test_ex6_29_node_anchors() { - let mut p = Parser::new(EX6_29.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX6_29).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -968,8 +913,7 @@ fn test_ex6_29_node_anchors() { #[test] fn test_ex7_1_alias_nodes() { - let mut p = Parser::new(EX7_1.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_1).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -986,8 +930,7 @@ fn test_ex7_1_alias_nodes() { #[test] fn test_ex7_2_empty_nodes() { - let mut p = Parser::new(EX7_2.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_2).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1000,8 +943,7 @@ fn test_ex7_2_empty_nodes() { #[test] fn test_ex7_3_completely_empty_nodes() { - let mut p = Parser::new(EX7_3.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_3).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1014,8 +956,7 @@ fn test_ex7_3_completely_empty_nodes() { #[test] fn test_ex7_4_double_quoted_implicit_keys() { - let mut p = Parser::new(EX7_4.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_4).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1031,8 +972,7 @@ fn test_ex7_4_double_quoted_implicit_keys() { #[test] fn test_ex7_5_double_quoted_line_breaks() { - let mut p = Parser::new(EX7_5.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_5).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1040,8 +980,7 @@ fn test_ex7_5_double_quoted_line_breaks() { #[test] fn test_ex7_6_double_quoted_lines() { - let mut p = Parser::new(EX7_6.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_6).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1049,8 +988,7 @@ fn test_ex7_6_double_quoted_lines() { #[test] fn test_ex7_7_single_quoted_characters() { - let mut p = Parser::new(EX7_7.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_7).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1058,8 +996,7 @@ fn test_ex7_7_single_quoted_characters() { #[test] fn test_ex7_8_single_quoted_implicit_keys() { - let mut p = Parser::new(EX7_8.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_8).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1075,8 +1012,7 @@ fn test_ex7_8_single_quoted_implicit_keys() { #[test] fn test_ex7_9_single_quoted_lines() { - let mut p = Parser::new(EX7_9.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_9).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1084,8 +1020,7 @@ fn test_ex7_9_single_quoted_lines() { #[test] fn test_ex7_10_plain_characters() { - let mut p = Parser::new(EX7_10.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_10).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -1106,8 +1041,7 @@ fn test_ex7_10_plain_characters() { #[test] fn test_ex7_11_plain_implicit_keys() { - let mut p = Parser::new(EX7_11.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_11).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1123,8 +1057,7 @@ fn test_ex7_11_plain_implicit_keys() { #[test] fn test_ex7_12_plain_lines() { - let mut p = Parser::new(EX7_12.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_12).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1132,8 +1065,7 @@ fn test_ex7_12_plain_lines() { #[test] fn test_ex7_13_flow_sequence() { - let mut p = Parser::new(EX7_13.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_13).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnSequenceStart); @@ -1150,8 +1082,7 @@ fn test_ex7_13_flow_sequence() { #[test] fn test_ex7_14_flow_sequence_entries() { - let mut p = Parser::new(EX7_14.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_14).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -1170,8 +1101,7 @@ fn test_ex7_14_flow_sequence_entries() { #[test] fn test_ex7_15_flow_mappings() { - let mut p = Parser::new(EX7_15.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_15).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnMapStart); @@ -1192,8 +1122,7 @@ fn test_ex7_15_flow_mappings() { #[test] fn test_ex7_16_flow_mapping_entries() { - let mut p = Parser::new(EX7_16.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_16).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1208,8 +1137,7 @@ fn test_ex7_16_flow_mapping_entries() { #[test] fn test_ex7_17_flow_mapping_separate_values() { - let mut p = Parser::new(EX7_17.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_17).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1226,8 +1154,7 @@ fn test_ex7_17_flow_mapping_separate_values() { #[test] fn test_ex7_18_flow_mapping_adjacent_values() { - let mut p = Parser::new(EX7_18.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_18).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1242,8 +1169,7 @@ fn test_ex7_18_flow_mapping_adjacent_values() { #[test] fn test_ex7_19_single_pair_flow_mappings() { - let mut p = Parser::new(EX7_19.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_19).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnMapStart); @@ -1256,8 +1182,7 @@ fn test_ex7_19_single_pair_flow_mappings() { #[test] fn test_ex7_20_single_pair_explicit_entry() { - let mut p = Parser::new(EX7_20.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_20).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnMapStart); @@ -1270,8 +1195,7 @@ fn test_ex7_20_single_pair_explicit_entry() { #[test] fn test_ex7_21_single_pair_implicit_entries() { - let mut p = Parser::new(EX7_21.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_21).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnSequenceStart); @@ -1301,8 +1225,7 @@ fn test_ex7_21_single_pair_implicit_entries() { #[test] fn test_ex7_23_flow_content() { - let mut p = Parser::new(EX7_23.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_23).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnSequenceStart); @@ -1322,8 +1245,7 @@ fn test_ex7_23_flow_content() { #[test] fn test_ex7_24_flow_nodes() { - let mut p = Parser::new(EX7_24.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX7_24).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -1337,8 +1259,7 @@ fn test_ex7_24_flow_nodes() { #[test] fn test_ex8_1_block_scalar_header() { - let mut p = Parser::new(EX8_1.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_1).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -1351,8 +1272,7 @@ fn test_ex8_1_block_scalar_header() { #[test] fn test_ex8_2_block_indentation_header() { - let mut p = Parser::new(EX8_2.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_2).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -1365,8 +1285,7 @@ fn test_ex8_2_block_indentation_header() { #[test] fn test_ex8_4_chomping_final_line_break() { - let mut p = Parser::new(EX8_4.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_4).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1381,8 +1300,7 @@ fn test_ex8_4_chomping_final_line_break() { #[test] fn test_ex8_6_empty_scalar_chomping() { - let mut p = Parser::new(EX8_6.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_6).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1397,8 +1315,7 @@ fn test_ex8_6_empty_scalar_chomping() { #[test] fn test_ex8_7_literal_scalar() { - let mut p = Parser::new(EX8_7.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_7).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1406,8 +1323,7 @@ fn test_ex8_7_literal_scalar() { #[test] fn test_ex8_8_literal_content() { - let mut p = Parser::new(EX8_8.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_8).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1415,8 +1331,7 @@ fn test_ex8_8_literal_content() { #[test] fn test_ex8_9_folded_scalar() { - let mut p = Parser::new(EX8_9.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_9).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1424,8 +1339,7 @@ fn test_ex8_9_folded_scalar() { #[test] fn test_ex8_10_folded_lines() { - let mut p = Parser::new(EX8_10.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_10).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1433,8 +1347,7 @@ fn test_ex8_10_folded_lines() { #[test] fn test_ex8_11_more_indented_lines() { - let mut p = Parser::new(EX8_11.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_11).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1442,8 +1355,7 @@ fn test_ex8_11_more_indented_lines() { #[test] fn test_ex8_12_empty_separation_lines() { - let mut p = Parser::new(EX8_12.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_12).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1451,8 +1363,7 @@ fn test_ex8_12_empty_separation_lines() { #[test] fn test_ex8_13_final_empty_lines() { - let mut p = Parser::new(EX8_13.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_13).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnScalar); assert_next!(v, TestEvent::OnDocumentEnd); @@ -1460,8 +1371,7 @@ fn test_ex8_13_final_empty_lines() { #[test] fn test_ex8_14_block_sequence() { - let mut p = Parser::new(EX8_14.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_14).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1478,8 +1388,7 @@ fn test_ex8_14_block_sequence() { #[test] fn test_ex8_15_block_sequence_entry_types() { - let mut p = Parser::new(EX8_15.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_15).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnNull); @@ -1498,8 +1407,7 @@ fn test_ex8_15_block_sequence_entry_types() { #[test] fn test_ex8_16_block_mappings() { - let mut p = Parser::new(EX8_16.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_16).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1513,8 +1421,7 @@ fn test_ex8_16_block_mappings() { #[test] fn test_ex8_17_explicit_block_mapping_entries() { - let mut p = Parser::new(EX8_17.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_17).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1530,8 +1437,7 @@ fn test_ex8_17_explicit_block_mapping_entries() { #[test] fn test_ex8_18_implicit_block_mapping_entries() { - let mut p = Parser::new(EX8_18.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_18).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar); @@ -1548,8 +1454,7 @@ fn test_ex8_18_implicit_block_mapping_entries() { #[test] fn test_ex8_19_compact_block_mappings() { - let mut p = Parser::new(EX8_19.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_19).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnMapStart); @@ -1572,8 +1477,7 @@ fn test_ex8_19_compact_block_mappings() { #[test] fn test_ex8_20_block_node_types() { - let mut p = Parser::new(EX8_20.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_20).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnSequenceStart); assert_next!(v, TestEvent::OnScalar); @@ -1588,8 +1492,7 @@ fn test_ex8_20_block_node_types() { #[test] fn test_ex8_22_block_collection_nodes() { - let mut p = Parser::new(EX8_22.chars()); - let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter(); + let mut v = str_to_test_events(EX8_22).into_iter(); assert_next!(v, TestEvent::OnDocumentStart); assert_next!(v, TestEvent::OnMapStart); assert_next!(v, TestEvent::OnScalar);