#include "./test_lib/test_group.hpp"
#include "./test_lib/test_group.def.hpp"

RYML_DEFINE_TEST_MAIN()

namespace c4 {
namespace yml {

TEST(simple_seq, bad_seq1)
{
    Tree tree;
    ExpectError::check_error_parse(&tree, [&]{
        parse_in_arena(R"(
---
[ a, b, c ] ]
)", &tree);
    });
}

TEST(simple_seq, bad_seq2)
{
    Tree tree;
    ExpectError::check_error_parse(&tree, [&]{
        parse_in_arena(R"(
---
[ [ a, b, c ]
)", &tree);
    });
}

TEST(simple_seq, two_nested_flow_seqs)
{
    Tree tree = parse_in_arena("[[]]");
    EXPECT_TRUE(tree.rootref().is_seq());
    ASSERT_TRUE(tree.rootref().has_children());
    EXPECT_TRUE(tree.rootref().first_child().is_seq());
    ASSERT_FALSE(tree.rootref().first_child().has_children());
}

TEST(simple_seq, many_unmatched_brackets)
{
    std::string src;
    src.reserve(10000000u);
    for(size_t num_brackets : {4u, 8u, 32u, 64u})
    {
        SCOPED_TRACE(num_brackets);
        for(size_t i = src.size(); i < num_brackets; ++i)
            src += '[';
        Tree tree;
        Location loc = {};
        loc.line = 1;
        loc.col = num_brackets + 1u;
        ExpectError::check_error_parse(&tree, [&]{
            parse_in_place(to_substr(src), &tree);
        }, loc);
    }
}

TEST(simple_seq, missing_quoted_key)
{
    csubstr yaml = R"(
"top1" :
  ["0", "1", ]
'top2' :
  ["0", "1", ]
---
"top1" :
  - "0"
  - "1"
'top2' :
  - "0"
  - "1"
)";
    test_check_emit_check(yaml, [](Tree const &t){
        ConstNodeRef n = t.docref(0);
        EXPECT_TRUE(n["top1"].is_key_quoted());
        EXPECT_TRUE(n["top2"].is_key_quoted());
        EXPECT_TRUE(n["top1"][0].is_val_quoted());
        EXPECT_TRUE(n["top1"][1].is_val_quoted());
        EXPECT_TRUE(n["top2"][0].is_val_quoted());
        EXPECT_TRUE(n["top2"][1].is_val_quoted());
        n = t.docref(1);
        EXPECT_TRUE(n["top1"].is_key_quoted());
        EXPECT_TRUE(n["top2"].is_key_quoted());
        EXPECT_TRUE(n["top1"][0].is_val_quoted());
        EXPECT_TRUE(n["top1"][1].is_val_quoted());
        EXPECT_TRUE(n["top2"][0].is_val_quoted());
        EXPECT_TRUE(n["top2"][1].is_val_quoted());
    });
}

TEST(simple_seq, block_nested_with_tags)
{
    std::string yaml = R"(- !!seq
  - !!seq
    - foo
- bar
)";
    Tree t = parse_in_arena(to_csubstr(yaml));
    EXPECT_EQ(yaml, emitrs_yaml<std::string>(t));
}

TEST(simple_seq, deeply_nested_to_cover_parse_stack_resizes)
{
    csubstr yaml = R"(
[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[0, 1, 2, 3, 4, 5, 6, 7]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
)";
    Tree t = parse_in_arena(yaml);
    id_type id = t.root_id();
    while(t.has_children(id))
        id = t.first_child(id);
    ASSERT_TRUE(t.cref(id).has_parent());
    ConstNodeRef seq = t.cref(id).parent();
    ASSERT_TRUE(seq.is_seq());
    EXPECT_EQ(seq[0].val(), csubstr("0"));
    EXPECT_EQ(seq[1].val(), csubstr("1"));
    EXPECT_EQ(seq[2].val(), csubstr("2"));
    EXPECT_EQ(seq[3].val(), csubstr("3"));
    EXPECT_EQ(seq[4].val(), csubstr("4"));
    EXPECT_EQ(seq[5].val(), csubstr("5"));
    EXPECT_EQ(seq[6].val(), csubstr("6"));
    EXPECT_EQ(seq[7].val(), csubstr("7"));
}


