Reverted yaml-reader name change

CMakeLists.txt

@@ -67,6 +67,6 @@ if(UNIX)
 endif(UNIX)
 
 if(YAML_CPP_BUILD_TOOLS)
-	add_subdirectory (test)
+	add_subdirectory (yaml-reader)
 	add_subdirectory (util)
 endif(YAML_CPP_BUILD_TOOLS)

yaml-reader/CMakeLists.txt

@@ -0,0 +1,10 @@
+file(GLOB yaml-reader_headers [a-z]*.h)
+file(GLOB yaml-reader_sources [a-z]*.cpp)
+
+add_executable(yaml-reader
+	${yaml-reader_sources}
+	${yaml-reader_headers}
+)
+target_link_libraries(yaml-reader yaml-cpp)
+
+add_test(yaml-reader-test yaml-reader)

yaml-reader/emittertests.cpp

@@ -0,0 +1,650 @@
+#include "tests.h"
+#include "yaml.h"
+
+namespace Test
+{
+	namespace Emitter {
+		////////////////////////////////////////////////////////////////////////////////////////////////////////
+		// correct emitting
+
+		void SimpleScalar(YAML::Emitter& out, std::string& desiredOutput) {
+			out << "Hello, World!";
+			desiredOutput = "Hello, World!";
+		}
+		
+		void SimpleSeq(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginSeq;
+			out << "eggs";
+			out << "bread";
+			out << "milk";
+			out << YAML::EndSeq;
+
+			desiredOutput = "- eggs\n- bread\n- milk";
+		}
+		
+		void SimpleFlowSeq(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::Flow;
+			out << YAML::BeginSeq;
+			out << "Larry";
+			out << "Curly";
+			out << "Moe";
+			out << YAML::EndSeq;
+			
+			desiredOutput = "[Larry, Curly, Moe]";
+		}
+		
+		void EmptyFlowSeq(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::Flow;
+			out << YAML::BeginSeq;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "[]";
+		}
+		
+		void NestedBlockSeq(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginSeq;
+			out << "item 1";
+			out << YAML::BeginSeq << "subitem 1" << "subitem 2" << YAML::EndSeq;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- item 1\n-\n  - subitem 1\n  - subitem 2";
+		}
+		
+		void NestedFlowSeq(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginSeq;
+			out << "one";
+			out << YAML::Flow << YAML::BeginSeq << "two" << "three" << YAML::EndSeq;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- one\n- [two, three]";
+		}
+
+		void SimpleMap(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginMap;
+			out << YAML::Key << "name";
+			out << YAML::Value << "Ryan Braun";
+			out << YAML::Key << "position";
+			out << YAML::Value << "3B";
+			out << YAML::EndMap;
+
+			desiredOutput = "name: Ryan Braun\nposition: 3B";
+		}
+		
+		void SimpleFlowMap(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::Flow;
+			out << YAML::BeginMap;
+			out << YAML::Key << "shape";
+			out << YAML::Value << "square";
+			out << YAML::Key << "color";
+			out << YAML::Value << "blue";
+			out << YAML::EndMap;
+			
+			desiredOutput = "{shape: square, color: blue}";
+		}
+		
+		void MapAndList(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginMap;
+			out << YAML::Key << "name";
+			out << YAML::Value << "Barack Obama";
+			out << YAML::Key << "children";
+			out << YAML::Value << YAML::BeginSeq << "Sasha" << "Malia" << YAML::EndSeq;
+			out << YAML::EndMap;
+
+			desiredOutput = "name: Barack Obama\nchildren:\n  - Sasha\n  - Malia";
+		}
+		
+		void ListAndMap(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginSeq;
+			out << "item 1";
+			out << YAML::BeginMap;
+			out << YAML::Key << "pens" << YAML::Value << 8;
+			out << YAML::Key << "pencils" << YAML::Value << 14;
+			out << YAML::EndMap;
+			out << "item 2";
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- item 1\n-\n  pens: 8\n  pencils: 14\n- item 2";
+		}
+
+		void NestedBlockMap(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginMap;
+			out << YAML::Key << "name";
+			out << YAML::Value << "Fred";
+			out << YAML::Key << "grades";
+			out << YAML::Value;
+			out << YAML::BeginMap;
+			out << YAML::Key << "algebra" << YAML::Value << "A";
+			out << YAML::Key << "physics" << YAML::Value << "C+";
+			out << YAML::Key << "literature" << YAML::Value << "B";
+			out << YAML::EndMap;
+			out << YAML::EndMap;
+			
+			desiredOutput = "name: Fred\ngrades:\n  algebra: A\n  physics: C+\n  literature: B";
+		}
+
+		void NestedFlowMap(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::Flow;
+			out << YAML::BeginMap;
+			out << YAML::Key << "name";
+			out << YAML::Value << "Fred";
+			out << YAML::Key << "grades";
+			out << YAML::Value;
+			out << YAML::BeginMap;
+			out << YAML::Key << "algebra" << YAML::Value << "A";
+			out << YAML::Key << "physics" << YAML::Value << "C+";
+			out << YAML::Key << "literature" << YAML::Value << "B";
+			out << YAML::EndMap;
+			out << YAML::EndMap;
+			
+			desiredOutput = "{name: Fred, grades: {algebra: A, physics: C+, literature: B}}";
+		}
+		
+		void MapListMix(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginMap;
+			out << YAML::Key << "name";
+			out << YAML::Value << "Bob";
+			out << YAML::Key << "position";
+			out << YAML::Value;
+			out << YAML::Flow << YAML::BeginSeq << 2 << 4 << YAML::EndSeq;
+			out << YAML::Key << "invincible" << YAML::Value << YAML::OnOffBool << false;
+			out << YAML::EndMap;
+			
+			desiredOutput = "name: Bob\nposition: [2, 4]\ninvincible: off";
+		}
+
+		void SimpleLongKey(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::LongKey;
+			out << YAML::BeginMap;
+			out << YAML::Key << "height";
+			out << YAML::Value << "5'9\"";
+			out << YAML::Key << "weight";
+			out << YAML::Value << 145;
+			out << YAML::EndMap;
+			
+			desiredOutput = "? height\n: 5'9\"\n? weight\n: 145";
+		}
+		
+		void SingleLongKey(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key << "age";
+			out << YAML::Value << "24";
+			out << YAML::LongKey << YAML::Key << "height";
+			out << YAML::Value << "5'9\"";
+			out << YAML::Key << "weight";
+			out << YAML::Value << 145;
+			out << YAML::EndMap;
+			
+			desiredOutput = "age: 24\n? height\n: 5'9\"\nweight: 145";
+		}
+		
+		void ComplexLongKey(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::LongKey;
+			out << YAML::BeginMap;
+			out << YAML::Key << YAML::BeginSeq << 1 << 3 << YAML::EndSeq;
+			out << YAML::Value << "monster";
+			out << YAML::Key << YAML::Flow << YAML::BeginSeq << 2 << 0 << YAML::EndSeq;
+			out << YAML::Value << "demon";
+			out << YAML::EndMap;
+			
+			desiredOutput = "?\n  - 1\n  - 3\n: monster\n? [2, 0]\n: demon";
+		}
+
+		void AutoLongKey(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key << YAML::BeginSeq << 1 << 3 << YAML::EndSeq;
+			out << YAML::Value << "monster";
+			out << YAML::Key << YAML::Flow << YAML::BeginSeq << 2 << 0 << YAML::EndSeq;
+			out << YAML::Value << "demon";
+			out << YAML::Key << "the origin";
+			out << YAML::Value << "angel";
+			out << YAML::EndMap;
+			
+			desiredOutput = "?\n  - 1\n  - 3\n: monster\n? [2, 0]\n: demon\nthe origin: angel";
+		}
+		
+		void ScalarFormat(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << "simple scalar";
+			out << YAML::SingleQuoted << "explicit single-quoted scalar";
+			out << YAML::DoubleQuoted << "explicit double-quoted scalar";
+			out << "auto-detected\ndouble-quoted scalar";
+			out << "a non-\"auto-detected\" double-quoted scalar";
+			out << YAML::Literal << "literal scalar\nthat may span\nmany, many\nlines and have \"whatever\" crazy\tsymbols that we like";
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- simple scalar\n- 'explicit single-quoted scalar'\n- \"explicit double-quoted scalar\"\n- \"auto-detected\\x0adouble-quoted scalar\"\n- a non-\"auto-detected\" double-quoted scalar\n- |\n  literal scalar\n  that may span\n  many, many\n  lines and have \"whatever\" crazy\tsymbols that we like";
+		}
+
+		void AutoLongKeyScalar(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key << YAML::Literal << "multi-line\nscalar";
+			out << YAML::Value << "and its value";
+			out << YAML::EndMap;
+			
+			desiredOutput = "? |\n  multi-line\n  scalar\n: and its value";
+		}
+		
+		void LongKeyFlowMap(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::Flow;
+			out << YAML::BeginMap;
+			out << YAML::Key << "simple key";
+			out << YAML::Value << "and value";
+			out << YAML::LongKey << YAML::Key << "long key";
+			out << YAML::Value << "and its value";
+			out << YAML::EndMap;
+			
+			desiredOutput = "{simple key: and value, ? long key: and its value}";
+		}
+
+		void BlockMapAsKey(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key;
+			out << YAML::BeginMap;
+			out << YAML::Key << "key" << YAML::Value << "value";
+			out << YAML::Key << "next key" << YAML::Value << "next value";
+			out << YAML::EndMap;
+			out << YAML::Value;
+			out << "total value";
+			out << YAML::EndMap;
+			
+			desiredOutput = "?\n  key: value\n  next key: next value\n: total value";
+		}
+		
+		void AliasAndAnchor(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << YAML::Anchor("fred");
+			out << YAML::BeginMap;
+			out << YAML::Key << "name" << YAML::Value << "Fred";
+			out << YAML::Key << "age" << YAML::Value << 42;
+			out << YAML::EndMap;
+			out << YAML::Alias("fred");
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- &fred\n  name: Fred\n  age: 42\n- *fred";
+		}
+
+		void AliasAndAnchorWithNull(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << YAML::Anchor("fred") << YAML::Null;
+			out << YAML::Alias("fred");
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- &fred ~\n- *fred";
+		}
+
+		void ComplexDoc(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key << "receipt";
+			out << YAML::Value << "Oz-Ware Purchase Invoice";
+			out << YAML::Key << "date";
+			out << YAML::Value << "2007-08-06";
+			out << YAML::Key << "customer";
+			out << YAML::Value;
+			out << YAML::BeginMap;
+			out << YAML::Key << "given";
+			out << YAML::Value << "Dorothy";
+			out << YAML::Key << "family";
+			out << YAML::Value << "Gale";
+			out << YAML::EndMap;
+			out << YAML::Key << "items";
+			out << YAML::Value;
+			out << YAML::BeginSeq;
+			out << YAML::BeginMap;
+			out << YAML::Key << "part_no";
+			out << YAML::Value << "A4786";
+			out << YAML::Key << "descrip";
+			out << YAML::Value << "Water Bucket (Filled)";
+			out << YAML::Key << "price";
+			out << YAML::Value << 1.47;
+			out << YAML::Key << "quantity";
+			out << YAML::Value << 4;
+			out << YAML::EndMap;
+			out << YAML::BeginMap;
+			out << YAML::Key << "part_no";
+			out << YAML::Value << "E1628";
+			out << YAML::Key << "descrip";
+			out << YAML::Value << "High Heeled \"Ruby\" Slippers";
+			out << YAML::Key << "price";
+			out << YAML::Value << 100.27;
+			out << YAML::Key << "quantity";
+			out << YAML::Value << 1;
+			out << YAML::EndMap;
+			out << YAML::EndSeq;
+			out << YAML::Key << "bill-to";
+			out << YAML::Value << YAML::Anchor("id001");
+			out << YAML::BeginMap;
+			out << YAML::Key << "street";
+			out << YAML::Value << YAML::Literal << "123 Tornado Alley\nSuite 16";
+			out << YAML::Key << "city";
+			out << YAML::Value << "East Westville";
+			out << YAML::Key << "state";
+			out << YAML::Value << "KS";
+			out << YAML::EndMap;
+			out << YAML::Key << "ship-to";
+			out << YAML::Value << YAML::Alias("id001");
+			out << YAML::EndMap;
+			
+			desiredOutput = "receipt: Oz-Ware Purchase Invoice\ndate: 2007-08-06\ncustomer:\n  given: Dorothy\n  family: Gale\nitems:\n  -\n    part_no: A4786\n    descrip: Water Bucket (Filled)\n    price: 1.47\n    quantity: 4\n  -\n    part_no: E1628\n    descrip: High Heeled \"Ruby\" Slippers\n    price: 100.27\n    quantity: 1\nbill-to: &id001\n  street: |\n    123 Tornado Alley\n    Suite 16\n  city: East Westville\n  state: KS\nship-to: *id001";
+		}
+
+		void STLContainers(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			std::vector <int> primes;
+			primes.push_back(2);
+			primes.push_back(3);
+			primes.push_back(5);
+			primes.push_back(7);
+			primes.push_back(11);
+			primes.push_back(13);
+			out << YAML::Flow << primes;
+			std::map <std::string, int> ages;
+			ages["Daniel"] = 26;
+			ages["Jesse"] = 24;
+			out << ages;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- [2, 3, 5, 7, 11, 13]\n-\n  Daniel: 26\n  Jesse: 24";
+		}
+
+		void SimpleComment(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key << "method";
+			out << YAML::Value << "least squares" << YAML::Comment("should we change this method?");
+			out << YAML::EndMap;
+			
+			desiredOutput = "method: least squares  # should we change this method?";
+		}
+
+		void MultiLineComment(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << "item 1" << YAML::Comment("really really long\ncomment that couldn't possibly\nfit on one line");
+			out << "item 2";
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- item 1  # really really long\n          # comment that couldn't possibly\n          # fit on one line\n- item 2";
+		}
+
+		void ComplexComments(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::LongKey << YAML::Key << "long key" << YAML::Comment("long key");
+			out << YAML::Value << "value";
+			out << YAML::EndMap;
+			
+			desiredOutput = "? long key  # long key\n: value";
+		}
+
+		void Indentation(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::Indent(4);
+			out << YAML::BeginSeq;
+			out << YAML::BeginMap;
+			out << YAML::Key << "key 1" << YAML::Value << "value 1";
+			out << YAML::Key << "key 2" << YAML::Value << YAML::BeginSeq << "a" << "b" << "c" << YAML::EndSeq;
+			out << YAML::EndMap;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "-\n    key 1: value 1\n    key 2:\n        - a\n        - b\n        - c";
+		}
+
+		void SimpleGlobalSettings(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out.SetIndent(4);
+			out.SetMapFormat(YAML::LongKey);
+
+			out << YAML::BeginSeq;
+			out << YAML::BeginMap;
+			out << YAML::Key << "key 1" << YAML::Value << "value 1";
+			out << YAML::Key << "key 2" << YAML::Value << YAML::Flow << YAML::BeginSeq << "a" << "b" << "c" << YAML::EndSeq;
+			out << YAML::EndMap;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "-\n    ? key 1\n    : value 1\n    ? key 2\n    : [a, b, c]";
+		}
+		
+		void ComplexGlobalSettings(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << YAML::Block;
+			out << YAML::BeginMap;
+			out << YAML::Key << "key 1" << YAML::Value << "value 1";
+			out << YAML::Key << "key 2" << YAML::Value;
+			out.SetSeqFormat(YAML::Flow);
+			out << YAML::BeginSeq << "a" << "b" << "c" << YAML::EndSeq;
+			out << YAML::EndMap;
+			out << YAML::BeginMap;
+			out << YAML::Key << YAML::BeginSeq << 1 << 2 << YAML::EndSeq;
+			out << YAML::Value << YAML::BeginMap << YAML::Key << "a" << YAML::Value << "b" << YAML::EndMap;
+			out << YAML::EndMap;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "-\n  key 1: value 1\n  key 2: [a, b, c]\n-\n  ? [1, 2]\n  :\n    a: b";
+		}
+
+		void Null(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << YAML::Null;
+			out << YAML::BeginMap;
+			out << YAML::Key << "null value" << YAML::Value << YAML::Null;
+			out << YAML::Key << YAML::Null << YAML::Value << "null key";
+			out << YAML::EndMap;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- ~\n-\n  null value: ~\n  ~: null key";
+		}
+		
+		void EscapedUnicode(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::EscapeNonAscii << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
+			
+			desiredOutput = "\"$ \\xa2 \\u20ac \\U00024b62\"";
+		}
+		
+		void Unicode(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
+			desiredOutput = "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
+		}
+		
+		void DoubleQuotedUnicode(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::DoubleQuoted << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
+			desiredOutput = "\"\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2\"";
+		}
+		
+
+		////////////////////////////////////////////////////////////////////////////////////////////////////////
+		// incorrect emitting
+		
+		void ExtraEndSeq(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::UNEXPECTED_END_SEQ;
+
+			out << YAML::BeginSeq;
+			out << "Hello";
+			out << "World";
+			out << YAML::EndSeq;
+			out << YAML::EndSeq;
+		}
+
+		void ExtraEndMap(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::UNEXPECTED_END_MAP;
+			
+			out << YAML::BeginMap;
+			out << YAML::Key << "Hello" << YAML::Value << "World";
+			out << YAML::EndMap;
+			out << YAML::EndMap;
+		}
+
+		void BadSingleQuoted(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::SINGLE_QUOTED_CHAR;
+			
+			out << YAML::SingleQuoted << "Hello\nWorld";
+		}
+
+		void InvalidAnchor(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::INVALID_ANCHOR;
+			
+			out << YAML::BeginSeq;
+			out << YAML::Anchor("new\nline") << "Test";
+			out << YAML::EndSeq;
+		}
+		
+		void InvalidAlias(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::INVALID_ALIAS;
+			
+			out << YAML::BeginSeq;
+			out << YAML::Alias("new\nline");
+			out << YAML::EndSeq;
+		}
+
+		void MissingKey(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::EXPECTED_KEY_TOKEN;
+			
+			out << YAML::BeginMap;
+			out << YAML::Key << "key" << YAML::Value << "value";
+			out << "missing key" << YAML::Value << "value";
+			out << YAML::EndMap;
+		}
+		
+		void MissingValue(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::EXPECTED_VALUE_TOKEN;
+			
+			out << YAML::BeginMap;
+			out << YAML::Key << "key" << "value";
+			out << YAML::EndMap;
+		}
+
+		void UnexpectedKey(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::UNEXPECTED_KEY_TOKEN;
+			
+			out << YAML::BeginSeq;
+			out << YAML::Key << "hi";
+			out << YAML::EndSeq;
+		}
+		
+		void UnexpectedValue(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::UNEXPECTED_VALUE_TOKEN;
+			
+			out << YAML::BeginSeq;
+			out << YAML::Value << "hi";
+			out << YAML::EndSeq;
+		}
+	}
+	
+	namespace {
+		void RunEmitterTest(void (*test)(YAML::Emitter&, std::string&), const std::string& name, int& passed, int& total) {
+			YAML::Emitter out;
+			std::string desiredOutput;
+			test(out, desiredOutput);
+			std::string output = out.c_str();
+
+			if(output == desiredOutput) {
+				passed++;
+			} else {
+				std::cout << "Emitter test failed: " << name << "\n";
+				std::cout << "Output:\n";
+				std::cout << output << "<<<\n";
+				std::cout << "Desired output:\n";
+				std::cout << desiredOutput << "<<<\n";				
+			}
+			total++;
+		}
+		
+		void RunEmitterErrorTest(void (*test)(YAML::Emitter&, std::string&), const std::string& name, int& passed, int& total) {
+			YAML::Emitter out;
+			std::string desiredError;
+			test(out, desiredError);
+			std::string lastError = out.GetLastError();
+			if(!out.good() && lastError == desiredError) {
+				passed++;
+			} else {
+				std::cout << "Emitter test failed: " << name << "\n";
+				if(out.good())
+					std::cout << "No error detected\n";
+				else
+					std::cout << "Detected error: " << lastError << "\n";
+				std::cout << "Expected error: " << desiredError << "\n";
+			}
+			total++;
+		}
+	}
+	
+	bool RunEmitterTests()
+	{
+		int passed = 0;
+		int total = 0;
+		RunEmitterTest(&Emitter::SimpleScalar, "simple scalar", passed, total);
+		RunEmitterTest(&Emitter::SimpleSeq, "simple seq", passed, total);
+		RunEmitterTest(&Emitter::SimpleFlowSeq, "simple flow seq", passed, total);
+		RunEmitterTest(&Emitter::EmptyFlowSeq, "empty flow seq", passed, total);
+		RunEmitterTest(&Emitter::NestedBlockSeq, "nested block seq", passed, total);
+		RunEmitterTest(&Emitter::NestedFlowSeq, "nested flow seq", passed, total);
+		RunEmitterTest(&Emitter::SimpleMap, "simple map", passed, total);
+		RunEmitterTest(&Emitter::SimpleFlowMap, "simple flow map", passed, total);
+		RunEmitterTest(&Emitter::MapAndList, "map and list", passed, total);
+		RunEmitterTest(&Emitter::ListAndMap, "list and map", passed, total);
+		RunEmitterTest(&Emitter::NestedBlockMap, "nested block map", passed, total);
+		RunEmitterTest(&Emitter::NestedFlowMap, "nested flow map", passed, total);
+		RunEmitterTest(&Emitter::MapListMix, "map list mix", passed, total);
+		RunEmitterTest(&Emitter::SimpleLongKey, "simple long key", passed, total);
+		RunEmitterTest(&Emitter::SingleLongKey, "single long key", passed, total);
+		RunEmitterTest(&Emitter::ComplexLongKey, "complex long key", passed, total);
+		RunEmitterTest(&Emitter::AutoLongKey, "auto long key", passed, total);
+		RunEmitterTest(&Emitter::ScalarFormat, "scalar format", passed, total);
+		RunEmitterTest(&Emitter::AutoLongKeyScalar, "auto long key scalar", passed, total);
+		RunEmitterTest(&Emitter::LongKeyFlowMap, "long key flow map", passed, total);
+		RunEmitterTest(&Emitter::BlockMapAsKey, "block map as key", passed, total);
+		RunEmitterTest(&Emitter::AliasAndAnchor, "alias and anchor", passed, total);
+		RunEmitterTest(&Emitter::AliasAndAnchorWithNull, "alias and anchor with null", passed, total);
+		RunEmitterTest(&Emitter::ComplexDoc, "complex doc", passed, total);
+		RunEmitterTest(&Emitter::STLContainers, "STL containers", passed, total);
+		RunEmitterTest(&Emitter::SimpleComment, "simple comment", passed, total);
+		RunEmitterTest(&Emitter::MultiLineComment, "multi-line comment", passed, total);
+		RunEmitterTest(&Emitter::ComplexComments, "complex comments", passed, total);
+		RunEmitterTest(&Emitter::Indentation, "indentation", passed, total);
+		RunEmitterTest(&Emitter::SimpleGlobalSettings, "simple global settings", passed, total);
+		RunEmitterTest(&Emitter::ComplexGlobalSettings, "complex global settings", passed, total);
+		RunEmitterTest(&Emitter::Null, "null", passed, total);
+		RunEmitterTest(&Emitter::EscapedUnicode, "escaped unicode", passed, total);
+		RunEmitterTest(&Emitter::Unicode, "unicode", passed, total);
+		RunEmitterTest(&Emitter::DoubleQuotedUnicode, "double quoted unicode", passed, total);
+		
+		RunEmitterErrorTest(&Emitter::ExtraEndSeq, "extra EndSeq", passed, total);
+		RunEmitterErrorTest(&Emitter::ExtraEndMap, "extra EndMap", passed, total);
+		RunEmitterErrorTest(&Emitter::BadSingleQuoted, "bad single quoted string", passed, total);
+		RunEmitterErrorTest(&Emitter::InvalidAnchor, "invalid anchor", passed, total);
+		RunEmitterErrorTest(&Emitter::InvalidAlias, "invalid alias", passed, total);
+		RunEmitterErrorTest(&Emitter::MissingKey, "missing key", passed, total);
+		RunEmitterErrorTest(&Emitter::MissingValue, "missing value", passed, total);
+		RunEmitterErrorTest(&Emitter::UnexpectedKey, "unexpected key", passed, total);
+		RunEmitterErrorTest(&Emitter::UnexpectedValue, "unexpected value", passed, total);
+
+		std::cout << "Emitter tests: " << passed << "/" << total << " passed\n";
+		return passed == total;
+	}
+}
+

