Skip to content

Commit c3e3138

Browse files
biojppmbiojppm
committed
wip
1 parent b8bdfc3 commit c3e3138

5 files changed

Lines changed: 173 additions & 130 deletions

File tree

‎ext/c4core‎

‎src/c4/yml/evt/extra/event_handler_ints.hpp‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -56,6 +56,37 @@ typedef enum : DataType {
5656
/// respectively the string's offset and length
5757
HAS_STR = SCLR|ALIA|ANCH|TAG_
5858
} EventFlags;
59+
60+
struct symbol { EventFlags value; const char* name; };
61+
inline C4_NO_INLINE symbol const* symbols(size_t *num_symbols) noexcept
62+
{
63+
static constexpr const symbol syms[] = {
64+
{KEY_, "KEY_"},
65+
{VAL_, "VAL_"},
66+
{SCLR, "SCLR"},
67+
{BSEQ, "BSEQ"},
68+
{ESEQ, "ESEQ"},
69+
{BMAP, "BMAP"},
70+
{EMAP, "EMAP"},
71+
{ALIA, "ALIA"},
72+
{ANCH, "ANCH"},
73+
{TAG_, "TAG_"},
74+
{PLAI, "PLAI"},
75+
{SQUO, "SQUO"},
76+
{DQUO, "DQUO"},
77+
{LITL, "LITL"},
78+
{FOLD, "FOLD"},
79+
{FLOW, "FLOW"},
80+
{BLCK, "BLCK"},
81+
{BDOC, "BDOC"},
82+
{EDOC, "EDOC"},
83+
{BSTR, "BSTR"},
84+
{ESTR, "ESTR"},
85+
{EXPL, "EXPL"},
86+
};
87+
*num_symbols = sizeof(syms) / sizeof(syms[0]);
88+
return syms;
89+
}
5990
} // namespace ievt
6091

6192

‎src/c4/yml/evt/extra/event_handler_test_suite.hpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@
1313
#endif
1414

1515
#ifndef _C4_YML_EVT_EXTRA_STRING_HPP_
16-
#include "./string.hpp"
16+
#include "c4/yml/evt/extra/string.hpp"
1717
#endif
1818

1919
C4_SUPPRESS_WARNING_GCC_CLANG_PUSH

‎test/test_int_events.cpp‎