#ifdef RYML_WITH_TAB_TOKENS
TEST(simple_seq, block_tab_tokens__0_spaces_only)
{
    Tree tree = parse_in_arena(R"(
- 0
- 1
- 2
)");
    EXPECT_EQ(tree[0].val(), csubstr("0"));
    EXPECT_EQ(tree[1].val(), csubstr("1"));
    EXPECT_EQ(tree[2].val(), csubstr("2"));
}
TEST(simple_seq, block_tab_tokens__1_tabs_after)
{
    Tree tree = parse_in_arena(R"(
-	0
-	1
-	2
)");
    EXPECT_EQ(tree[0].val(), csubstr("0"));
    EXPECT_EQ(tree[1].val(), csubstr("1"));
    EXPECT_EQ(tree[2].val(), csubstr("2"));
}
TEST(simple_seq, block_tab_tokens__2_tabs_before_after)
{
    Tree tree = parse_in_arena(R"(
-	0	
-	1	
-	2	
)");
    EXPECT_EQ(tree[0].val(), csubstr("0"));
    EXPECT_EQ(tree[1].val(), csubstr("1"));
    EXPECT_EQ(tree[2].val(), csubstr("2"));
}
TEST(simple_seq, block_tab_tokens__3_tabs_everywhere)
{
    Tree tree = parse_in_arena(R"(
-	0	0	
-	1	1	
-	2	2	
)");
    EXPECT_EQ(tree[0].val(), csubstr("0\t0"));
    EXPECT_EQ(tree[1].val(), csubstr("1\t1"));
    EXPECT_EQ(tree[2].val(), csubstr("2\t2"));
}
TEST(simple_seq, block_tab_tokens__4_tabs_indentation_error)
{
    ExpectError::check_error_parse([]{
        Tree tree = parse_in_arena(R"(
	-	0	0	
	-	1	1	
	-	2	2	
)");
    });
}

TEST(simple_seq, flow_tab_tokens__0_flow_no_tabs)
{
    Tree tree = parse_in_arena(R"([0, 1, 2])");
    EXPECT_EQ(tree[0].val(), csubstr("0"));
    EXPECT_EQ(tree[1].val(), csubstr("1"));
    EXPECT_EQ(tree[2].val(), csubstr("2"));
}

TEST(simple_seq, flow_tab_tokens__1_flow_tabs_after)
{
    Tree tree = parse_in_arena(R"([0,	1,	2]	)");
    EXPECT_EQ(tree[0].val(), csubstr("0"));
    EXPECT_EQ(tree[1].val(), csubstr("1"));
    EXPECT_EQ(tree[2].val(), csubstr("2"));
}

TEST(simple_seq, flow_tab_tokens__2_flow_tabs_before_and_after)
{
    Tree tree = parse_in_arena(R"([0	,	1	,	2])");
    EXPECT_EQ(tree[0].val(), csubstr("0"));
    EXPECT_EQ(tree[1].val(), csubstr("1"));
    EXPECT_EQ(tree[2].val(), csubstr("2"));
}

TEST(simple_seq, flow_tab_tokens__3_flow_tabs_everywhere)
{
    Tree tree = parse_in_arena(R"(	[	
	0	0	,	
	1	1	,	
	2	2	,	
	]	
)");
    EXPECT_EQ(tree[0].val(), csubstr("0\t0"));
    EXPECT_EQ(tree[1].val(), csubstr("1\t1"));
    EXPECT_EQ(tree[2].val(), csubstr("2\t2"));
}
#endif // RYML_WITH_TAB_TOKENS


TEST(simple_seq, unterminated_seqimap)
{
    {
        SCOPED_TRACE("space after");
        Tree t;
        ExpectError::check_error_parse(&t, [&]{
            parse_in_arena("[a: ");
        });
    }
    {
        SCOPED_TRACE("no space after");
        Tree t;
        ExpectError::check_error_parse(&t, [&]{
            parse_in_arena("[a:");
        });
    }
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------


CASE_GROUP(SIMPLE_SEQ)
{

ADD_CASE_TO_GROUP("simple seq",
R"(- 0
- 1
- 2
- 3
)",
N(SB, L{N{VP, "0"}, N{VP, "1"}, N{VP, "2"}, N{VP, "3"}})
);


ADD_CASE_TO_GROUP("simple seq, flow, single line",
"[0, 1, 2, 3]",
N(SFS, L{N{VP, "0"}, N{VP, "1"}, N{VP, "2"}, N{VP, "3"}})
);

ADD_CASE_TO_GROUP("simple seq, flow, single line, trailcomma",
"[0, 1, 2, 3,]",
N(SFS, L{N{VP, "0"}, N{VP, "1"}, N{VP, "2"}, N{VP, "3"},})
);

ADD_CASE_TO_GROUP("simple seq, flow, multiline, unindented",
R"([
0,
1,
2,
3
])",
N(SFM, L{N{VP, "0"}, N{VP, "1"}, N{VP, "2"}, N{VP, "3"},})
);

ADD_CASE_TO_GROUP("simple seq, flow, multiline, unindented, trailcomma",
R"([
0,
1,
2,
3,
])",
N(SFM, L{N{VP, "0"}, N{VP, "1"}, N{VP, "2"}, N{VP, "3"}})
);

