Merge branch 'main' into sb/spdlog-outsb/spdlog-out

1 files changed, 0 insertions, 616 deletions

diff --git a/thirdparty/ryml/test/test_style.cpp b/thirdparty/ryml/test/test_style.cpp
deleted file mode 100644
index 5b46d075b..000000000
--- a/thirdparty/ryml/test/test_style.cpp
+++ /dev/null
@@ -1,616 +0,0 @@
-#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_case.hpp"
-
-#include <gtest/gtest.h>
-
-namespace c4 {
-namespace yml {
-
-std::string emit2str(Tree const& t)
-{
-    return emitrs_yaml<std::string>(t);
-}
-
-
-TEST(style, flags)
-{
-    Tree tree = parse_in_arena("foo: bar");
-    EXPECT_TRUE(tree.rootref().type().default_block());
-    EXPECT_FALSE(tree.rootref().type().marked_flow());
-    EXPECT_FALSE(tree.rootref().type().marked_flow_sl());
-    EXPECT_FALSE(tree.rootref().type().marked_flow_ml());
-    tree._add_flags(tree.root_id(), _WIP_STYLE_FLOW_SL);
-    EXPECT_FALSE(tree.rootref().type().default_block());
-    EXPECT_TRUE(tree.rootref().type().marked_flow());
-    EXPECT_TRUE(tree.rootref().type().marked_flow_sl());
-    EXPECT_FALSE(tree.rootref().type().marked_flow_ml());
-    tree._rem_flags(tree.root_id(), _WIP_STYLE_FLOW_SL);
-    tree._add_flags(tree.root_id(), _WIP_STYLE_FLOW_ML);
-    EXPECT_FALSE(tree.rootref().type().default_block());
-    EXPECT_TRUE(tree.rootref().type().marked_flow());
-    EXPECT_FALSE(tree.rootref().type().marked_flow_sl());
-    EXPECT_TRUE(tree.rootref().type().marked_flow_ml());
-}
-
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-csubstr scalar_yaml = R"(
-this is the key: >-
-  this is the multiline
-  "val" with
-
-  'empty' lines
-)";
-
-void check_same_emit(Tree const& expected)
-{
-    #if 0
-        #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)
-    #else
-        #define _showtrees(num)
-    #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)
-{
-    Tree expected = parse_in_arena("{}");
-    NodeRef r = expected.rootref();
-    r["normal"] |= MAP;
-    r["normal"]["singleline"] = "foo";
-    r["normal"]["multiline"] |= MAP;
-    r["normal"]["multiline"]["____________"] = "foo";
-    r["normal"]["multiline"]["____mid_____"] = "foo\nbar";
-    r["normal"]["multiline"]["____mid_end1"] = "foo\nbar\n";
-    r["normal"]["multiline"]["____mid_end2"] = "foo\nbar\n\n";
-    r["normal"]["multiline"]["____mid_end3"] = "foo\nbar\n\n\n";
-    r["normal"]["multiline"]["____________"] = "foo";
-    r["normal"]["multiline"]["____________"] = "foo bar";
-    r["normal"]["multiline"]["________end1"] = "foo bar\n";
-    r["normal"]["multiline"]["________end2"] = "foo bar\n\n";
-    r["normal"]["multiline"]["________end3"] = "foo bar\n\n\n";
-    r["normal"]["multiline"]["beg_________"] = "\nfoo";
-    r["normal"]["multiline"]["beg_mid_____"] = "\nfoo\nbar";
-    r["normal"]["multiline"]["beg_mid_end1"] = "\nfoo\nbar\n";
-    r["normal"]["multiline"]["beg_mid_end2"] = "\nfoo\nbar\n\n";
-    r["normal"]["multiline"]["beg_mid_end3"] = "\nfoo\nbar\n\n\n";
-    r["leading_ws"] |= MAP;
-    r["leading_ws"]["singleline"] |= MAP;
-    r["leading_ws"]["singleline"]["space"] = " foo";
-    r["leading_ws"]["singleline"]["tab"] = "\tfoo";
-    r["leading_ws"]["singleline"]["space_and_tab0"] = " \tfoo";
-    r["leading_ws"]["singleline"]["space_and_tab1"] = "\t foo";
-    r["leading_ws"]["multiline"] |= MAP;
-    r["leading_ws"]["multiline"]["beg_________"] = "\n \tfoo";
-    r["leading_ws"]["multiline"]["beg_mid_____"] = "\n \tfoo\nbar";
-    r["leading_ws"]["multiline"]["beg_mid_end1"] = "\n \tfoo\nbar\n";
-    r["leading_ws"]["multiline"]["beg_mid_end2"] = "\n \tfoo\nbar\n\n";
-    r["leading_ws"]["multiline"]["beg_mid_end3"] = "\n \tfoo\nbar\n\n\n";
-    check_same_emit(expected);
-}
-
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-
-#ifdef WIP
-TEST(style, scalar_retains_style_after_parse)
-{
-    {
-        Tree t = parse_in_arena("foo");
-        EXPECT_TRUE(t.rootref().type().val_marked_plain());
-        EXPECT_FALSE(t.rootref().type().val_marked_squo());
-        EXPECT_FALSE(t.rootref().type().val_marked_dquo());
-        EXPECT_FALSE(t.rootref().type().val_marked_literal());
-        EXPECT_FALSE(t.rootref().type().val_marked_folded());
-        EXPECT_EQ(emitrs<std::string>(t), std::string("foo\n"));
-    }
-    {
-        Tree t = parse_in_arena("'foo'");
-        EXPECT_FALSE(t.rootref().type().val_marked_plain());
-        EXPECT_TRUE(t.rootref().type().val_marked_squo());
-        EXPECT_FALSE(t.rootref().type().val_marked_dquo());
-        EXPECT_FALSE(t.rootref().type().val_marked_literal());
-        EXPECT_FALSE(t.rootref().type().val_marked_folded());
-        EXPECT_EQ(emitrs<std::string>(t), std::string("'foo'\n"));
-    }
-    {
-        Tree t = parse_in_arena("'foo'");
-        EXPECT_FALSE(t.rootref().type().val_marked_plain());
-        EXPECT_FALSE(t.rootref().type().val_marked_squo());
-        EXPECT_TRUE(t.rootref().type().val_marked_dquo());
-        EXPECT_FALSE(t.rootref().type().val_marked_literal());
-        EXPECT_FALSE(t.rootref().type().val_marked_folded());
-        EXPECT_EQ(emitrs<std::string>(t), std::string("'foo'\n"));
-    }
-    {
-        Tree t = parse_in_arena("[foo, 'baz', \"bat\"]");
-        EXPECT_TRUE(t.rootref().type().marked_flow());
-        EXPECT_TRUE(t[0].type().val_marked_plain());
-        EXPECT_FALSE(t[0].type().val_marked_squo());
-        EXPECT_FALSE(t[0].type().val_marked_dquo());
-        EXPECT_FALSE(t[0].type().val_marked_literal());
-        EXPECT_FALSE(t[0].type().val_marked_folded());
-        EXPECT_FALSE(t[1].type().val_marked_plain());
-        EXPECT_TRUE(t[1].type().val_marked_squo());
-        EXPECT_FALSE(t[1].type().val_marked_dquo());
-        EXPECT_FALSE(t[1].type().val_marked_literal());
-        EXPECT_FALSE(t[1].type().val_marked_folded());
-        EXPECT_FALSE(t[2].type().val_marked_plain());
-        EXPECT_FALSE(t[2].type().val_marked_squo());
-        EXPECT_TRUE(t[2].type().val_marked_dquo());
-        EXPECT_FALSE(t[2].type().val_marked_literal());
-        EXPECT_FALSE(t[2].type().val_marked_folded());
-        EXPECT_EQ(emitrs<std::string>(t), std::string("foo"));
-    }
-}
-#endif
-
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-
-TEST(scalar, base)
-{
-    Tree tree = parse_in_arena(scalar_yaml);
-    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)
-{
-    Tree tree = parse_in_arena(scalar_yaml);
-    {
-        SCOPED_TRACE("val only");
-        EXPECT_FALSE(tree[0].type().key_marked_literal());
-        EXPECT_FALSE(tree[0].type().val_marked_literal());
-        tree._add_flags(tree[0].id(), _WIP_VAL_LITERAL);
-        EXPECT_FALSE(tree[0].type().key_marked_literal());
-        EXPECT_TRUE(tree[0].type().val_marked_literal());
-        EXPECT_EQ(emit2str(tree), R"(this is the key: |-
-  this is the multiline "val" with
-  'empty' lines
-)");
-        check_same_emit(tree);
-    }
-    {
-        SCOPED_TRACE("key+val");
-        tree._add_flags(tree[0].id(), _WIP_KEY_LITERAL);
-        EXPECT_TRUE(tree[0].type().key_marked_literal());
-        EXPECT_TRUE(tree[0].type().val_marked_literal());
-        EXPECT_EQ(emit2str(tree), R"(? |-
-  this is the key
-: |-
-  this is the multiline "val" with
-  'empty' lines
-)");
-        check_same_emit(tree);
-    }
-    {
-        SCOPED_TRACE("key only");
-        tree._rem_flags(tree[0].id(), _WIP_VAL_LITERAL);
-        EXPECT_TRUE(tree[0].type().key_marked_literal());
-        EXPECT_FALSE(tree[0].type().val_marked_literal());
-        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)
-{
-    Tree tree = parse_in_arena(scalar_yaml);
-    {
-        SCOPED_TRACE("val only");
-        EXPECT_FALSE(tree[0].type().key_marked_folded());
-        EXPECT_FALSE(tree[0].type().val_marked_folded());
-        tree._add_flags(tree[0].id(), _WIP_VAL_FOLDED);
-        EXPECT_FALSE(tree[0].type().key_marked_folded());
-        EXPECT_TRUE(tree[0].type().val_marked_folded());
-        EXPECT_EQ(emit2str(tree), R"(this is the key: >-
-  this is the multiline "val" with
-
-  'empty' lines
-)");
-        check_same_emit(tree);
-    }
-    {
-        SCOPED_TRACE("key+val");
-        tree._add_flags(tree[0].id(), _WIP_KEY_FOLDED);
-        EXPECT_TRUE(tree[0].type().key_marked_folded());
-        EXPECT_TRUE(tree[0].type().val_marked_folded());
-        EXPECT_EQ(emit2str(tree), R"(? >-
-  this is the key
-: >-
-  this is the multiline "val" with
-
-  'empty' lines
-)");
-        check_same_emit(tree);
-    }
-    {
-        SCOPED_TRACE("val only");
-        tree._rem_flags(tree[0].id(), _WIP_VAL_FOLDED);
-        EXPECT_TRUE(tree[0].type().key_marked_folded());
-        EXPECT_FALSE(tree[0].type().val_marked_folded());
-        EXPECT_EQ(emit2str(tree), R"(? >-
-  this is the key
-: |-
-  this is the multiline "val" with
-  'empty' lines
-)");
-        check_same_emit(tree);
-    }
-}
-
-TEST(scalar, squot)
-{
-    Tree tree = parse_in_arena(scalar_yaml);
-    EXPECT_FALSE(tree[0].type().key_marked_squo());
-    EXPECT_FALSE(tree[0].type().val_marked_squo());
-    {
-        SCOPED_TRACE("val only");
-        tree._add_flags(tree[0].id(), _WIP_VAL_SQUO);
-        EXPECT_FALSE(tree[0].type().key_marked_squo());
-        EXPECT_TRUE(tree[0].type().val_marked_squo());
-        EXPECT_EQ(emit2str(tree), R"(this is the key: 'this is the multiline "val" with
-
-  ''empty'' lines'
-)");
-        check_same_emit(tree);
-    }
-    {
-        SCOPED_TRACE("key+val");
-        tree._add_flags(tree[0].id(), _WIP_KEY_SQUO);
-        EXPECT_TRUE(tree[0].type().key_marked_squo());
-        EXPECT_TRUE(tree[0].type().val_marked_squo());
-        EXPECT_EQ(emit2str(tree), R"('this is the key': 'this is the multiline "val" with
-
-  ''empty'' lines'
-)");
-        check_same_emit(tree);
-    }
-    {
-        SCOPED_TRACE("key only");
-        tree._rem_flags(tree[0].id(), _WIP_VAL_SQUO);
-        EXPECT_TRUE(tree[0].type().key_marked_squo());
-        EXPECT_FALSE(tree[0].type().val_marked_squo());
-        EXPECT_EQ(emit2str(tree), R"('this is the key': |-
-  this is the multiline "val" with
-  'empty' lines
-)");
-        check_same_emit(tree);
-    }
-}
-
-TEST(scalar, dquot)
-{
-    Tree tree = parse_in_arena(scalar_yaml);
-    EXPECT_FALSE(tree[0].type().key_marked_dquo());
-    EXPECT_FALSE(tree[0].type().val_marked_dquo());
-    {
-        SCOPED_TRACE("val only");
-        tree._add_flags(tree[0].id(), _WIP_VAL_DQUO);
-        EXPECT_FALSE(tree[0].type().key_marked_dquo());
-        EXPECT_TRUE(tree[0].type().val_marked_dquo());
-        // visual studio fails to compile this string when used inside
-        // the EXPECT_EQ() macro below. So we declare it separately
-        // instead:
-        csubstr yaml = R"(this is the key: "this is the multiline \"val\" with
-
-  'empty' lines"
-)";
-        EXPECT_EQ(emit2str(tree), yaml);
-        check_same_emit(tree);
-    }
-    {
-        SCOPED_TRACE("key+val");
-        tree._add_flags(tree[0].id(), _WIP_KEY_DQUO);
-        EXPECT_TRUE(tree[0].type().key_marked_dquo());
-        EXPECT_TRUE(tree[0].type().val_marked_dquo());
-        // visual studio fails to compile this string when used inside
-        // the EXPECT_EQ() macro below. So we declare it separately
-        // instead:
-        csubstr yaml = R"("this is the key": "this is the multiline \"val\" with
-
-  'empty' lines"
-)";
-        EXPECT_EQ(emit2str(tree), yaml);
-        check_same_emit(tree);
-    }
-    {
-        SCOPED_TRACE("key only");
-        tree._rem_flags(tree[0].id(), _WIP_VAL_DQUO);
-        EXPECT_TRUE(tree[0].type().key_marked_dquo());
-        EXPECT_FALSE(tree[0].type().val_marked_dquo());
-        EXPECT_EQ(emit2str(tree), R"("this is the key": |-
-  this is the multiline "val" with
-  'empty' lines
-)");
-        check_same_emit(tree);
-    }
-}
-
-TEST(scalar, plain)
-{
-    Tree tree = parse_in_arena(scalar_yaml);
-    EXPECT_FALSE(tree[0].type().key_marked_plain());
-    EXPECT_FALSE(tree[0].type().val_marked_plain());
-    {
-        SCOPED_TRACE("val only");
-        tree._add_flags(tree[0].id(), _WIP_VAL_PLAIN);
-        EXPECT_FALSE(tree[0].type().key_marked_plain());
-        EXPECT_TRUE(tree[0].type().val_marked_plain());
-        EXPECT_EQ(emit2str(tree), R"(this is the key: this is the multiline "val" with
-
-  'empty' lines
-)");
-        check_same_emit(tree);
-    }
-    {
-        SCOPED_TRACE("key+val");
-        tree._add_flags(tree[0].id(), _WIP_KEY_PLAIN);
-        EXPECT_TRUE(tree[0].type().key_marked_plain());
-        EXPECT_TRUE(tree[0].type().val_marked_plain());
-        EXPECT_EQ(emit2str(tree), R"(this is the key: this is the multiline "val" with
-
-  'empty' lines
-)");
-        check_same_emit(tree);
-    }
-    {
-        SCOPED_TRACE("key only");
-        tree._rem_flags(tree[0].id(), _WIP_VAL_PLAIN);
-        EXPECT_TRUE(tree[0].type().key_marked_plain());
-        EXPECT_FALSE(tree[0].type().val_marked_plain());
-        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(), _WIP_STYLE_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]");
-    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._add_flags(tree.root_id(), _WIP_STYLE_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]}");
-    EXPECT_TRUE(tree.rootref().type().default_block());
-    EXPECT_EQ(emit2str(tree), R"(foo:
-  - 1
-  - 2
-  - 3
-  - 4
-  - 5
-  - 6
-)");
-    tree = parse_in_arena("{foo: [1, [2, 3], 4, [5, 6]]}");
-    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]}");
-    EXPECT_TRUE(tree.rootref().type().default_block());
-    tree._add_flags(tree.root_id(), _WIP_STYLE_FLOW_SL);
-    EXPECT_FALSE(tree.rootref().type().default_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._add_flags(tree.root_id(), _WIP_STYLE_FLOW_SL);
-    EXPECT_EQ(emit2str(tree), R"({foo: [1,[2,3],4,[5,6]]})");
-    //
-    tree._rem_flags(tree.root_id(), _WIP_STYLE_FLOW_SL);
-    tree._add_flags(tree["foo"][1].id(), _WIP_STYLE_FLOW_SL);
-    tree._add_flags(tree["foo"][3].id(), _WIP_STYLE_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}");
-    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("{1: 10, 2: 10, 3: 10, 4: 10, 5: 10, 6: 10}");
-    tree._add_flags(tree.root_id(), _WIP_STYLE_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}}");
-    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("{foo: {1: 10, 2: 10, 3: 10, 4: 10, 5: 10, 6: 10}}");
-    tree._add_flags(tree.root_id(), _WIP_STYLE_FLOW_SL);
-    EXPECT_EQ(emit2str(tree), R"({foo: {1: 10,2: 10,3: 10,4: 10,5: 10,6: 10}})");
-    //
-    tree = parse_in_arena("{foo: {1: 10, 2: {2: 10, 3: 10}, 4: 10, 5: {5: 10, 6: 10}}}");
-    EXPECT_EQ(emit2str(tree), R"(foo:
-  1: 10
-  2:
-    2: 10
-    3: 10
-  4: 10
-  5:
-    5: 10
-    6: 10
-)");
-    tree._add_flags(tree.root_id(), _WIP_STYLE_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(), _WIP_STYLE_FLOW_SL);
-    tree._add_flags(tree["foo"][1].id(), _WIP_STYLE_FLOW_SL);
-    tree._add_flags(tree["foo"][3].id(), _WIP_STYLE_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