yaml-reader/emittertests.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#ifndef EMITTERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+namespace Test {
+	bool RunEmitterTests();
+}
+
+#endif // EMITTERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+

yaml-reader/main.cpp

@@ -0,0 +1,11 @@
+#include "tests.h"
+
+int main()
+{
+#ifdef WINDOWS
+	_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF);
+#endif // WINDOWS
+	Test::RunAll();
+
+	return 0;
+}

yaml-reader/parsertests.cpp

@@ -0,0 +1,888 @@
+#include "tests.h"
+#include "yaml.h"
+#include <sstream>
+#include <algorithm>
+
+namespace Test
+{
+	namespace Parser {
+		void SimpleScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "Hello, World!";
+			desiredOutput = "Hello, World!";
+		}
+
+		void MultiLineScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				"normal scalar, but\n"
+				"over several lines";
+			desiredOutput = "normal scalar, but over several lines";
+		}
+
+		void LiteralScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				"|\n"
+				" literal scalar - so we can draw ASCII:\n"
+				" \n"
+                "          -   -\n"
+                "         |  -  |\n"
+                "          -----\n";
+			desiredOutput =
+				"literal scalar - so we can draw ASCII:\n"
+				"\n"
+                "         -   -\n"
+                "        |  -  |\n"
+                "         -----\n";
+		}
+
+		void FoldedScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				">\n"
+				" and a folded scalar... so we\n"
+				" can just keep writing various\n"
+				" things. And if we want to keep indentation:\n"
+				" \n"
+				"    we just indent a little\n"
+				"    see, this stays indented";
+			desiredOutput =
+				"and a folded scalar... so we"
+				" can just keep writing various"
+				" things. And if we want to keep indentation:\n"
+				"\n"
+				"   we just indent a little\n"
+				"   see, this stays indented";
+		}
+
+		void ChompedFoldedScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				">-\n"
+				"  Here's a folded scalar\n"
+				"  that gets chomped.";
+			desiredOutput =
+				"Here's a folded scalar"
+				" that gets chomped.";
+		}
+
+		void ChompedLiteralScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				"|-\n"
+				"  Here's a literal scalar\n"
+				"  that gets chomped.";
+			desiredOutput =
+				"Here's a literal scalar\n"
+				"that gets chomped.";
+		}
+
+		void FoldedScalarWithIndent(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				">2\n"
+				"       Here's a folded scalar\n"
+				"  that starts with some indentation.";
+			desiredOutput =
+				"     Here's a folded scalar\n"
+				"that starts with some indentation.";
+		}
+
+		void ColonScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "::vector";
+			desiredOutput = "::vector";
+		}
+
+		void QuotedScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "\": - ()\"";
+			desiredOutput = ": - ()";
+		}
+
+		void CommaScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "Up, up, and away!";
+			desiredOutput = "Up, up, and away!";
+		}
+
+		void DashScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "-123";
+			desiredOutput = "-123";
+		}
+
+		void URLScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "http://example.com/foo#bar";
+			desiredOutput = "http://example.com/foo#bar";
+		}
+
+		bool SimpleSeq()
+		{
+			std::string input =
+				"- eggs\n"
+				"- bread\n"
+				"- milk";
+
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc[0] >> output;
+			if(output != "eggs")
+				return false;
+			doc[1] >> output;
+			if(output != "bread")
+				return false;
+			doc[2] >> output;
+			if(output != "milk")
+				return false;
+
+			return true;
+		}
+
+		bool SimpleMap()
+		{
+			std::string input =
+				"name: Prince Fielder\n"
+				"position: 1B\n"
+				"bats: L";
+
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc["name"] >> output;
+			if(output != "Prince Fielder")
+				return false;
+			doc["position"] >> output;
+			if(output != "1B")
+				return false;
+			doc["bats"] >> output;
+			if(output != "L")
+				return false;
+
+			return true;
+		}
+
+		bool FlowSeq()
+		{
+			std::string input = "[ 2 , 3, 5  ,  7,   11]";
+
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			int output;
+			doc[0] >> output;
+			if(output != 2)
+				return false;
+			doc[1] >> output;
+			if(output != 3)
+				return false;
+			doc[2] >> output;
+			if(output != 5)
+				return false;
+			doc[3] >> output;
+			if(output != 7)
+				return false;
+			doc[4] >> output;
+			if(output != 11)
+				return false;
+
+			return true;
+		}
+
+		bool FlowMap()
+		{
+			std::string input = "{hr: 65, avg: 0.278}";
+
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc["hr"] >> output;
+			if(output != "65")
+				return false;
+			doc["avg"] >> output;
+			if(output != "0.278")
+				return false;
+
+			return true;
+		}
+
+		bool FlowMapWithOmittedKey()
+		{
+			std::string input = "{: omitted key}";
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc[YAML::Null] >> output;
+			if(output != "omitted key")
+				return false;
+			
+			return true;
+		}
+		
+		bool FlowMapWithOmittedValue()
+		{
+			std::string input = "{a: b, c:, d:}";
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc["a"] >> output;
+			if(output != "b")
+				return false;
+			if(!IsNull(doc["c"]))
+				return false;
+			if(!IsNull(doc["d"]))
+				return false;
+
+			return true;
+		}
+
+		bool FlowMapWithSoloEntry()
+		{
+			std::string input = "{a: b, c, d: e}";
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc["a"] >> output;
+			if(output != "b")
+				return false;
+			if(!IsNull(doc["c"]))
+				return false;
+			doc["d"] >> output;
+			if(output != "e")
+				return false;
+			
+			return true;
+		}
+		
+		bool FlowMapEndingWithSoloEntry()
+		{
+			std::string input = "{a: b, c}";
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc["a"] >> output;
+			if(output != "b")
+				return false;
+			if(!IsNull(doc["c"]))
+				return false;
+			
+			return true;
+		}
+		
+		bool QuotedSimpleKeys()
+		{
+			std::string KeyValue[3] = { "\"double\": double\n", "'single': single\n", "plain: plain\n" };
+			
+			int perm[3] = { 0, 1, 2 };
+			do {
+				std::string input = KeyValue[perm[0]] + KeyValue[perm[1]] + KeyValue[perm[2]];
+
+				std::stringstream stream(input);
+				YAML::Parser parser(stream);
+				YAML::Node doc;
+				parser.GetNextDocument(doc);
+				
+				std::string output;
+				doc["double"] >> output;
+				if(output != "double")
+					return false;
+				doc["single"] >> output;
+				if(output != "single")
+					return false;
+				doc["plain"] >> output;
+				if(output != "plain")
+					return false;
+			} while(std::next_permutation(perm, perm + 3));
+				
+			return true;
+		}
+
+		bool CompressedMapAndSeq()
+		{
+			std::string input = "key:\n- one\n- two";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			const YAML::Node& seq = doc["key"];
+			if(seq.size() != 2)
+				return false;
+				
+			std::string output;
+			seq[0] >> output;
+			if(output != "one")
+				return false;
+			seq[1] >> output;
+			if(output != "two")
+				return false;
+
+			return true;
+		}
+
+		bool NullBlockSeqEntry()
+		{
+			std::string input = "- hello\n-\n- world";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc[0] >> output;
+			if(output != "hello")
+				return false;
+			if(!IsNull(doc[1]))
+				return false;
+			doc[2] >> output;
+			if(output != "world")
+				return false;
+			
+			return true;
+		}
+		
+		bool NullBlockMapKey()
+		{
+			std::string input = ": empty key";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc[YAML::Null] >> output;
+			if(output != "empty key")
+				return false;
+			
+			return true;
+		}
+		
+		bool NullBlockMapValue()
+		{
+			std::string input = "empty value:";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(!IsNull(doc["empty value"]))
+				return false;
+			
+			return true;
+		}
+
+		bool SimpleAlias()
+		{
+			std::string input = "- &alias test\n- *alias";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc[0] >> output;
+			if(output != "test")
+				return false;
+			
+			doc[1] >> output;
+			if(output != "test")
+				return false;
+			
+			if(doc.size() != 2)
+				return false;
+			
+			return true;
+		}
+		
+		bool AliasWithNull()
+		{
+			std::string input = "- &alias\n- *alias";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(!IsNull(doc[0]))
+				return false;
+			
+			if(!IsNull(doc[1]))
+				return false;
+			
+			if(doc.size() != 2)
+				return false;
+			
+			return true;
+		}
+
+		bool AnchorInSimpleKey()
+		{
+			std::string input = "- &a b: c\n- *a";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(doc.size() != 2)
+				return false;
+	
+			std::string output;
+			doc[0]["b"] >> output;
+			if(output != "c")
+				return false;
+			
+			doc[1] >> output;
+			if(output != "b")
+				return false;
+			
+			return true;
+		}
+		
+		bool AliasAsSimpleKey()
+		{
+			std::string input = "- &a b\n- *a: c";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			if(doc.size() != 2)
+				return false;
+			
+			std::string output;
+			doc[0] >> output;
+			if(output != "b")
+				return false;
+			
+			doc[1]["b"] >> output;
+			if(output != "c")
+				return false;
+
+			return true;
+		}
+		
+		bool ExplicitDoc()
+		{
+			std::string input = "---\n- one\n- two";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(doc.size() != 2)
+				return false;
+			
+			std::string output;
+			doc[0] >> output;
+			if(output != "one")
+				return false;
+			doc[1] >> output;
+			if(output != "two")
+				return false;
+			
+			return true;
+		}
+
+		bool MultipleDocs()
+		{
+			std::string input = "---\nname: doc1\n---\nname: doc2";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc["name"] >> output;
+			if(output != "doc1")
+				return false;
+			
+			if(!parser)
+				return false;
+			
+			parser.GetNextDocument(doc);
+			doc["name"] >> output;
+			if(output != "doc2")
+				return false;
+			
+			return true;
+		}
+		
+		bool ExplicitEndDoc()
+		{
+			std::string input = "- one\n- two\n...\n...";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(doc.size() != 2)
+				return false;
+			
+			std::string output;
+			doc[0] >> output;
+			if(output != "one")
+				return false;
+			doc[1] >> output;
+			if(output != "two")
+				return false;
+			
+			return true;
+		}
+		
+		bool MultipleDocsWithSomeExplicitIndicators()
+		{
+			std::string input =
+				"- one\n- two\n...\n"
+				"---\nkey: value\n...\n...\n"
+				"- three\n- four\n"
+				"---\nkey: value";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			std::string output;
+
+			parser.GetNextDocument(doc);
+			if(doc.size() != 2)
+				return false;
+			doc[0] >> output;
+			if(output != "one")
+				return false;
+			doc[1] >> output;
+			if(output != "two")
+				return false;
+			
+			parser.GetNextDocument(doc);
+			doc["key"] >> output;
+			if(output != "value")
+				return false;
+			
+			parser.GetNextDocument(doc);
+			if(doc.size() != 2)
+				return false;
+			doc[0] >> output;
+			if(output != "three")
+				return false;
+			doc[1] >> output;
+			if(output != "four")
+				return false;
+			
+			parser.GetNextDocument(doc);
+			doc["key"] >> output;
+			if(output != "value")
+				return false;
+			
+			return true;
+		}
+	}
+	
+	namespace {
+		void RunScalarParserTest(void (*test)(std::string&, std::string&), const std::string& name, int& passed, int& total) {
+			std::string error;
+			std::string inputScalar, desiredOutput;
+			std::string output;
+			bool ok = true;
+			try {
+				test(inputScalar, desiredOutput);
+				std::stringstream stream(inputScalar);
+				YAML::Parser parser(stream);
+				YAML::Node doc;
+				parser.GetNextDocument(doc);
+				doc >> output;
+			} catch(const YAML::Exception& e) {
+				ok = false;
+				error = e.msg;
+			}
+			if(ok && output == desiredOutput) {
+				passed++;
+			} else {
+				std::cout << "Parser test failed: " << name << "\n";
+				if(error != "")
+					std::cout << "Caught exception: " << error << "\n";
+				else {
+					std::cout << "Output:\n" << output << "<<<\n";
+					std::cout << "Desired output:\n" << desiredOutput << "<<<\n";
+				}
+			}
+			total++;
+		}
+
+		void RunParserTest(bool (*test)(), const std::string& name, int& passed, int& total) {
+			std::string error;
+			bool ok = true;
+			try {
+				ok = test();
+			} catch(const YAML::Exception& e) {
+				ok = false;
+				error = e.msg;
+			}
+			if(ok) {
+				passed++;
+			} else {
+				std::cout << "Parser test failed: " << name << "\n";
+				if(error != "")
+					std::cout << "Caught exception: " << error << "\n";
+			}
+			total++;
+		}
+
+		typedef void (*EncodingFn)(std::ostream&, int);
+
+		inline char Byte(int ch)
+		{
+			return static_cast<char>(static_cast<unsigned char>(static_cast<unsigned int>(ch)));
+		}
+
+		void EncodeToUtf8(std::ostream& stream, int ch)
+		{
+			if (ch <= 0x7F)
+			{
+				stream << Byte(ch);
+			}
+			else if (ch <= 0x7FF)
+			{
+				stream << Byte(0xC0 | (ch >> 6));
+				stream << Byte(0x80 | (ch & 0x3F));
+			}
+			else if (ch <= 0xFFFF)
+			{
+				stream << Byte(0xE0 | (ch >> 12));
+				stream << Byte(0x80 | ((ch >> 6) & 0x3F));
+				stream << Byte(0x80 | (ch & 0x3F));
+			}
+			else if (ch <= 0x1FFFFF)
+			{
+				stream << Byte(0xF0 | (ch >> 18));
+				stream << Byte(0x80 | ((ch >> 12) & 0x3F));
+				stream << Byte(0x80 | ((ch >> 6) & 0x3F));
+				stream << Byte(0x80 | (ch & 0x3F));
+			}
+		}
+
+		bool SplitUtf16HighChar(std::ostream& stream, EncodingFn encoding, int ch)
+		{
+			int biasedValue = ch - 0x10000;
+			if (biasedValue < 0)
+			{
+				return false;
+			}
+			int high = 0xD800 | (biasedValue >> 10);
+			int low  = 0xDC00 | (biasedValue & 0x3FF);
+			encoding(stream, high);
+			encoding(stream, low);
+			return true;
+		}
+
+		void EncodeToUtf16LE(std::ostream& stream, int ch)
+		{
+			if (!SplitUtf16HighChar(stream, &EncodeToUtf16LE, ch))
+			{
+				stream << Byte(ch & 0xFF) << Byte(ch >> 8);
+			}
+		}
+
+		void EncodeToUtf16BE(std::ostream& stream, int ch)
+		{
+			if (!SplitUtf16HighChar(stream, &EncodeToUtf16BE, ch))
+			{
+				stream << Byte(ch >> 8) << Byte(ch & 0xFF);
+			}
+		}
+
+		void EncodeToUtf32LE(std::ostream& stream, int ch)
+		{
+			stream << Byte(ch & 0xFF) << Byte((ch >> 8) & 0xFF) 
+				<< Byte((ch >> 16) & 0xFF) << Byte((ch >> 24) & 0xFF);
+		}
+
+		void EncodeToUtf32BE(std::ostream& stream, int ch)
+		{
+			stream << Byte((ch >> 24) & 0xFF) << Byte((ch >> 16) & 0xFF)
+				<< Byte((ch >> 8) & 0xFF) << Byte(ch & 0xFF);
+		}
+
+		class EncodingTester
+		{
+		public:
+			EncodingTester(EncodingFn encoding, bool declareEncoding)
+			{
+				if (declareEncoding)
+				{
+					encoding(m_yaml, 0xFEFF);
+				}
+
+				AddEntry(encoding, 0x0021, 0x007E); // Basic Latin
+				AddEntry(encoding, 0x00A1, 0x00FF); // Latin-1 Supplement
+				AddEntry(encoding, 0x0660, 0x06FF); // Arabic (largest contiguous block)
+
+				// CJK unified ideographs (multiple lines)
+				AddEntry(encoding, 0x4E00, 0x4EFF);
+				AddEntry(encoding, 0x4F00, 0x4FFF);
+				AddEntry(encoding, 0x5000, 0x51FF); // 512 character line
+				AddEntry(encoding, 0x5200, 0x54FF); // 768 character line
+				AddEntry(encoding, 0x5500, 0x58FF); // 1024 character line
+
+				AddEntry(encoding, 0x103A0, 0x103C3); // Old Persian
+
+				m_yaml.seekg(0, std::ios::beg);
+			}
+
+			std::istream& stream() {return m_yaml;}
+			const std::vector<std::string>& entries() {return m_entries;}
+
+		private:
+			std::stringstream m_yaml;
+			std::vector<std::string> m_entries;
+
+			void AddEntry(EncodingFn encoding, int startCh, int endCh)
+			{
+				encoding(m_yaml, '-');
+				encoding(m_yaml, ' ');
+				encoding(m_yaml, '|');
+				encoding(m_yaml, '\n');
+				encoding(m_yaml, ' ');
+				encoding(m_yaml, ' ');
+
+				std::stringstream entry;
+				for (int ch = startCh; ch <= endCh; ++ch)
+				{
+					encoding(m_yaml, ch);
+					EncodeToUtf8(entry, ch);
+				}
+				encoding(m_yaml, '\n');
+
+				m_entries.push_back(entry.str());
+			}
+		};
+
+		void RunEncodingTest(EncodingFn encoding, bool declareEncoding, const std::string& name, int& passed, int& total)
+		{
+			EncodingTester tester(encoding, declareEncoding);
+			std::string error;
+			bool ok = true;
+			try {
+				YAML::Parser parser(tester.stream());
+				YAML::Node doc;
+				parser.GetNextDocument(doc);
+
+				YAML::Iterator itNode = doc.begin();
+				std::vector<std::string>::const_iterator itEntry = tester.entries().begin();
+				for (; (itNode != doc.end()) && (itEntry != tester.entries().end()); ++itNode, ++itEntry)
+				{
+					std::string stScalarValue;
+					if (!itNode->GetScalar(stScalarValue) && (stScalarValue == *itEntry))
+					{
+						break;
+					}
+				}
+
+				if ((itNode != doc.end()) || (itEntry != tester.entries().end()))
+				{
+					ok = false;
+				}
+			} catch(const YAML::Exception& e) {
+				ok = false;
+				error = e.msg;
+			}
+			if(ok) {
+				passed++;
+			} else {
+				std::cout << "Parser test failed: " << name << "\n";
+				if(error != "")
+					std::cout << "Caught exception: " << error << "\n";
+			}
+			total++;
+		}
+	}
+
+	bool RunParserTests()
+	{
+		int passed = 0;
+		int total = 0;
+		RunScalarParserTest(&Parser::SimpleScalar, "simple scalar", passed, total);
+		RunScalarParserTest(&Parser::MultiLineScalar, "multi-line scalar", passed, total);
+		RunScalarParserTest(&Parser::LiteralScalar, "literal scalar", passed, total);
+		RunScalarParserTest(&Parser::FoldedScalar, "folded scalar", passed, total);
+		RunScalarParserTest(&Parser::ChompedFoldedScalar, "chomped folded scalar", passed, total);
+		RunScalarParserTest(&Parser::ChompedLiteralScalar, "chomped literal scalar", passed, total);
+		RunScalarParserTest(&Parser::FoldedScalarWithIndent, "folded scalar with indent", passed, total);
+		RunScalarParserTest(&Parser::ColonScalar, "colon scalar", passed, total);
+		RunScalarParserTest(&Parser::QuotedScalar, "quoted scalar", passed, total);
+		RunScalarParserTest(&Parser::CommaScalar, "comma scalar", passed, total);
+		RunScalarParserTest(&Parser::DashScalar, "dash scalar", passed, total);
+		RunScalarParserTest(&Parser::URLScalar, "url scalar", passed, total);
+
+		RunParserTest(&Parser::SimpleSeq, "simple seq", passed, total);
+		RunParserTest(&Parser::SimpleMap, "simple map", passed, total);
+		RunParserTest(&Parser::FlowSeq, "flow seq", passed, total);
+		RunParserTest(&Parser::FlowMap, "flow map", passed, total);
+		RunParserTest(&Parser::FlowMapWithOmittedKey, "flow map with omitted key", passed, total);
+		RunParserTest(&Parser::FlowMapWithOmittedValue, "flow map with omitted value", passed, total);
+		RunParserTest(&Parser::FlowMapWithSoloEntry, "flow map with solo entry", passed, total);
+		RunParserTest(&Parser::FlowMapEndingWithSoloEntry, "flow map ending with solo entry", passed, total);
+		RunParserTest(&Parser::QuotedSimpleKeys, "quoted simple keys", passed, total);
+		RunParserTest(&Parser::CompressedMapAndSeq, "compressed map and seq", passed, total);
+		RunParserTest(&Parser::NullBlockSeqEntry, "null block seq entry", passed, total);
+		RunParserTest(&Parser::NullBlockMapKey, "null block map key", passed, total);
+		RunParserTest(&Parser::NullBlockMapValue, "null block map value", passed, total);
+		RunParserTest(&Parser::SimpleAlias, "simple alias", passed, total);
+		RunParserTest(&Parser::AliasWithNull, "alias with null", passed, total);
+		RunParserTest(&Parser::AnchorInSimpleKey, "anchor in simple key", passed, total);
+		RunParserTest(&Parser::AliasAsSimpleKey, "alias as simple key", passed, total);
+		RunParserTest(&Parser::ExplicitDoc, "explicit doc", passed, total);
+		RunParserTest(&Parser::MultipleDocs, "multiple docs", passed, total);
+		RunParserTest(&Parser::ExplicitEndDoc, "explicit end doc", passed, total);
+		RunParserTest(&Parser::MultipleDocsWithSomeExplicitIndicators, "multiple docs with some explicit indicators", passed, total);
+		
+		RunEncodingTest(&EncodeToUtf8, false, "UTF-8, no BOM", passed, total);
+		RunEncodingTest(&EncodeToUtf8, true, "UTF-8 with BOM", passed, total);
+		RunEncodingTest(&EncodeToUtf16LE, false, "UTF-16LE, no BOM", passed, total);
+		RunEncodingTest(&EncodeToUtf16LE, true, "UTF-16LE with BOM", passed, total);
+		RunEncodingTest(&EncodeToUtf16BE, false, "UTF-16BE, no BOM", passed, total);
+		RunEncodingTest(&EncodeToUtf16BE, true, "UTF-16BE with BOM", passed, total);
+		RunEncodingTest(&EncodeToUtf32LE, false, "UTF-32LE, no BOM", passed, total);
+		RunEncodingTest(&EncodeToUtf32LE, true, "UTF-32LE with BOM", passed, total);
+		RunEncodingTest(&EncodeToUtf32BE, false, "UTF-32BE, no BOM", passed, total);
+		RunEncodingTest(&EncodeToUtf32BE, true, "UTF-32BE with BOM", passed, total);
+
+		std::cout << "Parser tests: " << passed << "/" << total << " passed\n";
+		return passed == total;
+	}
+}
+