ADD_CASE_TO_GROUP("simple seq, flow, multiline, comments inline",
R"([
0,  # bla0
1,  # bla1
2,  # bla2
3   # bla3
])",
N(SFM, L{N{VP, "0"}, N{VP, "1"}, N{VP, "2"}, N{VP, "3"}})
);

ADD_CASE_TO_GROUP("simple seq, flow, multiline, comments prev line",
R"([
# bla0
0,
# bla1
1,
# bla2
2,
# bla3
3
])",
N(SFM, L{N{VP, "0"}, N{VP, "1"}, N{VP, "2"}, N{VP, "3"}})
);

ADD_CASE_TO_GROUP("simple seq, flow, multiline, indented",
R"([
  0,
  1,
  2,
  3
])",
N(SFM, L{N{VP, "0"}, N{VP, "1"}, N{VP, "2"}, N{VP, "3"}})
);

ADD_CASE_TO_GROUP("simple seq, comments inline",
R"(
- 0   # this is a foo
- 1   # this is a bar
- 2   # this is a bar
- 3   # this is a bar
)",
N(SB, L{N{VP, "0"}, N{VP, "1"}, N{VP, "2"}, N{VP, "3"}})
);

ADD_CASE_TO_GROUP("simple seq, comments prev line",
R"(
# this is a foo
- 0
# this is a bar
- 1
# this is a baz
- 2
# this is a bat
- 3
)",
N(SB, L{N{VP, "0"}, N{VP, "1"}, N{VP, "2"}, N{VP, "3"}})
);

ADD_CASE_TO_GROUP("simple seq, empty elements",
R"(-
-
- 
-  
- # with comments
- # more comments
)",
N(SB, L{VN, VN, VN, VN, VN, VN})
);

ADD_CASE_TO_GROUP("simple seq, empty elements with non-empty first",
R"(
- non-empty
-
- 
-  
- # with comments
- # more comments
)",
N(SB, L{N{VP, "non-empty"}, VN, VN, VN, VN, VN})
);

ADD_CASE_TO_GROUP("simple seq, scalars with special chars, comma",
R"(
- a,b
- c,d
- e,f
- a, b
- c, d
- e, f
- a , b
- c , d
- e , f
- a ,b
- c ,d
- e ,f
)",
N(SB, L{N{VP, "a,b"}, N{VP, "c,d"}, N{VP, "e,f"},
  N{VP, "a, b"}, N{VP, "c, d"}, N{VP, "e, f"},
  N{VP, "a , b"}, N{VP, "c , d"}, N{VP, "e , f"},
  N{VP, "a ,b"}, N{VP, "c ,d"}, N{VP, "e ,f"},
    })
);

ADD_CASE_TO_GROUP("simple seq, scalars with special chars, colon",
R"(
- a:b
- "c:d"
- 'e:f'
- a :b
- "c :d"
- 'e :f'
- a : b    # THIS IS A KEY-VAL!!!
- "c : d"
- 'e : f'
- a: b     # THIS IS A KEY-VAL!!!
- "c: d"
- 'e: f'
)",
N(SB, L{
  N(VP, "a:b"), N(VD, "c:d"), N(VS, "e:f"),
  N(VP, "a :b"), N(VD, "c :d"), N(VS, "e :f"),
  N(MB, L{N(KP|VP, "a", "b")}), N(VD, "c : d"), N(VS, "e : f"),
  N(MB, L{N(KP|VP, "a", "b")}), N(VD, "c: d"), N(VS, "e: f"),
    })
);

ADD_CASE_TO_GROUP("simple seq, scalars with special chars, cardinal",
R"(
- a#b
- "a#b"
- 'a#b'
- a# b
- "a# b"
- 'a# b'
- a # b
- "a # b"
- 'a # b'
- a #b
- "a #b"
- 'a #b'
)",
N(SB, L{
  N(VP, "a#b"), N(VD, "a#b"), N(VS, "a#b"),
  N(VP, "a# b"), N(VD, "a# b"), N(VS, "a# b"),
  N(VP, "a"), N(VD, "a # b"), N(VS, "a # b"),
  N(VP, "a"), N(VD, "a #b"), N(VS, "a #b"),
    })
);

ADD_CASE_TO_GROUP("simple seq, scalars with special chars, dash",
R"(
- a-b
- "a-b"
- 'a-b'
- a- b
- "a- b"
- 'a- b'
- a - b
- "a - b"
- 'a - b'
- a -b
- "a -b"
- 'a -b'
)",
N(SB, L{
 N(VP, "a-b"),   N(VD, "a-b"),   N(VS, "a-b"),
 N(VP, "a- b"),  N(VD, "a- b"),  N(VS, "a- b"),
 N(VP, "a - b"), N(VD, "a - b"), N(VS, "a - b"),
 N(VP, "a -b"),  N(VD, "a -b"),  N(VS, "a -b"),
    })
);

