Mirrors/rapidyaml
0
0
Fork 0
mirror of https://github.com/biojppm/rapidyaml.git synced 2026-01-18 21:41:18 +01:00
Code Issues Packages Projects Releases Wiki Activity

split test-parse_engine, compilers were choking on it

Browse Source
This commit is contained in:
Joao Paulo Magalhaes
2024-05-06 00:04:15 +02:00
parent bdfb82f449
commit f465a92352
12 changed files with 7036 additions and 6811 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
test/CMakeLists.txt
View File

@@ -32,8 +32,8 @@ endif()
function(ryml_add_test test_name)
set(t ryml-test-${test_name})
c4_add_executable(${t}
SOURCES test_${test_name}.cpp ${ARGN}
LIBS ryml-_testlib gtest_main
SOURCES test_${test_name}.cpp
LIBS ${ARGN} ryml-_testlib gtest_main
FOLDER test)
c4_add_test(${t})
endfunction()
@@ -52,12 +52,27 @@ function(ryml_add_test_case_group name)
endfunction()
ryml_add_test(parse_engine
test_suite/test_suite_event_handler.cpp
test_suite/test_suite_event_handler.hpp)
ryml_add_test(yaml_events
test_suite/test_suite_event_handler.cpp
test_suite/test_suite_event_handler.hpp)
c4_add_library(ryml-_evt_handler_yaml_std LIBRARY_STATIC
SOURCES
test_suite/test_suite_event_handler.cpp
test_suite/test_suite_event_handler.hpp
LIBS ryml
FOLDER test
)
function(ryml_add_engine_test name)
ryml_add_test(${name} ryml-_evt_handler_yaml_std)
endfunction()
ryml_add_engine_test(parse_engine_1_doc)
ryml_add_engine_test(parse_engine_2_map)
ryml_add_engine_test(parse_engine_3_seq)
ryml_add_engine_test(parse_engine_4_anchor)
ryml_add_engine_test(parse_engine_5_tag)
ryml_add_engine_test(parse_engine_6_qmrk)
ryml_add_engine_test(parse_engine_7_seqimap)
ryml_add_engine_test(parse_engine_8_scalars_tokens)
ryml_add_engine_test(yaml_events)
ryml_add_test(callbacks)
ryml_add_test(stack)
ryml_add_test(filter)
@@ -105,10 +120,6 @@ ryml_add_test_case_group(indentation)
ryml_add_test_case_group(number)
ryml_add_test_case_group(github_issues)
if(WIN32 AND MSVC)
target_compile_options(ryml-test-parse_engine PRIVATE /bigobj)
endif()
#-------------------------------------------------------------------------
# test the tools as well

6796
test/test_parse_engine.cpp
View File

File diff suppressed because it is too large Load Diff

1136
test/test_parse_engine_1_doc.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1578
test/test_parse_engine_2_map.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

637
test/test_parse_engine_3_seq.cpp Normal file
View File