Lines changed: 5 additions & 128 deletions
Original file line numberDiff line numberDiff line change
@@ -1,147 +1,24 @@
1-
#include <c4/yml/evt/extra/event_handler_ints.hpp>
2-
#include <c4/bitmask.hpp>
3-
#include <vector>
41
#include "test_lib/test_case.hpp"
5-
6-
namespace c4 {
7-
8-
using EventFlags = c4::yml::evt::extra::ievt::EventFlags;
9-
10-
template<>
11-
c4::EnumSymbols<EventFlags> const esyms<EventFlags>()
12-
{
13-
static constexpr typename c4::EnumSymbols<EventFlags>::Sym syms[] = {
14-
{yml::evt::extra::ievt::KEY_, "KEY_"},
15-
{yml::evt::extra::ievt::VAL_, "VAL_"},
16-
{yml::evt::extra::ievt::SCLR, "SCLR"},
17-
{yml::evt::extra::ievt::BSEQ, "BSEQ"},
18-
{yml::evt::extra::ievt::ESEQ, "ESEQ"},
19-
{yml::evt::extra::ievt::BMAP, "BMAP"},
20-
{yml::evt::extra::ievt::EMAP, "EMAP"},
21-
{yml::evt::extra::ievt::ALIA, "ALIA"},
22-
{yml::evt::extra::ievt::ANCH, "ANCH"},
23-
{yml::evt::extra::ievt::TAG_, "TAG_"},
24-
{yml::evt::extra::ievt::PLAI, "PLAI"},
25-
{yml::evt::extra::ievt::SQUO, "SQUO"},
26-
{yml::evt::extra::ievt::DQUO, "DQUO"},
27-
{yml::evt::extra::ievt::LITL, "LITL"},
28-
{yml::evt::extra::ievt::FOLD, "FOLD"},
29-
{yml::evt::extra::ievt::FLOW, "FLOW"},
30-
{yml::evt::extra::ievt::BLCK, "BLCK"},
31-
{yml::evt::extra::ievt::BDOC, "BDOC"},
32-
{yml::evt::extra::ievt::EDOC, "EDOC"},
33-
{yml::evt::extra::ievt::BSTR, "BSTR"},
34-
{yml::evt::extra::ievt::ESTR, "ESTR"},
35-
{yml::evt::extra::ievt::EXPL, "EXPL"},
36-
};
37-
return c4::EnumSymbols<EventFlags>(syms);
38-
}
2+
#include "test_lib/test_events_int.hpp"
3+
#include <c4/yml/evt/extra/event_handler_ints.hpp>
394

405

6+
namespace c4 {
417
namespace yml {
428
namespace evt {
439
namespace extra {
4410

4511

46-
// provide a structured input for the events, grouping the relevant
47-
// data in a single structure
48-
struct IntEventWithScalar
49-
{
50-
ievt::DataType flags, str_start, str_len;
51-
csubstr scalar;
52-
bool needs_filter;
53-
IntEventWithScalar(ievt::DataType t, ievt::DataType start=0, ievt::DataType len=0, csubstr sclr={}, bool needs_filter_=false)
54-
: flags(t)
55-
, str_start(start)
56-
, str_len(len)
57-
, scalar(sclr)
58-
, needs_filter(needs_filter_)
59-
{
60-
}
61-
size_t required_size() const { return (flags & ievt::HAS_STR) ? 3u : 1u; }
62-
};
63-
64-
6512
struct IntEventsCase
6613
{
6714
const char *file;
6815
const int line;
6916
csubstr yaml;
7017
const std::vector<IntEventWithScalar> evt;
7118

72-
size_t expected_size() const
73-
{
74-
size_t sz = 0;
75-
for(IntEventWithScalar const& e : evt)
76-
sz += e.required_size();
77-
return sz;
78-
}
7919
void testeq(ievt::DataType const* actual, size_t actual_size, csubstr parsed_source) const
8020
{
81-
int status = true;
82-
size_t num_events_expected = evt.size();
83-
size_t num_ints_expected = expected_size();
84-
85-
EXPECT_EQ(actual_size, num_ints_expected);
86-
status = (actual_size == num_ints_expected);
87-
88-
char actualbuf[100];
89-
char expectedbuf[100];
90-
for(size_t i = 0, ie = 0; ie < num_events_expected; ++ie)
91-
{
92-
EXPECT_LT(i, actual_size);
93-
if (i >= actual_size)
94-
break;
95-
size_t reqsize_actual = c4::bm2str<ievt::EventFlags>(actual[i] & ievt::MASK, actualbuf, sizeof(actualbuf));
96-
size_t reqsize_expected = c4::bm2str<ievt::EventFlags>(evt[ie].flags & ievt::MASK, expectedbuf, sizeof(expectedbuf));
97-
ASSERT_GT(reqsize_actual, 0u);
98-
ASSERT_GT(reqsize_expected, 0u);
99-
ASSERT_LT(reqsize_actual, sizeof(actualbuf));
100-
ASSERT_LT(reqsize_expected, sizeof(expectedbuf));
101-
csubstr actual_str = {actualbuf, reqsize_actual-1u};
102-
csubstr expected_str = {expectedbuf, reqsize_expected-1u};
103-
#define _test_eq(fmt, lhs, rhs, ...) \
104-
do \
105-
{ \
106-
_c4dbgpf("status={} cmp={} evt={} i={}: {}={} {}={} " fmt, status, (lhs == rhs), ie, i, #lhs, lhs, #rhs, rhs, __VA_ARGS__); \
107-
status &= (lhs == rhs); \
108-
EXPECT_EQ(lhs, rhs); \
109-
} while(0)
110-
_test_eq("actual={} expected={}", actual[i], evt[ie].flags, actual_str, expected_str);
111-
if((evt[ie].flags & ievt::HAS_STR) && (actual[i] & ievt::HAS_STR))
112-
{
113-
_test_eq("", evt[ie].str_start, actual[i + 1], 0);
114-
_test_eq("", evt[ie].str_len, actual[i + 2], 0);
115-
bool safeactual = (i + 2 < actual_size) && (actual[i + 1] < (int)parsed_source.len && actual[i + 1] + actual[i + 2] <= (int)parsed_source.len);
116-
bool safeexpected = (evt[ie].str_start < (int)parsed_source.len && evt[ie].str_start + evt[ie].str_len <= (int)parsed_source.len);
117-
_test_eq("", safeactual, true, 0);
118-
_test_eq("", safeactual, safeexpected, 0);
119-
if(safeactual && safeexpected)
120-
{
121-
csubstr evtstr = parsed_source.sub((size_t)evt[ie].str_start, (size_t)evt[ie].str_len);
122-
csubstr actualstr = parsed_source.sub((size_t)actual[i + 1], (size_t)actual[i + 2]);
123-
_test_eq(" ref=[{}]~~~{}~~~ vs act=[{}]~~~{}~~~",
124-
evt[ie].scalar, actualstr,
125-
evt[ie].scalar.len, evt[ie].scalar,
126-
actualstr.len, actualstr);
127-
if( ! evt[ie].needs_filter)
128-
{
129-
_test_eq(" exp=[{}]~~~{}~~~ vs act=[{}]~~~{}~~~",
130-
evtstr, actualstr,
131-
evtstr.len, evtstr,
132-
actualstr.len, actualstr);
133-
}
134-
}
135-
}
136-
i += (actual[i] & ievt::HAS_STR) ? 3u : 1u;
137-
}
138-
RYML_TRACE_FMT("defined in:\n{}:{}\n"
139-
"input:[{}]~~~{}~~~\n"
140-
"parsed:[{}]~~~{}~~~\n",
141-
file, line,
142-
yaml.len, yaml,
143-
parsed_source.len, parsed_source);
144-
EXPECT_TRUE(status);
21+
test_events_ints(evt.data(), evt.size(), actual, actual_size, yaml, parsed_source, file, line);
14522
}
14623
};
14724

@@ -448,7 +325,7 @@ struct IntEventsTestHelper
448325
std::vector<ievt::DataType> actual;
449326
IntEventsTestHelper(IntEventsCase const& ec_)
450327
: ec(ec_)
451-
, required_size_expected(ec.expected_size())
328+
, required_size_expected(num_ints(ec.evt.data(), ec.evt.size()))
452329
, handler()
453330
, parser(&handler)
454331
, src_copy()

‎test/test_lib/test_events_int.hpp‎

Lines changed: 135 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,135 @@
1+
#ifndef _TEST_EVENTS_INTS_HPP_
2+
#define _TEST_EVENTS_INTS_HPP_
3+
4+
#include <c4/yml/evt/extra/event_handler_ints.hpp>
5+
#include <c4/bitmask.hpp>
6+
#include <gtest/gtest.h>
7+
8+
namespace c4 {
9+
using EventFlags = c4::yml::evt::extra::ievt::EventFlags;
10+
template<>
11+
c4::EnumSymbols<EventFlags> const esyms<EventFlags>()
12+
{
13+
using namespace yml::evt::extra::ievt;
14+
static_assert(offsetof(symbol, value) == offsetof(c4::EnumSymbols<EventFlags>::Sym, value), "wrong offset");
15+
static_assert(offsetof(symbol, name) == offsetof(c4::EnumSymbols<EventFlags>::Sym, name), "wrong offset");
16+
size_t numsyms = 0;
17+
symbol const* syms = symbols(&numsyms);
18+
return c4::EnumSymbols<EventFlags>((c4::EnumSymbols<EventFlags>::Sym const*)syms, numsyms);
19+
}
20+
inline csubstr mkstring(c4::yml::evt::extra::ievt::DataType flags, substr buf)
21+
{
22+
using namespace yml::evt::extra;
23+
size_t reqsize = c4::bm2str<ievt::EventFlags>((flags & ievt::MASK), buf.str, buf.len);
24+
C4_CHECK(reqsize > 0u);
25+
C4_CHECK(reqsize < buf.len);
26+
return buf.offs(0, 1);
27+
}
28+
} // namespace c4
29+
30+
31+
namespace c4 {
32+
namespace yml {
33+
namespace evt {
34+
namespace extra {
35+
36+
// provide a structured input for the event integers, grouping the
37+
// relevant data for the event in a single structure to simplify
38+
// specifying events in tests
39+
struct IntEventWithScalar
40+
{
41+
ievt::DataType flags, str_start, str_len;
42+
csubstr scalar;
43+
bool needs_filter;
44+
IntEventWithScalar(ievt::DataType t, ievt::DataType start=0, ievt::DataType len=0, csubstr sclr={}, bool needs_filter_=false)
45+
: flags(t)
46+
, str_start(start)
47+
, str_len(len)
48+
, scalar(sclr)
49+
, needs_filter(needs_filter_)
50+
{
51+
}
52+
size_t required_size() const { return (flags & ievt::HAS_STR) ? 3u : 1u; }
53+
};
54+
55+
56+
inline C4_NO_INLINE size_t num_ints(IntEventWithScalar const *evt, size_t evt_size)
57+
{
58+
size_t sz = 0;
59+
for(size_t i = 0; i < evt_size; ++i)
60+
sz += evt[i].required_size();
61+
return sz;
62+
}
63+
64+
inline void C4_NO_INLINE test_events_ints(IntEventWithScalar const* expected, size_t expected_sz,
65+
ievt::DataType const* actual, size_t actual_sz,
66+
csubstr yaml,
67+
csubstr parsed_source,
68+
const char *file, int line)
69+
{
70+
int status = true;
71+
size_t num_ints_expected = num_ints(expected, expected_sz);
72+
73+
EXPECT_EQ(actual_sz, num_ints_expected);
74+
status = (actual_sz == num_ints_expected);
75+
76+
char actualbuf[100];
77+
char expectedbuf[100];
78+
for(size_t i = 0, ie = 0; ie < expected_sz; ++ie)
79+
{
80+
EXPECT_LT(i, actual_sz);
81+
if (i >= actual_sz)
82+
break;
83+
csubstr actual_str = mkstring(actual[i], actualbuf);
84+
csubstr expected_str = mkstring(expected[ie].flags, expectedbuf);
85+
#define _test_eq(fmt, lhs, rhs, ...) \
86+
do \
87+
{ \
88+
_c4dbgpf("status={} cmp={} evt={} i={}: {}={} {}={} " fmt, status, (lhs == rhs), ie, i, #lhs, lhs, #rhs, rhs, __VA_ARGS__); \
89+
status &= (lhs == rhs); \
90+
EXPECT_EQ(lhs, rhs); \
91+
} while(0)
92+
_test_eq("actual={} expected={}", actual[i], expected[ie].flags, actual_str, expected_str);
93+
if((expected[ie].flags & ievt::HAS_STR) && (actual[i] & ievt::HAS_STR))
94+
{
95+
_test_eq("", expected[ie].str_start, actual[i + 1], 0);
96+
_test_eq("", expected[ie].str_len, actual[i + 2], 0);
97+
bool safeactual = (i + 2 < actual_sz) && (actual[i + 1] < (int)parsed_source.len && actual[i + 1] + actual[i + 2] <= (int)parsed_source.len);
98+
bool safeexpected = (expected[ie].str_start < (int)parsed_source.len && expected[ie].str_start + expected[ie].str_len <= (int)parsed_source.len);
99+
_test_eq("", safeactual, true, 0);
100+
_test_eq("", safeactual, safeexpected, 0);
101+
if(safeactual && safeexpected)
102+
{
103+
csubstr evtstr = parsed_source.sub((size_t)expected[ie].str_start, (size_t)expected[ie].str_len);
104+
csubstr actualstr = parsed_source.sub((size_t)actual[i + 1], (size_t)actual[i + 2]);
105+
_test_eq(" ref=[{}]~~~{}~~~ vs act=[{}]~~~{}~~~",
106+
expected[ie].scalar, actualstr,
107+
expected[ie].scalar.len, expected[ie].scalar,
108+
actualstr.len, actualstr);
109+
if( ! expected[ie].needs_filter)
110+
{
111+
_test_eq(" exp=[{}]~~~{}~~~ vs act=[{}]~~~{}~~~",
112+
evtstr, actualstr,
113+
evtstr.len, evtstr,
114+
actualstr.len, actualstr);
115+
}
116+
}
117+
}
118+
i += (actual[i] & ievt::HAS_STR) ? 3u : 1u;
119+
}
120+
RYML_TRACE_FMT("defined in:\n{}:{}\n"
121+
"input:[{}]~~~{}~~~\n"
122+
"parsed:[{}]~~~{}~~~\n",
123+
file, line,
124+
yaml.len, yaml,
125+
parsed_source.len, parsed_source);
126+
EXPECT_TRUE(status);
127+
}
128+
129+
130+
} // namespace extra
131+
} // namespace evt
132+
} // namespace yml
133+
} // namespace c4
134+
135+
#endif /* _TEST_EVENTS_INTS_HPP_ */

0 commit comments

Comments
 (0)