ADD_CASE_TO_GROUP("simple seq, scalars with special chars, left-curly",
R"(
- a{b
- "a{b"
- 'a{b'
- a{ b
- "a{ b"
- 'a{ b'
- a { b
- "a { b"
- 'a { b'
- a {b
- "a {b"
- 'a {b'
)",
N(SB, L{
  N(VP, "a{b"),   N(VD, "a{b"),   N(VS, "a{b"),
  N(VP, "a{ b"),  N(VD, "a{ b"),  N(VS, "a{ b"),
  N(VP, "a { b"), N(VD, "a { b"), N(VS, "a { b"),
  N(VP, "a {b"),  N(VD, "a {b"),  N(VS, "a {b"),
    })
);

ADD_CASE_TO_GROUP("simple seq, scalars with special chars, right-curly",
R"(
- a}b
- "a}b"
- 'a}b'
- a} b
- "a} b"
- 'a} b'
- a } b
- "a } b"
- 'a } b'
- a }b
- "a }b"
- 'a }b'
)",
N(SB, L{
  N(VP, "a}b"),   N(VD, "a}b"),   N(VS, "a}b"),
  N(VP, "a} b"),  N(VD, "a} b"),  N(VS, "a} b"),
  N(VP, "a } b"), N(VD, "a } b"), N(VS, "a } b"),
  N(VP, "a }b"),  N(VD, "a }b"),  N(VS, "a }b"),
    })
);

ADD_CASE_TO_GROUP("simple seq, scalars with special chars, left-bracket",
R"(
- a[b
- "a[b"
- 'a[b'
- a[ b
- "a[ b"
- 'a[ b'
- a [ b
- "a [ b"
- 'a [ b'
- a [b
- "a [b"
- 'a [b'
)",
N(SB, L{
  N(VP, "a[b"),   N(VD, "a[b"),   N(VS, "a[b"),
  N(VP, "a[ b"),  N(VD, "a[ b"),  N(VS, "a[ b"),
  N(VP, "a [ b"), N(VD, "a [ b"), N(VS, "a [ b"),
  N(VP, "a [b"),  N(VD, "a [b"),  N(VS, "a [b"),
    })
);

ADD_CASE_TO_GROUP("simple seq, scalars with special chars, right-bracket",
R"(
- a]b
- "a]b"
- 'a]b'
- a] b
- "a] b"
- 'a] b'
- a ] b
- "a ] b"
- 'a ] b'
- a ]b
- "a ]b"
- 'a ]b'
)",
N(SB, L{
  N(VP, "a]b"),   N(VD, "a]b"),   N(VS, "a]b"),
  N(VP, "a] b"),  N(VD, "a] b"),  N(VS, "a] b"),
  N(VP, "a ] b"), N(VD, "a ] b"), N(VS, "a ] b"),
  N(VP, "a ]b"),  N(VD, "a ]b"),  N(VS, "a ]b"),
    })
);

ADD_CASE_TO_GROUP("simple seq expl, scalars with special chars, comma",
R"([
 a,b,  "c,d",   'e,f',
 a, b,  "c, d",   'e, f',
 a , b,  "c , d",   'e , f',
 a ,b,  "c ,d",   'e ,f',
])",
N(SFM, L{
  N(VP, "a"), N(VP, "b"), N(VD, "c,d"),   N(VS, "e,f"),
  N(VP, "a"), N(VP, "b"), N(VD, "c, d"),  N(VS, "e, f"),
  N(VP, "a"), N(VP, "b"), N(VD, "c , d"), N(VS, "e , f"),
  N(VP, "a"), N(VP, "b"), N(VD, "c ,d"),  N(VS, "e ,f"),
})
);

