mirror of
https://github.com/jbeder/yaml-cpp.git
synced 2025-09-09 04:41:16 +00:00
Now actually removed yaml-reader
This commit is contained in:
Jesse Beder
@@ -20,7 +20,7 @@ set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML
|
||||
|
||||
enable_testing()
|
||||
|
||||
option(YAML_CPP_BUILD_TOOLS "Enables or disables yaml-reader and parse tools" true)
|
||||
option(YAML_CPP_BUILD_TOOLS "Enables or disables testing and parse tools" true)
|
||||
|
||||
if(WIN32)
|
||||
set(_library_dir bin) # .dll are in PATH, like executables
|
||||
@@ -67,6 +67,6 @@ if(UNIX)
|
||||
endif(UNIX)
|
||||
|
||||
if(YAML_CPP_BUILD_TOOLS)
|
||||
add_subdirectory (yaml-reader)
|
||||
add_subdirectory (test)
|
||||
add_subdirectory (util)
|
||||
endif(YAML_CPP_BUILD_TOOLS)
|
||||
|
||||
@@ -1,10 +0,0 @@
|
||||
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)
|
||||
@@ -1,650 +0,0 @@
|
||||
#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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
#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
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
#include "tests.h"
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifdef WINDOWS
|
||||
_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF);
|
||||
#endif // WINDOWS
|
||||
Test::RunAll();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,888 +0,0 @@
|
||||
#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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
#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
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,11 +0,0 @@
|
||||
#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
|
||||
|
||||
@@ -1,29 +0,0 @@
|
||||
#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";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,51 +0,0 @@
|
||||
#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
|
||||
@@ -1,4 +0,0 @@
|
||||
--- &list
|
||||
- This document contains a recursive list.
|
||||
- *list
|
||||
...
|
||||
Reference in New Issue
Block a user