yaml-reader/parsertests.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#ifndef PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+namespace Test {
+	bool RunParserTests();
+}
+
+#endif // PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+

yaml-reader/spectests.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#ifndef SPECTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SPECTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+namespace Test {
+	bool RunSpecTests();
+}
+
+#endif // SPECTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+

yaml-reader/tests.cpp

@@ -0,0 +1,29 @@
+#include "tests.h"
+#include "emittertests.h"
+#include "parsertests.h"
+#include "spectests.h"
+#include "yaml.h"
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <iostream>
+
+namespace Test
+{
+	void RunAll()
+	{
+		bool passed = true;
+		if(!RunParserTests())
+			passed = false;
+			
+		if(!RunEmitterTests())
+			passed = false;
+
+		if(!RunSpecTests())
+			passed = false;
+		
+		if(passed)
+			std::cout << "All tests passed!\n";
+	}
+}
+

yaml-reader/tests.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#ifndef TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#include <string>
+
+namespace Test {
+	void RunAll();
+
+	namespace Parser {
+		// scalar tests
+		void SimpleScalar(std::string& inputScalar, std::string& desiredOutput);
+		void MultiLineScalar(std::string& inputScalar, std::string& desiredOutput);
+		void LiteralScalar(std::string& inputScalar, std::string& desiredOutput);
+		void FoldedScalar(std::string& inputScalar, std::string& desiredOutput);
+		void ChompedFoldedScalar(std::string& inputScalar, std::string& desiredOutput);
+		void ChompedLiteralScalar(std::string& inputScalar, std::string& desiredOutput);
+		void FoldedScalarWithIndent(std::string& inputScalar, std::string& desiredOutput);
+		void ColonScalar(std::string& inputScalar, std::string& desiredOutput);
+		void QuotedScalar(std::string& inputScalar, std::string& desiredOutput);
+		void CommaScalar(std::string& inputScalar, std::string& desiredOutput);
+		void DashScalar(std::string& inputScalar, std::string& desiredOutput);
+		void URLScalar(std::string& inputScalar, std::string& desiredOutput);
+
+		// misc tests
+		bool SimpleSeq();
+		bool SimpleMap();
+		bool FlowSeq();
+		bool FlowMap();
+		bool FlowMapWithOmittedKey();
+		bool FlowMapWithOmittedValue();
+		bool FlowMapWithSoloEntry();
+		bool FlowMapEndingWithSoloEntry();
+		bool QuotedSimpleKeys();
+		bool CompressedMapAndSeq();
+		bool NullBlockSeqEntry();
+		bool NullBlockMapKey();
+		bool NullBlockMapValue();
+		bool SimpleAlias();
+		bool AliasWithNull();
+		bool AnchorInSimpleKey();
+		bool AliasAsSimpleKey();
+		bool ExplicitDoc();
+		bool MultipleDocs();
+		bool ExplicitEndDoc();
+		bool MultipleDocsWithSomeExplicitIndicators();
+	}
+}
+
+#endif // TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

yaml-reader/tests/aliased.yaml

@@ -0,0 +1,4 @@
+--- &list
+- This document contains a recursive list.
+- *list
+...