ADD_CASE_TO_GROUP("simple seq flow, scalars with special chars, colon",
R"([
    :a,
    :0,
    ::,
    :-,
    :*,
    :@,
    :%,
    :^,
    :$,
    :`,
    : ,    # this is a map
    :	,  # this is a map (when tab tokens are enabled)
    x:a,
    x:0,
    x::,
    x:-,
    x:*,
    x:@,
    x:%,
    x:^,
    x:$,
    x:`,
    x: ,   # this is a map
    x:	,  # this is a map (when tab tokens are enabled)
    :z:a,
    :z:0,
    :z::,
    :z:-,
    :z:*,
    :z:@,
    :z:%,
    :z:^,
    :z:$,
    :z:`,
    :z: ,   # this is a map
    :z:	,  # this is a map (when tab tokens are enabled)
]
)",
N(SFM, L{
   N(VP, ":a"),
   N(VP, ":0"),
   N(MFS, L{N(KP|VN, ":", {})}),
   N(VP, ":-"),
   N(VP, ":*"),
   N(VP, ":@"),
   N(VP, ":%"),
   N(VP, ":^"),
   N(VP, ":$"),
   N(VP, ":`"),
   N(MFS, L{KN|VN}),
   _RYML_WITH_OR_WITHOUT_TAB_TOKENS(N(MFS, L{KN|VN}), N(VP, ":\t")),
   N(VP, "x:a"),
   N(VP, "x:0"),
   N(MFS, L{N(KP|VN, "x:", {})}),
   N(VP, "x:-"),
   N(VP, "x:*"),
   N(VP, "x:@"),
   N(VP, "x:%"),
   N(VP, "x:^"),
   N(VP, "x:$"),
   N(VP, "x:`"),
   N(MFS, L{N(KP|VN, "x", "")}),
   _RYML_WITH_OR_WITHOUT_TAB_TOKENS(N(MFS, L{N(KP|VN, "x", "")}), N(VP, "x:\t")),
   N(VP, ":z:a"),
   N(VP, ":z:0"),
   N(MFS, L{N(KP|VN, ":z:", {})}),
   N(VP, ":z:-"),
   N(VP, ":z:*"),
   N(VP, ":z:@"),
   N(VP, ":z:%"),
   N(VP, ":z:^"),
   N(VP, ":z:$"),
   N(VP, ":z:`"),
   N(MFS, L{N(KP|VN, ":z", {})}),
   _RYML_WITH_OR_WITHOUT_TAB_TOKENS(N(MFS, L{N(KP|VN, ":z", "")}), N(VP, ":z:\t")),
 })
);

ADD_CASE_TO_GROUP("simple seq blck, scalars with special chars, colon",
R"(- :a
- :0
- ::
- :-
- :*
- :@
- :%
- :^
- :$
- :`
- :   # this is a map
#- :	  # this is a map (when tab tokens are enabled)
- x:a
- x:0
- x::
- x:-
- x:*
- x:@
- x:%
- x:^
- x:$
- x:`
- x:      # this is a map
#- x:	  # this is a map (when tab tokens are enabled)
- :z:a
- :z:0
- :z::
- :z:-
- :z:*
- :z:@
- :z:%
- :z:^
- :z:$
- :z:`
- :z:      # this is a map
#- :z:	  # this is a map (when tab tokens are enabled)
)",
N(SB, L{
 N(VP, ":a"),
 N(VP, ":0"),
 N(MB, L{N(KP|VN, ":", {})}),
 N(VP, ":-"),
 N(VP, ":*"),
 N(VP, ":@"),
 N(VP, ":%"),
 N(VP, ":^"),
 N(VP, ":$"),
 N(VP, ":`"),
 N(MB, L{KN|VN}),
// _RYML_WITH_OR_WITHOUT_TAB_TOKENS(N(MB, L{KN|VN}),
//                                  N(VP, ":")),
 N(VP, "x:a"),
 N(VP, "x:0"),
 N(MB, L{N(KP|VN, "x:", {})}),
 N(VP, "x:-"),
 N(VP, "x:*"),
 N(VP, "x:@"),
 N(VP, "x:%"),
 N(VP, "x:^"),
 N(VP, "x:$"),
 N(VP, "x:`"),
 N(MB, L{N(KP|VN, "x", {})}),
// _RYML_WITH_OR_WITHOUT_TAB_TOKENS(N(MB, L{N(KP|VN, "x", "")}),
//                                  N(VP, "x:")),
 N(VP, ":z:a"),
 N(VP, ":z:0"),
 N(MB, L{N(KP|VN, ":z:", {})}),
 N(VP, ":z:-"),
 N(VP, ":z:*"),
 N(VP, ":z:@"),
 N(VP, ":z:%"),
 N(VP, ":z:^"),
 N(VP, ":z:$"),
 N(VP, ":z:`"),
 N(MB, L{N(KP|VN, ":z", "")}),
// _RYML_WITH_OR_WITHOUT_TAB_TOKENS(N(MB, L{N(KP|VN, ":z", "")}),
//                                  N(VP, ":z:")),
})
);

ADD_CASE_TO_GROUP("simple seq flow, scalars with special chars, colon 2",
R"([
 a:b, "c:d",   'e:f',
 a: b, "c: d",   'e: f',
 a : b,  "c : d",   'e : f',
 a :b,  "c :d",   'e :f',
])",
N(SFM, L{
  N(VP, "a:b"), N(VD, "c:d"),   N(VS, "e:f"),
  N(MFS, L{N(KP|VP, "a", "b")}), N(VD, "c: d"),  N(VS, "e: f"),
  N(MFS, L{N(KP|VP, "a", "b")}), N(VD, "c : d"), N(VS, "e : f"),
  N(VP, "a :b"), N(VD, "c :d"),  N(VS, "e :f"),
    })
);

