Refactory YAML document loader

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<T: Iterator<Item=char>> Parser<T> {
         self.states.push(state);
     }
 
-    pub fn parse(&mut self) -> ParseResult {
+    fn parse<R: EventReceiver>(&mut self, recv: &mut R)
+        -> ParseResult {
         if self.scanner.stream_ended()
             || self.state == State::End {
             return Ok(Event::StreamEnd);
         }
-        let ev = self.state_machine();
+        let ev = try!(self.state_machine());
-        println!("EV {:?}", ev);
+        // println!("EV {:?}", ev);
-        ev
+        recv.on_event(&ev);
+        Ok(ev)
     }
 
-    pub fn load(&mut self) -> Result<Yaml, ScanError> {
+    pub fn load<R: EventReceiver>(&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<Vec<Yaml>, 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<Yaml> = 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<Yaml, ScanError> {
+    fn load_document<R: EventReceiver>(&mut self, first_ev: &Event, recv: &mut R)
+        -> Result<(), ScanError> {
         assert_eq!(first_ev, &Event::DocumentStart);
 
-        let ev = try!(self.parse());
+        let ev = try!(self.parse(recv));
-        let doc = try!(self.load_node(&ev));
+        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<Yaml, ScanError> {
+    fn load_node<R: EventReceiver>(&mut self, first_ev: &Event, recv: &mut R)
+        -> Result<(), ScanError> {
         match *first_ev {
             Event::Scalar(ref v, style) => {
-                // TODO scalar
+                Ok(())
-                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::<f64>().is_ok() => Ok(Yaml::Number(v.clone())),
-                        _ => Ok(Yaml::String(v.clone()))
-                    }
-                }
             },
             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<Yaml, ScanError> {
+    fn load_mapping<R: EventReceiver>(&mut self, first_ev: &Event, recv: &mut R)
-        let mut ev = try!(self.parse());
+        -> Result<(), ScanError> {
-        let mut map = Hash::new();
+        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());
+            ev = try!(self.parse(recv));
-            let value = try!(self.load_node(&ev));
+            try!(self.load_node(&ev, recv));
-
-            map.insert(key, value);
 
             // 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<Yaml, ScanError> {
+    fn load_sequence<R: EventReceiver>(&mut self, first_ev: &Event, recv: &mut R)
-        let mut ev = try!(self.parse());
+        -> Result<(), ScanError> {
-        let mut vec = Vec::new();
+        let mut ev = try!(self.parse(recv));
         while ev != Event::SequenceEnd {
-            let entry = try!(self.load_node(&ev));
+            let entry = try!(self.load_node(&ev, recv));
-            vec.push(entry);
 
             // 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<T: Iterator<Item=char>> Parser<T> {
 #[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);
-
-    }
 }
 

saphyr/src/scanner.rs

@@ -620,7 +620,6 @@ impl<T: Iterator<Item=char>> Scanner<T> {
         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<T: Iterator<Item=char>> Scanner<T> {
             leading_blank = is_blank(self.ch());
 
             while !is_breakz(self.ch()) {
-                println!("---->  {:?}", self.ch());
                 string.push(self.ch());
                 self.skip();
                 self.lookahead(1);

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<Yaml>;
 pub type Hash = BTreeMap<Yaml, Yaml>;
 
+pub struct YamlLoader {
+    docs: Vec<Yaml>,
+    // states
+    doc_stack: Vec<Yaml>,
+    key_stack: Vec<Yaml>,
+}
+
+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::<f64>().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<Vec<Yaml>, 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<usize> 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 = YamlLoader::load_from_str(&s).unwrap();
-        let out = parser.load().unwrap();
+        let doc = &out[0];
-        assert_eq!(out["a"].as_number::<i32>().unwrap(), 1);
+        assert_eq!(doc["a"].as_number::<i32>().unwrap(), 1);
-        assert_eq!(out["b"].as_number::<f32>().unwrap(), 2.2f32);
+        assert_eq!(doc["b"].as_number::<f32>().unwrap(), 2.2f32);
-        assert_eq!(out["c"][1].as_number::<i32>().unwrap(), 2);
+        assert_eq!(doc["c"][1].as_number::<i32>().unwrap(), 2);
-        assert!(out["d"][0].is_badvalue());
+        assert!(doc["d"][0].is_badvalue());
-        //assert_eq!(out.as_hash().unwrap()[&Yaml::String("a".to_string())].as_i64().unwrap(), 1i64);
     }
+
+    #[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);
+    }
+
 }
 

saphyr/tests/spec_test.rs

@@ -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<Yaml>) -> Vec<TestEvent> {
-    println!("DOCS {:?}", docs);
-    fn next(root: &Yaml, evs: &mut Vec<TestEvent>) {
-        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<TestEvent> = 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");
-

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 = str_to_test_events(EX2_1).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_2).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_3).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_4).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_5).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_6).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_7).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_8).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_9).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_10).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_11).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_12).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_13).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_14).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_15).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_16).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_17).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_18).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_23).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_24).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_25).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_26).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_27).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX2_28).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX5_3).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX5_4).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX5_6).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX5_7).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX5_8).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX5_11).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX5_12).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX5_13).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_1).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_2).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_3).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_4).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_5).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_6).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_7).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_8).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_9).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_12).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_13).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_14).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_16).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_18).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_19).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_20).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_21).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_22).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_23).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_24).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_26).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_28).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX6_29).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_1).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_2).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_3).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_4).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_5).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_6).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_7).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_8).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_9).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_10).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_11).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_12).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_13).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_14).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_15).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_16).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_17).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_18).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_19).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_20).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_21).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_23).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX7_24).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_1).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_2).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_4).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_6).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_7).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_8).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_9).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_10).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_11).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_12).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_13).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_14).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_15).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_16).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_17).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_18).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_19).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_20).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).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 = str_to_test_events(EX8_22).into_iter();
-    let mut v = yaml_to_test_events(&p.load_multidoc().unwrap()).into_iter();
     assert_next!(v, TestEvent::OnDocumentStart);
     assert_next!(v, TestEvent::OnMapStart);
     assert_next!(v, TestEvent::OnScalar);