@@ -0,0 +1,637 @@
#include "./test_lib/test_engine.hpp"
// WARNING: don't use raw string literals -- g++4.8 cannot accept them
// as macro arguments
namespace c4 {
namespace yml {
//-----------------------------------------------------------------------------
ENGINE_TEST(SimpleSeqFlow,
("[foo,bar,baz]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :foo\n"
"=VAL :bar\n"
"=VAL :baz\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("foo"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("baz"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST_ERRLOC(SimpleSeqFlowErr0, Location(1,1,2), "[")
ENGINE_TEST_ERRLOC(SimpleSeqFlowErr1, Location(2,1,3), "[[")
ENGINE_TEST_ERRLOC(SimpleSeqFlowErr2, Location(3,1,4), "[[]")
ENGINE_TEST_ERRLOC(SimpleSeqFlowErr3, Location(5,1,6), "[[[]]")
ENGINE_TEST_ERRLOC(SimpleSeqFlowErr4, Location(4,1,5), "[foo")
ENGINE_TEST_ERRLOC(SimpleSeqFlowErr5, Location(5,1,6), "[foo,")
ENGINE_TEST_ERRLOC(SimpleSeqFlowErr6, Location(12,1,13), "[foo,bar,baz")
ENGINE_TEST_ERRLOC(SimpleSeqFlowErr7, Location(8,1,9), "[[a,b,c]")
ENGINE_TEST(NestedSeqFlowEmpty,
("[[]]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+SEQ []\n"
"-SEQ\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_seq_val_flow());
___(ps.end_seq());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(NestedSeq3FlowEmpty,
("[[[]]]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+SEQ []\n"
"+SEQ []\n"
"-SEQ\n"
"-SEQ\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_seq_val_flow());
___(ps.begin_seq_val_flow());
___(ps.end_seq());
___(ps.end_seq());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(NestedSeq4FlowEmpty,
("[[[[]]]]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+SEQ []\n"
"+SEQ []\n"
"+SEQ []\n"
"-SEQ\n"
"-SEQ\n"
"-SEQ\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_seq_val_flow());
___(ps.begin_seq_val_flow());
___(ps.begin_seq_val_flow());
___(ps.end_seq());
___(ps.end_seq());
___(ps.end_seq());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SimpleSeqFlowMultiline,
("[\nfoo\n,\nbar\n,\nbaz\n]", "[foo,bar,baz]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :foo\n"
"=VAL :bar\n"
"=VAL :baz\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("foo"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("baz"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
//-----------------------------------------------------------------------------
ENGINE_TEST(SimpleSeqBlock,
("- foo\n- bar\n- baz\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL :foo\n"
"=VAL :bar\n"
"=VAL :baz\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.set_val_scalar_plain("foo"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("baz"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SimpleSeqBlock2,
("- [foo, bar, baz]\n- {foo: bar,baz}\n",
"- [foo,bar,baz]\n- {foo: bar,baz: }\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"+SEQ []\n"
"=VAL :foo\n"
"=VAL :bar\n"
"=VAL :baz\n"
"-SEQ\n"
"+MAP {}\n"
"=VAL :foo\n"
"=VAL :bar\n"
"=VAL :baz\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("foo"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("baz"));
___(ps.end_seq());
___(ps.add_sibling());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("foo"));
___(ps.set_val_scalar_plain("bar"));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("baz"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SimpleSeqBlockPlainScalar0,
(HAS_MULTILINE_SCALAR,
"- a\n"
" b\n"
,
"- a b\n")
,
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL :a b\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
ps.begin_stream();
ps.begin_doc();
ps.begin_seq_val_block();
ps.set_val_scalar_plain("a b");
ps.end_seq();
ps.end_doc();
ps.end_stream();
}
ENGINE_TEST(SimpleSeqBlockPlainScalar1,
(HAS_MULTILINE_SCALAR,
"- a\n"
" - b - c\n",
"- a - b - c\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL :a - b - c\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
ps.begin_stream();
ps.begin_doc();
ps.begin_seq_val_block();
ps.set_val_scalar_plain("a - b - c");
ps.end_seq();
ps.end_doc();
ps.end_stream();
}
ENGINE_TEST(SimpleSeqBlockComment0,
("- &wtf\n"
" # this is a comment\n"
" foo\n"
"\n",
"- &wtf foo\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL &wtf :foo\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
ps.begin_stream();
ps.begin_doc();
ps.begin_seq_val_block();
ps.set_val_anchor("wtf");
ps.set_val_scalar_plain("foo");
ps.end_seq();
ps.end_doc();
ps.end_stream();
}
ENGINE_TEST(SimpleSeqBlockComment1,
("- &wtf\n"
" foo\n"
" # this is a comment\n"
"\n", "- &wtf foo\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL &wtf :foo\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
ps.begin_stream();
ps.begin_doc();
ps.begin_seq_val_block();
ps.set_val_anchor("wtf");
ps.set_val_scalar_plain("foo");
ps.end_seq();
ps.end_doc();
ps.end_stream();
}
ENGINE_TEST(SimpleSeqBlockEmptyScalars,
("-\n-\n-\n-\n", "- \n- \n- \n- \n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL :\n"
"=VAL :\n"
"=VAL :\n"
"=VAL :\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
ps.begin_stream();
ps.begin_doc();
ps.begin_seq_val_block();
ps.set_val_scalar_plain({});
ps.add_sibling();
ps.set_val_scalar_plain({});
ps.add_sibling();
ps.set_val_scalar_plain({});
ps.add_sibling();
ps.set_val_scalar_plain({});
ps.end_seq();
ps.end_doc();
ps.end_stream();
}
ENGINE_TEST(SimpleSeqBlockEmptyLiterals,
(HAS_MULTILINE_SCALAR,
"- |\n- |\n- |\n- |\n",
"- |-\n- |-\n- |-\n- |-\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL |\n"
"=VAL |\n"
"=VAL |\n"
"=VAL |\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
ps.begin_stream();
ps.begin_doc();
ps.begin_seq_val_block();
ps.set_val_scalar_literal({});
ps.add_sibling();
ps.set_val_scalar_literal({});
ps.add_sibling();
ps.set_val_scalar_literal({});
ps.add_sibling();
ps.set_val_scalar_literal({});
ps.end_seq();
ps.end_doc();
ps.end_stream();
}
ENGINE_TEST(SimpleSeqBlockEmptyFolded,
(HAS_MULTILINE_SCALAR,
"- >\n- >\n- >\n- >\n",
"- >-\n- >-\n- >-\n- >-\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL >\n"
"=VAL >\n"
"=VAL >\n"
"=VAL >\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
ps.begin_stream();
ps.begin_doc();
ps.begin_seq_val_block();
ps.set_val_scalar_folded({});
ps.add_sibling();
ps.set_val_scalar_folded({});
ps.add_sibling();
ps.set_val_scalar_folded({});
ps.add_sibling();
ps.set_val_scalar_folded({});
ps.end_seq();
ps.end_doc();
ps.end_stream();
}
//-----------------------------------------------------------------------------
ENGINE_TEST(SeqSeqFlow,
("[[foo1,bar1,baz1],\n[foo2,bar2,baz2]]", "[[foo1,bar1,baz1],[foo2,bar2,baz2]]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+SEQ []\n"
"=VAL :foo1\n"
"=VAL :bar1\n"
"=VAL :baz1\n"
"-SEQ\n"
"+SEQ []\n"
"=VAL :foo2\n"
"=VAL :bar2\n"
"=VAL :baz2\n"
"-SEQ\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("foo1"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar1"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("baz1"));
___(ps.end_seq());
___(ps.add_sibling());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("foo2"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar2"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("baz2"));
___(ps.end_seq());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
//-----------------------------------------------------------------------------
ENGINE_TEST(SeqSeqBlock,
("- - foo1\n"
" - bar1\n"
" - baz1\n"
"- - foo2\n"
" - bar2\n"
" - baz2\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"+SEQ\n"
"=VAL :foo1\n"
"=VAL :bar1\n"
"=VAL :baz1\n"
"-SEQ\n"
"+SEQ\n"
"=VAL :foo2\n"
"=VAL :bar2\n"
"=VAL :baz2\n"
"-SEQ\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.begin_seq_val_block());
___(ps.set_val_scalar_plain("foo1"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar1"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("baz1"));
___(ps.end_seq());
___(ps.add_sibling());
___(ps.begin_seq_val_block());
___(ps.set_val_scalar_plain("foo2"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar2"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("baz2"));
___(ps.end_seq());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqSeqSeqBlock,
("- - - foo1\n"
" - bar1\n"
" - baz1\n"
" - - foo2\n"
" - bar2\n"
" - baz2\n"
"- back\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"+SEQ\n"
"+SEQ\n"
"=VAL :foo1\n"
"=VAL :bar1\n"
"=VAL :baz1\n"
"-SEQ\n"
"+SEQ\n"
"=VAL :foo2\n"
"=VAL :bar2\n"
"=VAL :baz2\n"
"-SEQ\n"
"-SEQ\n"
"=VAL :back\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.begin_seq_val_block());
___(ps.begin_seq_val_block());
___(ps.set_val_scalar_plain("foo1"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar1"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("baz1"));
___(ps.end_seq());
___(ps.add_sibling());
___(ps.begin_seq_val_block());
___(ps.set_val_scalar_plain("foo2"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar2"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("baz2"));
___(ps.end_seq());
___(ps.end_seq());
___(ps.add_sibling());
___(ps.set_val_scalar_plain("back"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqMapBlock,
("- foo: 1\n"
" bar: 2\n"
"- foo: 10\n"
" bar: 20\n"
"- foo: 100\n"
" bar: 200\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"+MAP\n"
"=VAL :foo\n"
"=VAL :1\n"
"=VAL :bar\n"
"=VAL :2\n"
"-MAP\n"
"+MAP\n"
"=VAL :foo\n"
"=VAL :10\n"
"=VAL :bar\n"
"=VAL :20\n"
"-MAP\n"
"+MAP\n"
"=VAL :foo\n"
"=VAL :100\n"
"=VAL :bar\n"
"=VAL :200\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("foo"));
___(ps.set_val_scalar_plain("1"));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("bar"));
___(ps.set_val_scalar_plain("2"));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("foo"));
___(ps.set_val_scalar_plain("10"));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("bar"));
___(ps.set_val_scalar_plain("20"));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("foo"));
___(ps.set_val_scalar_plain("100"));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("bar"));
___(ps.set_val_scalar_plain("200"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
} // namespace yml
} // namespace c4
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// this is needed to use the test case library
#ifndef RYML_SINGLE_HEADER
#include "c4/substr.hpp"
#endif
namespace c4 {
namespace yml {
struct Case;
Case const* get_case(csubstr /*name*/)
{
return nullptr;
}
} // namespace yml
} // namespace c4

1136
test/test_parse_engine_4_anchor.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

188
test/test_parse_engine_5_tag.cpp Normal file
View File

@@ -0,0 +1,188 @@
#include "./test_lib/test_engine.hpp"
// WARNING: don't use raw string literals -- g++4.8 cannot accept them
// as macro arguments
namespace c4 {
namespace yml {
//-----------------------------------------------------------------------------
ENGINE_TEST(TagBlock,
("- !light fluorescent\n- notag\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL <!light> :fluorescent\n"
"=VAL :notag\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.set_val_tag("!light"));
___(ps.set_val_scalar_plain("fluorescent"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("notag"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(TagFlow,
("[!light fluorescent,notag]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL <!light> :fluorescent\n"
"=VAL :notag\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_tag("!light"));
___(ps.set_val_scalar_plain("fluorescent"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("notag"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(DirectiveAndTag,
("%YAML 1.2\n"
"---\n"
"!light fluorescent\n"
"...\n"
"%TAG !m! !my-\n"
"---\n"
"!m!light green\n",
"--- !light fluorescent\n"
"...\n"
"%TAG !m! !my-\n"
"--- !m!light green\n"),
"+STR\n"
"+DOC ---\n"
"=VAL <!light> :fluorescent\n"
"-DOC ...\n"
"+DOC ---\n"
"=VAL <!my-light> :green\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.add_directive("%YAML 1.2"));
___(ps.begin_doc_expl());
___(ps.set_val_tag("!light"));
___(ps.set_val_scalar_plain("fluorescent"));
___(ps.end_doc_expl());
___(ps.add_directive("%TAG !m! !my-"));
___(ps.begin_doc_expl());
___(ps.set_val_tag("!m!light"));
___(ps.set_val_scalar_plain("green"));
___(ps.end_doc());
___(ps.end_stream());
}
//-----------------------------------------------------------------------------
ENGINE_TEST(TagTestSuiteUKK6_02_0,
("!", "! \n"),
"+STR\n"
"+DOC\n"
"=VAL <!> :\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.set_val_tag("!"));
___(ps.set_val_scalar_plain({}));
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(TagTestSuite6WLZ_0,
("--- !foo \"bar\"\n"
"...\n"
"%TAG ! tag:example.com,2000:app/\n"
"--- !foo \"bar\"\n"),
"+STR\n"
"+DOC ---\n"
"=VAL <!foo> \"bar\n"
"-DOC ...\n"
"+DOC ---\n"
"=VAL <tag:example.com,2000:app/foo> \"bar\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc_expl());
___(ps.set_val_tag("!foo"));
___(ps.set_val_scalar_dquoted("bar"));
___(ps.end_doc_expl());
___(ps.add_directive("%TAG ! tag:example.com,2000:app/"));
___(ps.begin_doc_expl());
___(ps.set_val_tag("!foo"));
___(ps.set_val_scalar_dquoted("bar"));
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(TagTestSuite6WLZ_1,
("--- !foo \"bar\"\n"
"...\n"
"%TAG ! tag:example.com,2000:app/\n"
"--- !<tag:example.com,2000:app/foo> \"bar\"\n"),
"+STR\n"
"+DOC ---\n"
"=VAL <!foo> \"bar\n"
"-DOC ...\n"
"+DOC ---\n"
"=VAL <tag:example.com,2000:app/foo> \"bar\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc_expl());
___(ps.set_val_tag("!foo"));
___(ps.set_val_scalar_dquoted("bar"));
___(ps.end_doc_expl());
___(ps.add_directive("%TAG ! tag:example.com,2000:app/"));
___(ps.begin_doc_expl());
___(ps.set_val_tag("<tag:example.com,2000:app/foo>"));
___(ps.set_val_scalar_dquoted("bar"));
___(ps.end_doc());
___(ps.end_stream());
}
} // namespace yml
} // namespace c4
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// this is needed to use the test case library
#ifndef RYML_SINGLE_HEADER
#include "c4/substr.hpp"
#endif
namespace c4 {
namespace yml {
struct Case;
Case const* get_case(csubstr /*name*/)
{
return nullptr;
}
} // namespace yml
} // namespace c4

984
test/test_parse_engine_6_qmrk.cpp Normal file
View File

@@ -0,0 +1,984 @@
#include "./test_lib/test_engine.hpp"
// WARNING: don't use raw string literals -- g++4.8 cannot accept them
// as macro arguments
namespace c4 {
namespace yml {
//-----------------------------------------------------------------------------
ENGINE_TEST(Qmrk0,
(HAS_CONTAINER_KEYS, Location(41,3,19),
"\n"
"a simple key: a value\n"
"? an explicit key: another value\n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"=VAL :a simple key\n"
"=VAL :a value\n"
"+MAP\n"
"=VAL :an explicit key\n"
"=VAL :another value\n"
"-MAP\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("a simple key"));
___(ps.set_val_scalar_plain("a value"));
___(ps.add_sibling());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain("an explicit key"));
___(ps.set_val_scalar_plain("another value"));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(Qmrk1_0,
("? an explicit key\n"
"a simple key: a value\n",
"an explicit key: \n"
"a simple key: a value\n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"=VAL :an explicit key\n"
"=VAL :\n"
"=VAL :a simple key\n"
"=VAL :a value\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("an explicit key"));
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("a simple key"));
___(ps.set_val_scalar_plain("a value"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(Qmrk1_1,
(HAS_CONTAINER_KEYS, Location(19,2,19),
"\n"
"? an explicit key: another value\n"
"a simple key: a value\n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"+MAP\n"
"=VAL :an explicit key\n"
"=VAL :another value\n"
"-MAP\n"
"=VAL :\n"
"=VAL :a simple key\n"
"=VAL :a value\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain("an explicit key"));
___(ps.set_val_scalar_plain("another value"));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("a simple key"));
___(ps.set_val_scalar_plain("a value"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(Qmrk1_2,
(HAS_CONTAINER_KEYS, Location(25,2,21),
"map:\n"
" ? an explicit key: another value\n"
" a simple key: a value\n"
"? an explicit key deindented: its value\n"
"? more: siblings\n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"=VAL :map\n"
"+MAP\n"
"+MAP\n"
"=VAL :an explicit key\n"
"=VAL :another value\n"
"-MAP\n"
"=VAL :\n"
"=VAL :a simple key\n"
"=VAL :a value\n"
"-MAP\n"
"+MAP\n"
"=VAL :an explicit key deindented\n"
"=VAL :its value\n"
"-MAP\n"
"=VAL :\n"
"+MAP\n"
"=VAL :more\n"
"=VAL :siblings\n"
"-MAP\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("map"));
___(ps.begin_map_val_block());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain("an explicit key"));
___(ps.set_val_scalar_plain("another value"));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("a simple key"));
___(ps.set_val_scalar_plain("a value"));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain("an explicit key deindented"));
___(ps.set_key_scalar_plain("its value"));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain("more"));
___(ps.set_key_scalar_plain("siblings"));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(Qmrk2_0,
("? an explicit key\n"
"...\n"
"? another explicit key\n",
"---\n"
"an explicit key: \n"
"---\n"
"another explicit key: \n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"=VAL :an explicit key\n"
"=VAL :\n"
"-MAP\n"
"-DOC ...\n"
"+DOC\n"
"+MAP\n"
"=VAL :another explicit key\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("an explicit key"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc_expl());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("another explicit key"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(Qmrk2_1,
("? an explicit key\n"
"---\n"
"? another explicit key\n",
"---\n"
"an explicit key: \n"
"---\n"
"another explicit key: \n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"=VAL :an explicit key\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"+DOC ---\n"
"+MAP\n"
"=VAL :another explicit key\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("an explicit key"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.begin_doc_expl());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("another explicit key"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(Qmrk3,
("{ ? an explicit key, ? foo,? bar,?baz:,?bat}",
"{an explicit key: ,foo: ,bar: ,?baz: ,?bat: }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL :an explicit key\n"
"=VAL :\n"
"=VAL :foo\n"
"=VAL :\n"
"=VAL :bar\n"
"=VAL :\n"
"=VAL :?baz\n"
"=VAL :\n"
"=VAL :?bat\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("an explicit key"));
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("foo"));
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("bar"));
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("?baz"));
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("?bat"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(Qmrk4,
("[ ? an explicit key, ? foo,? bar,?baz:,?bat]",
"[{an explicit key: },{foo: },{bar: },{?baz: },?bat]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :an explicit key\n"
"=VAL :\n"
"-MAP\n"
"+MAP {}\n"
"=VAL :foo\n"
"=VAL :\n"
"-MAP\n"
"+MAP {}\n"
"=VAL :bar\n"
"=VAL :\n"
"-MAP\n"
"+MAP {}\n"
"=VAL :?baz\n"
"=VAL :\n"
"-MAP\n"
"=VAL :?bat\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("an explicit key"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("foo"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("bar"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("?baz"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_val_scalar_plain("?bat"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(Qmrk5,
(HAS_CONTAINER_KEYS, Location(4,1,5),
"? a: b\n"
"?\n"
"?\n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"+MAP\n"
"=VAL :a\n"
"=VAL :b\n"
"-MAP\n"
"=VAL :\n"
"=VAL :\n"
"=VAL :\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain("a"));
___(ps.set_val_scalar_plain("b"));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(Qmrk6,
(HAS_CONTAINER_KEYS, Location(21,2,21),
"\n"
"- ? an explicit key: another value\n"
" a simple key: a value\n"
"- ? another explicit key: its value\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"+MAP\n"
"+MAP\n"
"=VAL :an explicit key\n"
"=VAL :another value\n"
"-MAP\n"
"=VAL :\n"
"=VAL :a simple key\n"
"=VAL :a value\n"
"-MAP\n"
"+MAP\n"
"+MAP\n"
"=VAL :another explicit key\n"
"=VAL :its value\n"
"-MAP\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.begin_map_val_block());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain("an explicit key"));
___(ps.set_val_scalar_plain("another value"));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("a simple key"));
___(ps.set_val_scalar_plain("a value"));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_val_block());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain("another explicit key"));
___(ps.set_val_scalar_plain("its value"));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(Qmrk7,
(HAS_CONTAINER_KEYS, Location(5,2,5),
"\n"
"- ? : x\n"
"- ? : \n"
"- ? :\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"+MAP\n"
"+MAP\n"
"=VAL :\n"
"=VAL :x\n"
"-MAP\n"
"=VAL :\n"
"-MAP\n"
"+MAP\n"
"+MAP\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"=VAL :\n"
"-MAP\n"
"+MAP\n"
"+MAP\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.begin_map_val_block());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain("x"));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_val_block());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_val_block());
___(ps.begin_map_key_block());
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkWithTags,
(HAS_CONTAINER_KEYS, Location(18,3,6),
"a1: b1\n"
"? !at\n"
" !bt : b2\n"
": c3\n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"=VAL :a1\n"
"=VAL :b1\n"
"+MAP <!at>\n"
"=VAL <!bt> :\n"
"=VAL :b2\n"
"-MAP\n"
"=VAL :c3\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("a1"));
___(ps.set_val_scalar_plain("b1"));
___(ps.add_sibling());
___(ps.set_key_tag("!at"));
___(ps.begin_map_key_block());
___(ps.set_key_tag("!bt"));
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain("b2"));
___(ps.end_map());
___(ps.set_val_scalar_plain("c3"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
//-----------------------------------------------------------------------------
ENGINE_TEST(QmrkFlow0,
("{ ? }", "{: }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1,
("{ ? , }", "{: }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1Anch,
("{ ? &anch , }", "{&anch : }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL &anch :\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_anchor("anch"));
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1Tag,
("{ ? !tag , }", "{!tag : }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL <!tag> :\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_tag("!tag"));
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1Squo,
("{ ? 'squo', }", "{'squo': }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL 'squo\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_squoted("squo"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1AnchSquo,
("{ ? &anch 'squo', }", "{&anch 'squo': }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL &anch 'squo\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_anchor("anch"));
___(ps.set_key_scalar_squoted("squo"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1TagSquo,
("{ ? !tag 'squo', }", "{!tag 'squo': }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL <!tag> 'squo\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_tag("!tag"));
___(ps.set_key_scalar_squoted("squo"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1Dquo,
("{ ? \"dquo\", }", "{\"dquo\": }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL \"dquo\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_dquoted("dquo"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1AnchDquo,
("{ ? &anch \"dquo\", }", "{&anch \"dquo\": }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL &anch \"dquo\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_anchor("anch"));
___(ps.set_key_scalar_dquoted("dquo"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1TagDquo,
("{ ? !tag \"dquo\", }", "{!tag \"dquo\": }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=VAL <!tag> \"dquo\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_tag("!tag"));
___(ps.set_key_scalar_dquoted("dquo"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1Ref,
("{ ? *ref , }", "{*ref : }"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"=ALI *ref\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_ref("*ref"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1Seq,
(HAS_CONTAINER_KEYS,
"{ ? [a, b]: c , }", "{? [a, b] : c}"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"+SEQ []\n"
"=VAL :a\n"
"=VAL :b\n"
"-SEQ\n"
"=VAL :c\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.begin_seq_key_flow());
___(ps.set_val_scalar_plain("a"));
___(ps.set_val_scalar_plain("b"));
___(ps.end_seq());
___(ps.set_val_scalar_plain("c"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1SeqAnchor,
(HAS_CONTAINER_KEYS,
"{ ? &anchor [a, b]: c , }", "{? &anchor [a, b] : c}"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"+SEQ [] &anchor\n"
"=VAL :a\n"
"=VAL :b\n"
"-SEQ\n"
"=VAL :c\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_anchor("anchor"));
___(ps.begin_seq_key_flow());
___(ps.set_val_scalar_plain("a"));
___(ps.set_val_scalar_plain("b"));
___(ps.end_seq());
___(ps.set_val_scalar_plain("c"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1SeqTag,
(HAS_CONTAINER_KEYS,
"{ ? !tag [a, b]: c , }", "{? !tag [a, b] : c}"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"+SEQ [] <!tag>\n"
"=VAL :a\n"
"=VAL :b\n"
"-SEQ\n"
"=VAL :c\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_tag("!tag"));
___(ps.begin_seq_key_flow());
___(ps.set_val_scalar_plain("a"));
___(ps.set_val_scalar_plain("b"));
___(ps.end_seq());
___(ps.set_val_scalar_plain("c"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1Map,
(HAS_CONTAINER_KEYS,
"{ ? {a: b}: c , }", "{? {a: b} : c}"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"+MAP {}\n"
"=VAL :a\n"
"=VAL :b\n"
"-MAP\n"
"=VAL :c\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.begin_map_key_flow());
___(ps.set_key_scalar_plain("a"));
___(ps.set_val_scalar_plain("b"));
___(ps.end_map());
___(ps.set_val_scalar_plain("c"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1MapAnchor,
(HAS_CONTAINER_KEYS,
"{ ? &anchor {a: b}: c , }", "{? &anchor {a: b} : c}"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"+MAP {} &anchor\n"
"=VAL :a\n"
"=VAL :b\n"
"-MAP\n"
"=VAL :c\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_anchor("anchor"));
___(ps.begin_map_key_flow());
___(ps.set_key_scalar_plain("a"));
___(ps.set_val_scalar_plain("b"));
___(ps.end_map());
___(ps.set_val_scalar_plain("c"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(QmrkFlow1MapTag,
(HAS_CONTAINER_KEYS,
"{ ? !tag {a: b}: c , }", "{? !tag {a: b} : c}"),
"+STR\n"
"+DOC\n"
"+MAP {}\n"
"+MAP {} <!tag>\n"
"=VAL :a\n"
"=VAL :b\n"
"-MAP\n"
"=VAL :c\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_flow());
___(ps.set_key_tag("!tag"));
___(ps.begin_map_key_flow());
___(ps.set_key_scalar_plain("a"));
___(ps.set_val_scalar_plain("b"));
___(ps.end_map());
___(ps.set_val_scalar_plain("c"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
} // namespace yml
} // namespace c4
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// this is needed to use the test case library
#ifndef RYML_SINGLE_HEADER
#include "c4/substr.hpp"
#endif
namespace c4 {
namespace yml {
struct Case;
Case const* get_case(csubstr /*name*/)
{
return nullptr;
}
} // namespace yml
} // namespace c4

858
test/test_parse_engine_7_seqimap.cpp Normal file
View File

@@ -0,0 +1,858 @@
#include "./test_lib/test_engine.hpp"
// WARNING: don't use raw string literals -- g++4.8 cannot accept them
// as macro arguments
namespace c4 {
namespace yml {
//-----------------------------------------------------------------------------
ENGINE_TEST(SeqIMap0Ref,
("[val0,val1,{key: val2},wtf]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :val0\n"
"=VAL :val1\n"
"+MAP {}\n"
"=VAL :key\n"
"=VAL :val2\n"
"-MAP\n"
"=VAL :wtf\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("val1"));
___(ps.add_sibling());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("key"));
___(ps.set_val_scalar_plain("val2"));
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_val_scalar_plain("wtf"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap1,
("[val0,val1,key: val2,wtf]", "[val0,val1,{key: val2},wtf]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :val0\n"
"=VAL :val1\n"
"+MAP {}\n"
"=VAL :key\n"
"=VAL :val2\n"
"-MAP\n"
"=VAL :wtf\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("val1"));
___(ps.add_sibling());
// first this is read as a val because the parent is read as a
// seq...
___(ps.set_val_scalar_plain("key"));
// ... then this will create a flow map, and move the existing
// val to the key of the first child
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain("val2"));
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_val_scalar_plain("wtf"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap2,
("[val0,val1,key: [foo: bar],wtf]", "[val0,val1,{key: [{foo: bar}]},wtf]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :val0\n"
"=VAL :val1\n"
"+MAP {}\n"
"=VAL :key\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :foo\n"
"=VAL :bar\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"=VAL :wtf\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("val1"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("key"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("foo"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain("bar"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_val_scalar_plain("wtf"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap2Nested,
("[val: [0: [1: [2: [3: [4: [5: [6: 7]]]]]]], :]",
"[{val: [{0: [{1: [{2: [{3: [{4: [{5: [{6: 7}]}]}]}]}]}]}]},{: }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :val\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :0\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :1\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :2\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :3\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :4\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :5\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :6\n"
"=VAL :7\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"+MAP {}\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("0"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("1"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("2"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("3"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("4"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("5"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("6"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain("7"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_val_scalar_plain({}));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap3EmptyKey,
("[val0, : wtf]", "[val0,{: wtf}]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :val0\n"
"+MAP {}\n"
"=VAL :\n"
"=VAL :wtf\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain({}));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain("wtf"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap3EmptyVal,
("[val0, wtf: ]", "[val0,{wtf: }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :val0\n"
"+MAP {}\n"
"=VAL :wtf\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("wtf"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap3EmptyKeyVal,
("[val0, : ]", "[val0,{: }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :val0\n"
"+MAP {}\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain({}));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap3EmptyKeyValNested,
("[val0: val1, : ]", "[{val0: val1},{: }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :val0\n"
"=VAL :val1\n"
"-MAP\n"
"+MAP {}\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain("val1"));
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_val_scalar_plain({}));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap3EmptyKeyValNested2,
("[val0: [val1: val2], : ]", "[{val0: [{val1: val2}]},{: }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :val0\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :val1\n"
"=VAL :val2\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"+MAP {}\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val1"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain("val2"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_val_scalar_plain({}));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap4Ref,
("[val0,val1,[rat,rot],wtf]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :val0\n"
"=VAL :val1\n"
"+SEQ []\n"
"=VAL :rat\n"
"=VAL :rot\n"
"-SEQ\n"
"=VAL :wtf\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("val1"));
___(ps.add_sibling());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("rat"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("rot"));
___(ps.end_seq());
___(ps.add_sibling());
___(ps.set_val_scalar_plain("wtf"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap4,
(HAS_CONTAINER_KEYS, Location(20,1,21), "[val0,val1,[rat,rot]: [foo: bar],wtf]", "[val0,val1,{[rat,rot]: [{foo: bar}]},wtf]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :val0\n"
"=VAL :val1\n"
"+MAP {}\n"
"+SEQ []\n"
"=VAL :rat\n"
"=VAL :rot\n"
"-SEQ\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :foo\n"
"=VAL :bar\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"=VAL :wtf\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("val1"));
___(ps.add_sibling());
___(ps.begin_map_val_flow());
___(ps.begin_seq_key_flow());
___(ps.set_val_scalar_plain("rat"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("rot"));
___(ps.end_seq());
___(ps.begin_seq_val_flow());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("foo"));
___(ps.set_val_scalar_plain("bar"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_val_scalar_plain("wtf"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap4_actually,
(HAS_CONTAINER_KEYS, Location(20,1,21), "[val0,val1,[rat,rot]: [foo: bar],wtf]", "[val0,val1,{[rat,rot]: [{foo: bar}]},wtf]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :val0\n"
"=VAL :val1\n"
"+MAP {}\n"
"+SEQ []\n"
"=VAL :rat\n"
"=VAL :rot\n"
"-SEQ\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :foo\n"
"=VAL :bar\n"
"-MAP\n"
"-SEQ\n"
"-MAP\n"
"=VAL :wtf\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("val0"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("val1"));
___(ps.add_sibling());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("rat"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("rot"));
___(ps.end_seq());
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("foo"));
___(ps.actually_val_is_first_key_of_new_map_flow());
___(ps.set_val_scalar_plain("bar"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_val_scalar_plain("wtf"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
//-----------------------------------------------------------------------------
ENGINE_TEST(SeqIMap5Squo,
("[a: &anchor 'b']", "[{a: &anchor 'b'}]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :a\n"
"=VAL &anchor 'b\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("a"));
___(ps.set_val_anchor("anchor"));
___(ps.set_val_scalar_squoted("b"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap5Dquo,
("[a: &anchor \"b\"]", "[{a: &anchor \"b\"}]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :a\n"
"=VAL &anchor \"b\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("a"));
___(ps.set_val_anchor("anchor"));
___(ps.set_val_scalar_dquoted("b"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap5Ref,
("[a: *ref]", "[{a: *ref}]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :a\n"
"=ALI *ref\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("a"));
___(ps.set_val_ref("*ref"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap5QmrkNone0,
("[? ,]", "[{: }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap5QmrkNone1,
("[? ]", "[{: }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain({}));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap5QmrkSquo1,
("[? &anchor 'squo' ]", "[{&anchor 'squo': }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL &anchor 'squo\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_key_tag("!tag"));
___(ps.begin_map_val_flow());
___(ps.set_key_anchor("anchor"));
___(ps.set_key_scalar_squoted("squo"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap5QmrkDquo1,
("[? &anchor \"dquo\" ]", "[{&anchor \"dquo\": }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL &anchor \"dquo\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_key_tag("!tag"));
___(ps.begin_map_val_flow());
___(ps.set_key_anchor("anchor"));
___(ps.set_key_scalar_dquoted("dquo"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap5QmrkRef1,
("[? a: *ref]", "[{a: *ref}]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=VAL :a\n"
"=ALI *ref\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("a"));
___(ps.set_val_ref("*ref"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap5QmrkRef2,
("[? *ref: b]", "[{*ref : b}]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"=ALI *ref\n"
"=VAL :b\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.begin_map_val_flow());
___(ps.set_key_ref("*ref"));
___(ps.set_val_scalar_plain("b"));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap5QmrkSeq,
(HAS_CONTAINER_KEYS,
"[? &anchor [a, seq]: ]", "[{&anchor [a, seq]: }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"+SEQ [] &anchor\n"
"=VAL :a\n"
"=VAL :seq\n"
"-SEQ\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_key_tag("!tag"));
___(ps.begin_map_val_flow());
___(ps.set_key_anchor("anchor"));
___(ps.begin_seq_key_flow());
___(ps.set_val_scalar_plain("a"));
___(ps.set_val_scalar_plain("seq"));
___(ps.end_seq());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(SeqIMap5QmrkMap,
(HAS_CONTAINER_KEYS,
"[? &anchor {a: map}: ]", "[{&anchor {a: map}: }]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"+MAP {}\n"
"+MAP {} &anchor\n"
"=VAL :a\n"
"=VAL :map\n"
"-MAP\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_key_tag("!tag"));
___(ps.begin_map_val_flow());
___(ps.set_key_anchor("anchor"));
___(ps.begin_map_key_flow());
___(ps.set_key_scalar_plain("a"));
___(ps.set_val_scalar_plain("map"));
___(ps.end_map());
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
} // namespace yml
} // namespace c4
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// this is needed to use the test case library
#ifndef RYML_SINGLE_HEADER
#include "c4/substr.hpp"
#endif
namespace c4 {
namespace yml {
struct Case;
Case const* get_case(csubstr /*name*/)
{
return nullptr;
}
} // namespace yml
} // namespace c4

493
test/test_parse_engine_8_scalars_tokens.cpp Normal file
View File

@@ -0,0 +1,493 @@
#include "./test_lib/test_engine.hpp"
// WARNING: don't use raw string literals -- g++4.8 cannot accept them
// as macro arguments
namespace c4 {
namespace yml {
//-----------------------------------------------------------------------------
ENGINE_TEST(PlainScalarWithColon0,
("a::\n", "a:: \n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"=VAL :a:\n"
"=VAL :\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("a:"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(PlainScalarWithColon1,
("key ends with two colons::: value\n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"=VAL :key ends with two colons::\n"
"=VAL :value\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("key ends with two colons::"));
___(ps.set_val_scalar_plain("value"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(PlainScalarWithColonSeq,
("- ::\n"
"- x::\n"
"- :x::\n",
"- :: \n"
"- x:: \n"
"- :x:: \n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"+MAP\n"
"=VAL ::\n"
"=VAL :\n"
"-MAP\n"
"+MAP\n"
"=VAL :x:\n"
"=VAL :\n"
"-MAP\n"
"+MAP\n"
"=VAL ::x:\n"
"=VAL :\n"
"-MAP\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain(":"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("x:"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.add_sibling());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain(":x:"));
___(ps.set_val_scalar_plain({}));
___(ps.end_map());
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
//-----------------------------------------------------------------------------
ENGINE_TEST(BlockPlainScalarCommaDoc,
("a, b\n"),
"+STR\n"
"+DOC\n"
"=VAL :a, b\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.set_val_scalar_plain("a, b"));
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(BlockPlainScalarCommaMap,
("a, b: c, d\n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"=VAL :a, b\n"
"=VAL :c, d\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("a, b"));
___(ps.set_val_scalar_plain("c, d"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(BlockPlainScalarCommaSeq,
("- a, b\n- c, d\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL :a, b\n"
"=VAL :c, d\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.set_val_scalar_plain("a, b"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("c, d"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
//-----------------------------------------------------------------------------
ENGINE_TEST_ERRLOC(tokens_after_mapflow_0_0, Location( 1,32), "{ first: Sammy, last: Sosa }foo")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_0_1, Location( 2, 4), "{ first: Sammy, last: Sosa }\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_2_0, Location( 1,29), "{ first: Sammy, last: Sosa }- foo")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_2_1, Location( 2, 1), "{ first: Sammy, last: Sosa }\n- foo")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_3_0, Location( 1,29), "{ first: Sammy, last: Sosa }[foo,bar]")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_3_1, Location( 2, 1), "{ first: Sammy, last: Sosa }\n[foo,bar]")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_4_0, Location( 1,29), "{ first: Sammy, last: Sosa }{foo: bar}")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_4_1, Location( 2, 1), "{ first: Sammy, last: Sosa }\n{foo: bar}")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_5_0, Location( 1,29), "{ first: Sammy, last: Sosa }'foo'")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_5_1, Location( 2, 1), "{ first: Sammy, last: Sosa }\n'foo'")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_6_0, Location( 1,29), "{ first: Sammy, last: Sosa }|\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_6_1, Location( 2, 1), "{ first: Sammy, last: Sosa }\n|\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_7_0, Location( 1,29), "{ first: Sammy, last: Sosa }>\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_7_1, Location( 2, 1), "{ first: Sammy, last: Sosa }\n>\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_8_0, Location( 1,33), "{ first: Sammy, last: Sosa }?foo")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_8_1, Location( 2, 1), "{ first: Sammy, last: Sosa }\n?\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_mapflow_9_0, Location( 1,33), "{ first: Sammy, last: Sosa }:foo")
//ENGINE_TEST_ERRLOC(tokens_after_mapflow_9_1, Location( 2, 1), "{ first: Sammy, last: Sosa }\n:\nfoo")//fixme
//ENGINE_TEST_ERRLOC(tokens_after_mapflow_10_0, Location( 1,29), "{ first: Sammy, last: Sosa }: foo")// fixme
//ENGINE_TEST_ERRLOC(tokens_after_mapflow_10_1, Location( 2, 1), "{ first: Sammy, last: Sosa }\n: \nfoo")//fixme
ENGINE_TEST_ERRLOC(tokens_after_mapflow_11_0, Location( 1,34), "{ first: Sammy, last: Sosa } &foo")// fixme
ENGINE_TEST_ERRLOC(tokens_after_mapflow_11_1, Location( 2, 5), "{ first: Sammy, last: Sosa }\n&foo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_0_0, Location(1,32), "[a,b,c, d]foo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_0_1, Location(2, 4), "[a,b,c, d]\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_2_0, Location(1,29), "[a,b,c, d]- foo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_2_1, Location(2, 1), "[a,b,c, d]\n- foo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_3_0, Location(1,29), "[a,b,c, d][foo,bar]")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_3_1, Location(2, 1), "[a,b,c, d]\n[foo,bar]")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_4_0, Location(1,29), "[a,b,c, d]{foo: bar}")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_4_1, Location(2, 1), "[a,b,c, d]\n{foo: bar}")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_5_0, Location(1,29), "[a,b,c, d]'foo'")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_5_1, Location(2, 1), "[a,b,c, d]\n'foo'")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_6_0, Location(1,29), "[a,b,c, d]|\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_6_1, Location(2, 1), "[a,b,c, d]\n|\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_7_0, Location(1,29), "[a,b,c, d]>\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_7_1, Location(2, 1), "[a,b,c, d]\n>\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_8_0, Location(1,33), "[a,b,c, d]?foo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_8_1, Location(2, 1), "[a,b,c, d]\n?\nfoo")
ENGINE_TEST_ERRLOC(tokens_after_seqflow_9_0, Location(1,33), "[a,b,c, d]:foo")// fixme
//ENGINE_TEST_ERRLOC(tokens_after_seqflow_9_1, Location(2, 1), "[a,b,c, d]\n:\nfoo")//fixme
//ENGINE_TEST_ERRLOC(tokens_after_seqflow_10_0, Location(1,29), "[a,b,c, d]: foo")// fixme
//ENGINE_TEST_ERRLOC(tokens_after_seqflow_10_1, Location(2, 1), "[a,b,c, d]\n: \nfoo")//fixme
ENGINE_TEST_ERRLOC(tokens_after_seqflow_11_0, Location(1,34), "[a,b,c, d] &foo")// fixme
ENGINE_TEST_ERRLOC(tokens_after_seqflow_11_1, Location(2, 5), "[a,b,c, d]\n&foo")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq1, Location(1, 9), "[a,b,c]]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq2, Location(1, 9), "[a,b,c]}")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq3, Location(1, 8), "[a,b,c]{")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq4, Location(1, 8), "[a,b,c][")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq5, Location(1, 8), "[a,b,c]-")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq1_0, Location(1,10), "[a,b,c] ]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq2_0, Location(1,10), "[a,b,c] }")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq3_0, Location(1,9), "[a,b,c] {")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq4_0, Location(1,9), "[a,b,c] [")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq5_0, Location(1,9), "[a,b,c] -")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq1_1, Location(2,2), "[a,b,c]\n]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq2_1, Location(2,2), "[a,b,c]\n}")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq3_1, Location(2,1), "[a,b,c]\n{")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq4_1, Location(2,1), "[a,b,c]\n[")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Seq5_1, Location(2,1), "[a,b,c]\n-")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map1, Location(1, 8), "{a: b}]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map2, Location(1, 8), "{a: b}}")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map3, Location(1, 7), "{a: b}{")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map4, Location(1, 7), "{a: b}[")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map5, Location(1, 7), "{a: b}-")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map1_0, Location(1,9), "{a: b} ]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map2_0, Location(1,9), "{a: b} }")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map3_0, Location(1,8), "{a: b} {")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map4_0, Location(1,8), "{a: b} [")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map5_0, Location(1,8), "{a: b} -")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map1_1, Location(2,2), "{a: b}\n]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map2_1, Location(2,2), "{a: b}\n}")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map3_1, Location(2,1), "{a: b}\n{")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map4_1, Location(2,1), "{a: b}\n[")
ENGINE_TEST_ERRLOC(ExtraTokensFlow1Map5_1, Location(2,1), "{a: b}\n-")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq1, Location(2, 9), "---\n[a,b,c]]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq2, Location(2, 9), "---\n[a,b,c]}")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq3, Location(2, 8), "---\n[a,b,c]{")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq4, Location(2, 8), "---\n[a,b,c][")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq5, Location(2, 8), "---\n[a,b,c]-")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq1_0, Location(2,10), "---\n[a,b,c] ]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq2_0, Location(2,10), "---\n[a,b,c] }")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq3_0, Location(2,9), "---\n[a,b,c] {")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq4_0, Location(2,9), "---\n[a,b,c] [")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq5_0, Location(2,9), "---\n[a,b,c] -")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq1_1, Location(3,2), "---\n[a,b,c]\n]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq2_1, Location(3,2), "---\n[a,b,c]\n}")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq3_1, Location(3,1), "---\n[a,b,c]\n{")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq4_1, Location(3,1), "---\n[a,b,c]\n[")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Seq5_1, Location(3,1), "---\n[a,b,c]\n-")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map1, Location(2, 8), "---\n{a: b}]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map2, Location(2, 8), "---\n{a: b}}")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map3, Location(2, 7), "---\n{a: b}{")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map4, Location(2, 7), "---\n{a: b}[")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map5, Location(2, 7), "---\n{a: b}-")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map1_0, Location(2,9), "---\n{a: b} ]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map2_0, Location(2,9), "---\n{a: b} }")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map3_0, Location(2,8), "---\n{a: b} {")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map4_0, Location(2,8), "---\n{a: b} [")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map5_0, Location(2,8), "---\n{a: b} -")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map1_1, Location(3,2), "---\n{a: b}\n]")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map2_1, Location(3,2), "---\n{a: b}\n}")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map3_1, Location(3,1), "---\n{a: b}\n{")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map4_1, Location(3,1), "---\n{a: b}\n[")
ENGINE_TEST_ERRLOC(ExtraTokensFlow2Map5_1, Location(3,1), "---\n{a: b}\n-")
ENGINE_TEST_ERRLOC(ExtraTokensScalar0, Location(2,6), "word1 # comment\nword2")
ENGINE_TEST(ExtraTokensNoFalseError0,
("---\n"
"map : {foo: bar, notag: none}\n"
"seq : [foo, bar]\n"
"...\n",
"---\n"
"map: {foo: bar,notag: none}\n"
"seq: [foo,bar]\n"),
"+STR\n"
"+DOC ---\n"
"+MAP\n"
"=VAL :map\n"
"+MAP {}\n"
"=VAL :foo\n"
"=VAL :bar\n"
"=VAL :notag\n"
"=VAL :none\n"
"-MAP\n"
"=VAL :seq\n"
"+SEQ []\n"
"=VAL :foo\n"
"=VAL :bar\n"
"-SEQ\n"
"-MAP\n"
"-DOC ...\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc_expl());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("map"));
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("foo"));
___(ps.set_val_scalar_plain("bar"));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("notag"));
___(ps.set_val_scalar_plain("none"));
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_key_scalar_plain("seq"));
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("foo"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar"));
___(ps.end_seq());
___(ps.end_map());
___(ps.end_doc_expl());
___(ps.end_stream());
}
ENGINE_TEST(ExtraTokensNoFalseError1,
("---\n"
"*mapref : {foo: bar, notag: none}\n"
"*seqref : [foo, bar]\n"
"...\n",
"---\n"
"*mapref : {foo: bar,notag: none}\n"
"*seqref : [foo,bar]\n"),
"+STR\n"
"+DOC ---\n"
"+MAP\n"
"=ALI *mapref\n"
"+MAP {}\n"
"=VAL :foo\n"
"=VAL :bar\n"
"=VAL :notag\n"
"=VAL :none\n"
"-MAP\n"
"=ALI *seqref\n"
"+SEQ []\n"
"=VAL :foo\n"
"=VAL :bar\n"
"-SEQ\n"
"-MAP\n"
"-DOC ...\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc_expl());
___(ps.begin_map_val_block());
___(ps.set_key_ref("*mapref"));
___(ps.begin_map_val_flow());
___(ps.set_key_scalar_plain("foo"));
___(ps.set_val_scalar_plain("bar"));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("notag"));
___(ps.set_val_scalar_plain("none"));
___(ps.end_map());
___(ps.add_sibling());
___(ps.set_key_ref("*seqref"));
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("foo"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("bar"));
___(ps.end_seq());
___(ps.end_map());
___(ps.end_doc_expl());
___(ps.end_stream());
}
//-----------------------------------------------------------------------------
ENGINE_TEST(PlainScalarDoc0,
("a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~",
"a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\n"),
"+STR\n"
"+DOC\n"
"=VAL :a!\"#$%&'()*+,-./09:;<=>?@AZ[\\\\]^_`az{|}~\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.set_val_scalar_plain("a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~"));
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(PlainScalarBlockSeq0,
("- a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~",
"- a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\n"),
"+STR\n"
"+DOC\n"
"+SEQ\n"
"=VAL :a!\"#$%&'()*+,-./09:;<=>?@AZ[\\\\]^_`az{|}~\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_block());
___(ps.set_val_scalar_plain("a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST(PlainScalarBlockMap0,
("key: a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\n"
"a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~: val\n"),
"+STR\n"
"+DOC\n"
"+MAP\n"
"=VAL :key\n"
"=VAL :a!\"#$%&'()*+,-./09:;<=>?@AZ[\\\\]^_`az{|}~\n"
"=VAL :a!\"#$%&'()*+,-./09:;<=>?@AZ[\\\\]^_`az{|}~\n"
"=VAL :val\n"
"-MAP\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_map_val_block());
___(ps.set_key_scalar_plain("key"));
___(ps.set_val_scalar_plain("a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~"));
___(ps.add_sibling());
___(ps.set_key_scalar_plain("a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~"));
___(ps.set_val_scalar_plain("val"));
___(ps.end_map());
___(ps.end_doc());
___(ps.end_stream());
}
ENGINE_TEST_ERRLOC(PlainScalarFlow0Seq0_0, Location(1,29), "[a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~]")
ENGINE_TEST_ERRLOC(PlainScalarFlow0Seq0_1, Location(1,29), "[a!\"#$%&'()*+,-./09:;<=>?@AZ{|}^_`az{|}~]")
ENGINE_TEST_ERRLOC(PlainScalarFlow0Seq1_0, Location(2,28), "[\n"
"a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\n]")
ENGINE_TEST_ERRLOC(PlainScalarFlow0Seq1_1, Location(2,28), "[\n"
"a!\"#$%&'()*+,-./09:;<=>?@AZ{|}^_`az{|}~\n]")
ENGINE_TEST_ERRLOC(PlainScalarFlow1Seq0, Location(1,38), "[a!\"#$%&'()*+,-./09:;<=>?@]^_`az{|}~]")
ENGINE_TEST(PlainScalarFlow0Seq1,
("[\n"
"a!\"#$%&'()*+,-./09:;<=>?@AZ\\\n]",
"[a!\"#$%&'()*+,-./09:;<=>?@AZ\\]"),
"+STR\n"
"+DOC\n"
"+SEQ []\n"
"=VAL :a!\"#$%&'()*+\n"
"=VAL :-./09:;<=>?@AZ\\\\\n"
"-SEQ\n"
"-DOC\n"
"-STR\n")
{
___(ps.begin_stream());
___(ps.begin_doc());
___(ps.begin_seq_val_flow());
___(ps.set_val_scalar_plain("a!\"#$%&'()*+"));
___(ps.add_sibling());
___(ps.set_val_scalar_plain("-./09:;<=>?@AZ\\"));
___(ps.end_seq());
___(ps.end_doc());
___(ps.end_stream());
}
} // namespace yml
} // namespace c4
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// this is needed to use the test case library
#ifndef RYML_SINGLE_HEADER
#include "c4/substr.hpp"
#endif
namespace c4 {
namespace yml {
struct Case;
Case const* get_case(csubstr /*name*/)
{
return nullptr;
}
} // namespace yml
} // namespace c4

2
test/test_suite/test_suite_event_handler.cpp
View File

@@ -13,7 +13,7 @@ namespace yml {
template class ParseEngine<EventHandlerYamlStd>;
inline void EventHandlerYamlStd::EventSink::append_escaped(csubstr val)
void EventHandlerYamlStd::EventSink::append_escaped(csubstr val)
{
#define _c4flush_use_instead(repl, skip) \
do { \

4
test/test_suite/test_suite_event_handler.hpp
View File

@@ -39,9 +39,9 @@ struct EventHandlerYamlStdState : public ParserState
* See the documentation for @ref doc_event_handlers, which has
* important notes about the event model used by rapidyaml.
*
* This classe is used only in the CI of this project, and in the
* This class is used only in the CI of this project, and in the
* application used as part of the [standard YAML
* playground](https://play.yaml.io/main/parser). This is not part of
* playground](https://play.yaml.io/main/parser). It is not part of
* the library and is not installed. *
*/
struct EventHandlerYamlStd : public EventHandlerStack<EventHandlerYamlStd, EventHandlerYamlStdState>