ADD_CASE_TO_GROUP("simple seq block, scalars with special chars, colon 2",
R"(- a:b
- "c:d"
- 'e:f'
- a: b
- "c: d"
- 'e: f'
- a : b
- "c : d"
- 'e : f'
- a :b
- "c :d"
- 'e :f'
)",
N(SB, L{
  N(VP, "a:b"), N(VD, "c:d"),   N(VS, "e:f"),
  N(MB, L{N(KP|VP, "a", "b")}), N(VD, "c: d"),  N(VS, "e: f"),
  N(MB, L{N(KP|VP, "a", "b")}), N(VD, "c : d"), N(VS, "e : f"),
  N(VP, "a :b"), N(VD, "c :d"),  N(VS, "e :f"),
    })
);

ADD_CASE_TO_GROUP("simple seq flow, scalars with special chars, cardinal",
R"([
 a#b, "c#d",   'e#f',
 a# b, "c# d",   'e# f',
 a # b, "c # d",   'e # f',
, # this is needed because of the comment above
 a #b, "c #d",   'e #f',
])",
N(SFM, L{
  N(VP, "a#b"), N(VD, "c#d"), N(VS, "e#f"),
  N(VP, "a# b"), N(VD, "c# d"), N(VS, "e# f"),
  N(VP, "a"),
  N(VP, "a"),
})
);

ADD_CASE_TO_GROUP("simple seq block, scalars with special chars, cardinal",
R"(- a#b
- "c#d"
- 'e#f'
- a# b
- "c# d"
- 'e# f'
- a # b
- "c # d"
- 'e # f'
- a #b
- "c #d"
- 'e #f'
)",
N(SB, L{
  N(VP, "a#b"), N(VD, "c#d"), N(VS, "e#f"),
  N(VP, "a# b"), N(VD, "c# d"), N(VS, "e# f"),
  N(VP, "a"), N(VD, "c # d"), N(VS, "e # f"),
  N(VP, "a"), N(VD, "c #d"), N(VS, "e #f"),
})
);

ADD_CASE_TO_GROUP("simple seq flow, scalars with special chars, dash",
R"([
 a-b, "c-d",   'e-f',
 a- b, "c- d",   'e- f',
 a - b, "c - d",   'e - f',
 a -b, "c -d",   'e -f',
])",
N(SFM, L{
  N(VP, "a-b"),   N(VD, "c-d"),   N(VS, "e-f"),
  N(VP, "a- b"),  N(VD, "c- d"),  N(VS, "e- f"),
  N(VP, "a - b"), N(VD, "c - d"), N(VS, "e - f"),
  N(VP, "a -b"),  N(VD, "c -d"),  N(VS, "e -f"),
    })
);

ADD_CASE_TO_GROUP("simple seq block, scalars with special chars, dash",
R"(- a-b
- "c-d"
- 'e-f'
- a- b
- "c- d"
- 'e- f'
- a - b
- "c - d"
- 'e - f'
- a -b
- "c -d"
- 'e -f'
)",
N(SB, L{
  N(VP, "a-b"),   N(VD, "c-d"),   N(VS, "e-f"),
  N(VP, "a- b"),  N(VD, "c- d"),  N(VS, "e- f"),
  N(VP, "a - b"), N(VD, "c - d"), N(VS, "e - f"),
  N(VP, "a -b"),  N(VD, "c -d"),  N(VS, "e -f"),
    })
);

ADD_CASE_TO_GROUP("simple seq flow, scalars with special chars, left-bracket",
R"([
 #a[b,
 "c[d",   'e[f',
 #a[ b,
 "c[ d",   'e[ f',
 #a [ b,
 "c [ d",   'e [ f',
 #a [b,
 "c [d",   'e [f',
])",
N(SFM, L{
  /*N(VP, "a[b"),  */ N(VD, "c[d"),   N(VS, "e[f"),
  /*N(VP, "a[ b"), */ N(VD, "c[ d"),  N(VS, "e[ f"),
  /*N(VP, "a [ b"),*/ N(VD, "c [ d"), N(VS, "e [ f"),
  /*N(VP, "a [b"), */ N(VD, "c [d"),  N(VS, "e [f"),
    })
);

