Mirrors/rapidyaml
0
0
Fork 0
mirror of https://github.com/biojppm/rapidyaml.git synced 2026-01-18 13:31:19 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
rapidyaml/test/test_style.cpp
Joao Paulo Magalhaes 27b56e59e5 Implement FLOW_ML style: update tests
2025-12-31 18:23:44 +00:00

774 lines
22 KiB
C++
Raw Permalink Blame History

#ifndef RYML_SINGLE_HEADER
#include "c4/yml/std/std.hpp"
#include "c4/yml/parse.hpp"
#include "c4/yml/emit.hpp"
#include <c4/format.hpp>
#include <c4/yml/detail/checks.hpp>
#include <c4/yml/detail/print.hpp>
#endif
#include "./test_lib/test_case.hpp"
#include <gtest/gtest.h>
namespace c4 {
namespace yml {
std::string emit2str(Tree const& t)
{
return emitrs_yaml<std::string>(t);
}
inline void test_container_nostyle(ConstNodeRef n)
{
EXPECT_FALSE(n.type().is_container_styled());
EXPECT_FALSE(n.type().is_block());
EXPECT_FALSE(n.type().is_flow());
EXPECT_FALSE(n.type().is_flow_sl());
EXPECT_FALSE(n.type().is_flow_ml());
}
inline void test_container_block(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_container_styled());
EXPECT_TRUE(n.type().is_block());
EXPECT_FALSE(n.type().is_flow());
EXPECT_FALSE(n.type().is_flow_sl());
EXPECT_FALSE(n.type().is_flow_ml());
}
inline void test_container_flow_sl(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_container_styled());
EXPECT_FALSE(n.type().is_block());
EXPECT_TRUE(n.type().is_flow());
EXPECT_TRUE(n.type().is_flow_sl());
EXPECT_FALSE(n.type().is_flow_ml());
}
inline void test_container_flow_ml(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_container_styled());
EXPECT_FALSE(n.type().is_block());
EXPECT_TRUE(n.type().is_flow());
EXPECT_FALSE(n.type().is_flow_sl());
EXPECT_TRUE(n.type().is_flow_ml());
}
inline void test_key_plain(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_key_styled());
EXPECT_TRUE(n.type().is_key_plain());
EXPECT_FALSE(n.type().is_key_squo());
EXPECT_FALSE(n.type().is_key_dquo());
EXPECT_FALSE(n.type().is_key_literal());
EXPECT_FALSE(n.type().is_key_folded());
}
inline void test_val_plain(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_val_styled());
EXPECT_TRUE(n.type().is_val_plain());
EXPECT_FALSE(n.type().is_val_squo());
EXPECT_FALSE(n.type().is_val_dquo());
EXPECT_FALSE(n.type().is_val_literal());
EXPECT_FALSE(n.type().is_val_folded());
}
inline void test_key_squo(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_key_styled());
EXPECT_FALSE(n.type().is_key_plain());
EXPECT_TRUE(n.type().is_key_squo());
EXPECT_FALSE(n.type().is_key_dquo());
EXPECT_FALSE(n.type().is_key_literal());
EXPECT_FALSE(n.type().is_key_folded());
}
inline void test_val_squo(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_val_styled());
EXPECT_FALSE(n.type().is_val_plain());
EXPECT_TRUE(n.type().is_val_squo());
EXPECT_FALSE(n.type().is_val_dquo());
EXPECT_FALSE(n.type().is_val_literal());
EXPECT_FALSE(n.type().is_val_folded());
}
inline void test_key_dquo(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_key_styled());
EXPECT_FALSE(n.type().is_key_plain());
EXPECT_FALSE(n.type().is_key_squo());
EXPECT_TRUE(n.type().is_key_dquo());
EXPECT_FALSE(n.type().is_key_literal());
EXPECT_FALSE(n.type().is_key_folded());
}
inline void test_val_dquo(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_val_styled());
EXPECT_FALSE(n.type().is_val_plain());
EXPECT_FALSE(n.type().is_val_squo());
EXPECT_TRUE(n.type().is_val_dquo());
EXPECT_FALSE(n.type().is_val_literal());
EXPECT_FALSE(n.type().is_val_folded());
}
inline void test_key_literal(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_key_styled());
EXPECT_FALSE(n.type().is_key_plain());
EXPECT_FALSE(n.type().is_key_squo());
EXPECT_FALSE(n.type().is_key_dquo());
EXPECT_TRUE(n.type().is_key_literal());
EXPECT_FALSE(n.type().is_key_folded());
}
inline void test_val_literal(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_val_styled());
EXPECT_FALSE(n.type().is_val_plain());
EXPECT_FALSE(n.type().is_val_squo());
EXPECT_FALSE(n.type().is_val_dquo());
EXPECT_TRUE(n.type().is_val_literal());
EXPECT_FALSE(n.type().is_val_folded());
}
inline void test_key_folded(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_key_styled());
EXPECT_FALSE(n.type().is_key_plain());
EXPECT_FALSE(n.type().is_key_squo());
EXPECT_FALSE(n.type().is_key_dquo());
EXPECT_FALSE(n.type().is_key_literal());
EXPECT_TRUE(n.type().is_key_folded());
}
inline void test_val_folded(ConstNodeRef n)
{
EXPECT_TRUE(n.type().is_val_styled());
EXPECT_FALSE(n.type().is_val_plain());
EXPECT_FALSE(n.type().is_val_squo());
EXPECT_FALSE(n.type().is_val_dquo());
EXPECT_FALSE(n.type().is_val_literal());
EXPECT_TRUE(n.type().is_val_folded());
}
inline void test_key_nostyle(ConstNodeRef n)
{
EXPECT_FALSE(n.type().is_key_styled());
EXPECT_FALSE(n.type().is_key_plain());
EXPECT_FALSE(n.type().is_key_squo());
EXPECT_FALSE(n.type().is_key_dquo());
EXPECT_FALSE(n.type().is_key_literal());
EXPECT_FALSE(n.type().is_key_folded());
}
inline void test_val_nostyle(ConstNodeRef n)
{
EXPECT_FALSE(n.type().is_val_styled());
EXPECT_FALSE(n.type().is_val_plain());
EXPECT_FALSE(n.type().is_val_squo());
EXPECT_FALSE(n.type().is_val_dquo());
EXPECT_FALSE(n.type().is_val_literal());
EXPECT_FALSE(n.type().is_val_folded());
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(style, flags)
{
Tree tree = parse_in_arena("foo: bar");
test_container_block(tree.rootref());
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), FLOW_SL);
test_container_flow_sl(tree.rootref());
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), FLOW_ML);
test_container_flow_ml(tree.rootref());
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
csubstr scalar_yaml = R"(
this is the key: >-
this is the multiline
"val" with
'empty' lines
)";
void check_same_emit(Tree const& expected)
{
#ifndef RYML_DBG
#define _showtrees(num)
#else
#define _showtrees(num) \
{ \
std::cout << "--------\nEMITTED" #num "\n--------\n"; \
std::cout << ws ## num; \
std::cout << "--------\nACTUAL" #num "\n--------\n"; \
print_tree(actual ## num); \
std::cout << "--------\nEXPECTED" #num "\n--------\n"; \
print_tree(expected); \
}
#endif
std::string ws1, ws2, ws3, ws4;
emitrs_yaml(expected, &ws1);
{
SCOPED_TRACE("actual1");
Tree actual1 = parse_in_arena(to_csubstr(ws1));
_showtrees(1);
test_compare(actual1, expected);
emitrs_yaml(actual1, &ws2);
}
{
SCOPED_TRACE("actual2");
Tree actual2 = parse_in_arena(to_csubstr(ws2));
_showtrees(2);
test_compare(actual2, expected);
emitrs_yaml(actual2, &ws3);
}
{
SCOPED_TRACE("actual3");
Tree actual3 = parse_in_arena(to_csubstr(ws3));
_showtrees(3);
test_compare(actual3, expected);
emitrs_yaml(actual3, &ws4);
}
{
SCOPED_TRACE("actual4");
Tree actual4 = parse_in_arena(to_csubstr(ws4));
_showtrees(4);
test_compare(actual4, expected);
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(style, noflags)
{
auto setcont = [](NodeRef n, NodeType t){
n |= t;
test_container_nostyle(n);
return n;
};
auto setval = [](NodeRef n, csubstr key, csubstr val){
NodeRef ch = n[key];
ch = val;
test_key_nostyle(ch);
test_val_nostyle(ch);
};
Tree orig = parse_in_arena("{}");
NodeRef r = orig.rootref();
test_container_flow_sl(r);
{
NodeRef n = setcont(r["normal"], MAP);
setval(n, "singleline", "foo");
NodeRef ml = setcont(n["multiline"], MAP);
setval(ml, "____________", "foo");
setval(ml, "____mid_____", "foo\nbar");
setval(ml, "____mid_end1", "foo\nbar\n");
setval(ml, "____mid_end2", "foo\nbar\n\n");
setval(ml, "____mid_end3", "foo\nbar\n\n\n");
setval(ml, "____________", "foo");
setval(ml, "____________", "foo bar");
setval(ml, "________end1", "foo bar\n");
setval(ml, "________end2", "foo bar\n\n");
setval(ml, "________end3", "foo bar\n\n\n");
setval(ml, "beg_________", "\nfoo");
setval(ml, "beg_mid_____", "\nfoo\nbar");
setval(ml, "beg_mid_end1", "\nfoo\nbar\n");
setval(ml, "beg_mid_end2", "\nfoo\nbar\n\n");
setval(ml, "beg_mid_end3", "\nfoo\nbar\n\n\n");
}
{
NodeRef n = setcont(r["leading_ws"], MAP);
{
NodeRef sl = setcont(n["singleline"], MAP);
sl["space"] = " foo";
sl["tab"] = "\tfoo";
sl["space_and_tab0"] = " \tfoo";
sl["space_and_tab1"] = "\t foo";
}
{
NodeRef ml = setcont(n["multiline"], MAP);
ml["beg_________"] = "\n \tfoo";
ml["beg_mid_____"] = "\n \tfoo\nbar";
ml["beg_mid_end1"] = "\n \tfoo\nbar\n";
ml["beg_mid_end2"] = "\n \tfoo\nbar\n\n";
ml["beg_mid_end3"] = "\n \tfoo\nbar\n\n\n";
}
}
std::string emitted = emit2str(orig);
const Tree parsed = parse_in_place(to_substr(emitted));
_c4dbg_tree("original", orig);
_c4dbg_tree("parsed", parsed);
test_compare(parsed, orig);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(style, scalar_retains_style_after_parse__plain)
{
const Tree t = parse_in_arena("foo");
test_val_plain(t.rootref());
EXPECT_EQ(emitrs_yaml<std::string>(t), std::string("foo\n"));
}
TEST(style, scalar_retains_style_after_parse__squo)
{
const Tree t = parse_in_arena("'foo'");
test_val_squo(t.rootref());
EXPECT_EQ(emitrs_yaml<std::string>(t), std::string("'foo'\n"));
}
TEST(style, scalar_retains_style_after_parse__dquo)
{
const Tree t = parse_in_arena("\"foo\"");
test_val_dquo(t.rootref());
EXPECT_EQ(emitrs_yaml<std::string>(t), std::string("\"foo\"\n"));
}
TEST(style, scalar_retains_style_after_parse__literal)
{
const Tree t = parse_in_arena("|\n foo");
test_val_literal(t.rootref());
EXPECT_EQ(emitrs_yaml<std::string>(t), std::string("|\n foo\n"));
}
TEST(style, scalar_retains_style_after_parse__folded)
{
const Tree t = parse_in_arena(">\n foo");
test_val_folded(t.rootref());
EXPECT_EQ(emitrs_yaml<std::string>(t), std::string(">\n foo\n"));
}
TEST(style, scalar_retains_style_after_parse__mixed)
{
std::string yaml = "- foo\n- 'baz'\n- \"bat\"\n- |\n baq\n- >\n bax\n";
const Tree t = parse_in_arena(to_csubstr(yaml));
test_container_block(t.rootref());
test_val_plain(t[0]);
test_val_squo(t[1]);
test_val_dquo(t[2]);
test_val_literal(t[3]);
test_val_folded(t[4]);
EXPECT_EQ(emitrs_yaml<std::string>(t), yaml);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(scalar, base)
{
const Tree tree = parse_in_arena(scalar_yaml);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
EXPECT_EQ(tree[0].key(), csubstr("this is the key"));
EXPECT_EQ(tree[0].val(), csubstr("this is the multiline \"val\" with\n'empty' lines"));
EXPECT_EQ(emit2str(tree), R"(this is the key: >-
this is the multiline "val" with
'empty' lines
)");
check_same_emit(tree);
}
//-----------------------------------------------------------------------------
TEST(scalar, block_literal__key)
{
Tree tree = parse_in_arena(scalar_yaml);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
tree._rem_flags(tree[0].id(), KEY_STYLE);
tree._add_flags(tree[0].id(), KEY_LITERAL);
test_key_literal(tree[0]);
test_val_folded(tree[0]);
EXPECT_EQ(emit2str(tree), R"(? |-
this is the key
: >-
this is the multiline "val" with
'empty' lines
)");
check_same_emit(tree);
}
TEST(scalar, block_literal__val)
{
Tree tree = parse_in_arena(scalar_yaml);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
tree._rem_flags(tree[0].id(), VAL_STYLE);
tree._add_flags(tree[0].id(), VAL_LITERAL);
test_key_plain(tree[0]);
test_val_literal(tree[0]);
EXPECT_EQ(emit2str(tree), R"(this is the key: |-
this is the multiline "val" with
'empty' lines
)");
check_same_emit(tree);
}
TEST(scalar, block_literal__key_val)
{
Tree tree = parse_in_arena(scalar_yaml);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
tree._rem_flags(tree[0].id(), KEY_STYLE|VAL_STYLE);
tree._add_flags(tree[0].id(), KEY_LITERAL|VAL_LITERAL);
test_key_literal(tree[0]);
test_val_literal(tree[0]);
EXPECT_EQ(emit2str(tree), R"(? |-
this is the key
: |-
this is the multiline "val" with
'empty' lines
)");
check_same_emit(tree);
}
//-----------------------------------------------------------------------------
TEST(scalar, block_folded__key)
{
Tree tree = parse_in_arena(scalar_yaml);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
tree._rem_flags(tree[0].id(), KEY_STYLE);
tree._add_flags(tree[0].id(), KEY_FOLDED);
test_key_folded(tree[0]);
test_val_folded(tree[0]);
EXPECT_EQ(emit2str(tree), R"(? >-
this is the key
: >-
this is the multiline "val" with
'empty' lines
)");
check_same_emit(tree);
}
TEST(scalar, block_folded__val)
{
Tree tree = parse_in_arena(scalar_yaml);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
tree._rem_flags(tree[0].id(), VAL_STYLE);
tree._add_flags(tree[0].id(), VAL_FOLDED);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
EXPECT_EQ(emit2str(tree), R"(this is the key: >-
this is the multiline "val" with
'empty' lines
)");
check_same_emit(tree);
}
TEST(scalar, block_folded__key_val)
{
Tree tree = parse_in_arena(scalar_yaml);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
tree._rem_flags(tree[0].id(), KEY_STYLE|VAL_STYLE);
tree._add_flags(tree[0].id(), KEY_FOLDED|VAL_FOLDED);
test_key_folded(tree[0]);
test_val_folded(tree[0]);
EXPECT_EQ(emit2str(tree), R"(? >-
this is the key
: >-
this is the multiline "val" with
'empty' lines
)");
check_same_emit(tree);
}
//-----------------------------------------------------------------------------
TEST(scalar, squo__key)
{
Tree tree = parse_in_arena(scalar_yaml);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
tree._rem_flags(tree[0].id(), KEY_STYLE);
tree._add_flags(tree[0].id(), KEY_SQUO);
test_key_squo(tree[0]);
test_val_folded(tree[0]);
EXPECT_EQ(emit2str(tree), R"('this is the key': >-
this is the multiline "val" with
'empty' lines
)");
check_same_emit(tree);
}
TEST(scalar, squo__val)
{
Tree tree = parse_in_arena(scalar_yaml);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
tree._rem_flags(tree[0].id(), VAL_STYLE);
tree._add_flags(tree[0].id(), VAL_SQUO);
test_key_plain(tree[0]);
test_val_squo(tree[0]);
EXPECT_EQ(emit2str(tree), R"(this is the key: 'this is the multiline "val" with
''empty'' lines'
)");
check_same_emit(tree);
}
TEST(scalar, squo__key_val)
{
Tree tree = parse_in_arena(scalar_yaml);
test_key_plain(tree[0]);
test_val_folded(tree[0]);
tree._rem_flags(tree[0].id(), KEY_STYLE|VAL_STYLE);
tree._add_flags(tree[0].id(), KEY_SQUO|VAL_SQUO);
test_key_squo(tree[0]);
test_val_squo(tree[0]);
EXPECT_EQ(emit2str(tree), R"('this is the key': 'this is the multiline "val" with
''empty'' lines'
)");
check_same_emit(tree);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(stream, block)
{
Tree tree = parse_in_arena(R"(
---
scalar
%YAML 1.2
---
foo
---
bar
)");
EXPECT_TRUE(tree.rootref().is_stream());
EXPECT_TRUE(tree.docref(0).is_doc());
EXPECT_TRUE(tree.docref(0).is_val());
EXPECT_EQ(emit2str(tree), "--- scalar %YAML 1.2\n--- foo\n--- bar\n");
tree._add_flags(tree.root_id(), FLOW_SL);
EXPECT_EQ(emit2str(tree), "--- scalar %YAML 1.2\n--- foo\n--- bar\n");
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(seq, block)
{
Tree tree = parse_in_arena("[1, 2, 3, 4, 5, 6]");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), BLOCK);
EXPECT_EQ(emit2str(tree), R"(- 1
- 2
- 3
- 4
- 5
- 6
)");
}
TEST(seq, flow_sl)
{
Tree tree = parse_in_arena("[1, 2, 3, 4, 5, 6]");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), FLOW_SL);
EXPECT_EQ(emit2str(tree), R"([1,2,3,4,5,6])");
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(keyseq, block)
{
Tree tree = parse_in_arena("{foo: [1, 2, 3, 4, 5, 6]}");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), BLOCK);
EXPECT_EQ(emit2str(tree), R"(foo: [1,2,3,4,5,6]
)");
tree._rem_flags(tree["foo"].id(), CONTAINER_STYLE);
tree._add_flags(tree["foo"].id(), BLOCK);
EXPECT_EQ(emit2str(tree), R"(foo:
- 1
- 2
- 3
- 4
- 5
- 6
)");
tree = parse_in_arena("{foo: [1, [2, 3], 4, [5, 6]]}");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), BLOCK);
EXPECT_EQ(emit2str(tree), R"(foo: [1,[2,3],4,[5,6]]
)");
tree._rem_flags(tree["foo"].id(), CONTAINER_STYLE);
tree._add_flags(tree["foo"].id(), BLOCK);
EXPECT_EQ(emit2str(tree), R"(foo:
- 1
- [2,3]
- 4
- [5,6]
)");
}
TEST(keyseq, flow_sl)
{
Tree tree = parse_in_arena("foo: [1, 2, 3, 4, 5, 6]");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), FLOW_SL);
EXPECT_EQ(emit2str(tree), R"({foo: [1,2,3,4,5,6]})");
//
tree = parse_in_arena("foo: [1, [2, 3], 4, [5, 6]]");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), FLOW_SL);
EXPECT_EQ(emit2str(tree), R"({foo: [1,[2,3],4,[5,6]]})");
//
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), BLOCK);
tree._rem_flags(tree["foo"].id(), CONTAINER_STYLE);
tree._add_flags(tree["foo"].id(), BLOCK);
tree._add_flags(tree["foo"][1].id(), FLOW_SL);
tree._add_flags(tree["foo"][3].id(), FLOW_SL);
EXPECT_EQ(emit2str(tree), R"(foo:
- 1
- [2,3]
- 4
- [5,6]
)");
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(map, block)
{
Tree tree = parse_in_arena("{1: 10, 2: 10, 3: 10, 4: 10, 5: 10, 6: 10}");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), BLOCK);
EXPECT_EQ(emit2str(tree), R"(1: 10
2: 10
3: 10
4: 10
5: 10
6: 10
)");
}
TEST(map, flow_sl)
{
Tree tree = parse_in_arena(R"(1: 10
2: 10
3: 10
4: 10
5: 10
6: 10
)");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), FLOW_SL);
EXPECT_EQ(emit2str(tree), R"({1: 10,2: 10,3: 10,4: 10,5: 10,6: 10})");
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(keymap, block)
{
Tree tree = parse_in_arena("{foo: {1: 10, 2: 10, 3: 10, 4: 10, 5: 10, 6: 10}}");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), BLOCK);
tree._rem_flags(tree["foo"].id(), CONTAINER_STYLE);
tree._add_flags(tree["foo"].id(), BLOCK);
EXPECT_EQ(emit2str(tree), R"(foo:
1: 10
2: 10
3: 10
4: 10
5: 10
6: 10
)");
}
TEST(keymap, flow_sl)
{
Tree tree = parse_in_arena(R"(foo:
1: 10
2: 10
3: 10
4: 10
5: 10
6: 10
)");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), FLOW_SL);
EXPECT_EQ(emit2str(tree), R"({foo: {1: 10,2: 10,3: 10,4: 10,5: 10,6: 10}})");
//
tree = parse_in_arena(R"(foo:
1: 10
2:
2: 10
3: 10
4: 10
5:
5: 10
6: 10
)");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), FLOW_SL);
EXPECT_EQ(emit2str(tree), R"({foo: {1: 10,2: {2: 10,3: 10},4: 10,5: {5: 10,6: 10}}})");
tree._rem_flags(tree.root_id(), CONTAINER_STYLE);
tree._add_flags(tree.root_id(), BLOCK);
tree._rem_flags(tree["foo"][1].id(), BLOCK);
tree._add_flags(tree["foo"][1].id(), FLOW_SL);
tree._rem_flags(tree["foo"][3].id(), BLOCK);
tree._add_flags(tree["foo"][3].id(), FLOW_SL);
EXPECT_EQ(emit2str(tree), R"(foo:
1: 10
2: {2: 10,3: 10}
4: 10
5: {5: 10,6: 10}
)");
}
//-------------------------------------------
// this is needed to use the test case library
Case const* get_case(csubstr /*name*/)
{
return nullptr;
}
} // namespace yml
} // namespace c4
Reference in New Issue View Git Blame Copy Permalink