ADD_CASE_TO_GROUP("simple seq block, scalars with special chars, left-bracket",
R"(- a[b
- "c[d"
- 'e[f'
- a[ b
- "c[ d"
- 'e[ f'
- a [ b
- "c [ d"
- 'e [ f'
- a [b
- "c [d"
- 'e [f'
)",
N(SB, L{
  N(VP, "a[b"),   N(VD, "c[d"),   N(VS, "e[f"),
  N(VP, "a[ b"),  N(VD, "c[ d"),  N(VS, "e[ f"),
  N(VP, "a [ b"), N(VD, "c [ d"), N(VS, "e [ f"),
  N(VP, "a [b"),  N(VD, "c [d"),  N(VS, "e [f"),
    })
);

ADD_CASE_TO_GROUP("simple seq flow, scalars with special chars, right-bracket",
R"([
# a]b,
   "c]d",   'e]f',
# a] b,
   "c] d",   'e] f',
# a ] b,
   "c ] d",   'e ] f',
# a ]b,
   "c ]d",   'e ]f',
])",
N(SFM, L{
  /*N(VP, "a]b"), */  N(VD, "c]d"),   N(VS, "e]f"),
  /*N(VP, "a] b"), */ N(VD, "c] d"),  N(VS, "e] f"),
  /*N(VP, "a ] b"),*/ N(VD, "c ] d"), N(VS, "e ] f"),
  /*N(VP, "a ]b"), */ N(VD, "c ]d"),  N(VS, "e ]f"),
    })
);

ADD_CASE_TO_GROUP("simple seq block, scalars with special chars, right-bracket",
R"(- a]b
- "c]d"
- 'e]f'
- a] b
- "c] d"
- 'e] f'
- a ] b
- "c ] d"
- 'e ] f'
- a ]b
- "c ]d"
- 'e ]f'
)",
N(SB, L{
  N(VP, "a]b"),   N(VD, "c]d"),   N(VS, "e]f"),
  N(VP, "a] b"),  N(VD, "c] d"),  N(VS, "e] f"),
  N(VP, "a ] b"), N(VD, "c ] d"), N(VS, "e ] f"),
  N(VP, "a ]b"),  N(VD, "c ]d"),  N(VS, "e ]f"),
    })
);

ADD_CASE_TO_GROUP("simple seq flow, scalars with special chars, left-curly",
R"([
# a{b,
   "c{d",   'e{f',
# a{ b,
   "c{ d",   'e{ f',
# a { b,
   "c { d",   'e { f',
# a {b,
   "c {d",   'e {f',
])",
N(SFM, L{
  /*N(VP, "a{b"), */  N(VD, "c{d"),   N(VS, "e{f"),
  /*N(VP, "a{ b"), */ N(VD, "c{ d"),  N(VS, "e{ f"),
  /*N(VP, "a { b"),*/ N(VD, "c { d"), N(VS, "e { f"),
  /*N(VP, "a {b"), */ N(VD, "c {d"),  N(VS, "e {f"),
    })
);

ADD_CASE_TO_GROUP("simple seq block, scalars with special chars, left-curly",
R"(- a{b
- "c{d"
- 'e{f'
- a{ b
- "c{ d"
- 'e{ f'
- a { b
- "c { d"
- 'e { f'
- a {b
- "c {d"
- 'e {f'
)",
N(SB, L{
  N(VP, "a{b"),   N(VD, "c{d"),   N(VS, "e{f"),
  N(VP, "a{ b"),  N(VD, "c{ d"),  N(VS, "e{ f"),
  N(VP, "a { b"), N(VD, "c { d"), N(VS, "e { f"),
  N(VP, "a {b"),  N(VD, "c {d"),  N(VS, "e {f"),
    })
);

ADD_CASE_TO_GROUP("simple seq flow, scalars with special chars, right-curly",
R"([
# a}b,
   "c}d",   'e}f',
# a} b,
   "c} d",   'e} f',
# a } b,
   "c } d",   'e } f',
# a }b,
   "c }d",   'e }f',
])",
N(SFM, L{
  /*N(VP, "a}b"), */  N(VD, "c}d"),   N(VS, "e}f"),
  /*N(VP, "a} b"), */ N(VD, "c} d"),  N(VS, "e} f"),
  /*N(VP, "a } b"),*/ N(VD, "c } d"), N(VS, "e } f"),
  /*N(VP, "a }b"), */ N(VD, "c }d"),  N(VS, "e }f"),
    })
);

ADD_CASE_TO_GROUP("simple seq block, scalars with special chars, right-curly",
R"(- a}b
- "c}d"
- 'e}f'
- a} b
- "c} d"
- 'e} f'
- a } b
- "c } d"
- 'e } f'
- a }b
- "c }d"
- 'e }f'
)",
N(SB, L{
  N(VP, "a}b"),   N(VD, "c}d"),   N(VS, "e}f"),
  N(VP, "a} b"),  N(VD, "c} d"),  N(VS, "e} f"),
  N(VP, "a } b"), N(VD, "c } d"), N(VS, "e } f"),
  N(VP, "a }b"),  N(VD, "c }d"),  N(VS, "e }f"),
    })
);

// see https://github.com/biojppm/rapidyaml/issues/28
ADD_CASE_TO_GROUP("simple seq - indentless jumps",
R"(enemy:
- actors:
  - {name: Enemy_Bokoblin_Junior, value: 4.0}
  - {name: Enemy_Bokoblin_Middle, value: 16.0}
  - {name: Enemy_Bokoblin_Senior, value: 32.0}
  - {name: Enemy_Bokoblin_Dark, value: 48.0}
  species: BokoblinSeries
  more: attributes
- wtf enemy
enemy2:
  - actors:
      - {name: Enemy_Bokoblin_Junior, value: 4.0}
      - {name: Enemy_Bokoblin_Middle, value: 16.0}
      - {name: Enemy_Bokoblin_Senior, value: 32.0}
      - {name: Enemy_Bokoblin_Dark, value: 48.0}
    species: BokoblinSeries
    more: attributes
  - wtf enemy2
)",
N(MB, L{ // 0, map
  N(KP|SB, "enemy", L{ // 1, keyseq
    N(MB, L{ // 2, map
      N(KP|SB, "actors", L{ // 3, keyseq
        N(MFS, L{N(KP|VP, "name", "Enemy_Bokoblin_Junior"), N(KP|VP, "value", "4.0"),}), // 4, map + 5,6
        N(MFS, L{N(KP|VP, "name", "Enemy_Bokoblin_Middle"), N(KP|VP, "value", "16.0"),}), // 7, map + 8,9
        N(MFS, L{N(KP|VP, "name", "Enemy_Bokoblin_Senior"), N(KP|VP, "value", "32.0"),}), // 10, map + 11,12
        N(MFS, L{N(KP|VP, "name", "Enemy_Bokoblin_Dark"), N(KP|VP, "value", "48.0"),}), // 13, map + 14,15
      }),
      N(KP|VP, "species", "BokoblinSeries"), // 16, keyval
      N(KP|VP, "more", "attributes"), // 17, keyval
    }),
    N(VP, "wtf enemy"), // 18
  }),
  N(KP|SB, "enemy2", L{ // 19, keyseq
    N(MB, L{ // 20, map
      N(KP|SB, "actors", L{ // 21, keyseq
        N(MFS, L{N(KP|VP, "name", "Enemy_Bokoblin_Junior"), N(KP|VP, "value", "4.0"),}),
        N(MFS, L{N(KP|VP, "name", "Enemy_Bokoblin_Middle"), N(KP|VP, "value", "16.0"),}),
        N(MFS, L{N(KP|VP, "name", "Enemy_Bokoblin_Senior"), N(KP|VP, "value", "32.0"),}),
        N(MFS, L{N(KP|VP, "name", "Enemy_Bokoblin_Dark"), N(KP|VP, "value", "48.0"),}),
      }),
      N(KP|VP, "species", "BokoblinSeries"),
      N(KP|VP, "more", "attributes"),
    }),
    N(VP, "wtf enemy2"),
  }),
})
);

ADD_CASE_TO_GROUP("simple seq, invalid character 1", EXPECT_PARSE_ERROR,
R"(- 0   # this is a foo
}
)",
  Location(2, 1)
);

ADD_CASE_TO_GROUP("simple seq, invalid character 2", EXPECT_PARSE_ERROR,
R"(- 0   # this is a foo
]
)",
  Location(2, 1)
);

ADD_CASE_TO_GROUP("simple seq, invalid character 3", EXPECT_PARSE_ERROR,
R"(- 0   # this is a foo
:
)",
  Location(2, 1)
);

ADD_CASE_TO_GROUP("simple seq, invalid character 4", EXPECT_PARSE_ERROR,
R"(- 0   # this is a foo
abcdef!
)",
  Location(2, 1)
);

ADD_CASE_TO_GROUP("simple seq flow, missing val, 1", EXPECT_PARSE_ERROR,
R"([,]
)",
  Location(1, 2)
);

ADD_CASE_TO_GROUP("simple seq flow, missing val, 2", EXPECT_PARSE_ERROR,
R"([ ,]
)",
  Location(1, 3)
);

ADD_CASE_TO_GROUP("simple seq flow, missing val, 3", EXPECT_PARSE_ERROR,
R"([ , ]
)",
  Location(1, 3)
);

ADD_CASE_TO_GROUP("simple seq flow, missing val, 4", EXPECT_PARSE_ERROR,
R"([ , val]
)",
  Location(1, 3)
);

ADD_CASE_TO_GROUP("simple seq flow, missing val, 5", EXPECT_PARSE_ERROR,
R"([ , , ]
)",
  Location(1, 3)
);

ADD_CASE_TO_GROUP("simple seq flow, seqimap, at line end",
R"([a: 

b]
)",
N(SFM, L{N(MFM, L{N(KP|VP, "a", "b")})})
);

}

} // namespace yml
} // namespace c4
