Skip to content

Commit 0362274

Browse files
thiagomacieirathiagomacieira
committed
Parser: apply the same memory-check update
See previous commit for more details. This just applies the same technique using malloc/mmap to the the rest of the parser tests. Signed-off-by: Thiago Macieira <[email protected]>
1 parent 57b66a8 commit 0362274

File tree

1 file changed

+83
-88
lines changed

1 file changed

+83
-88
lines changed

‎tests/parser/tst_parser.cpp

Lines changed: 83 additions & 88 deletions
Original file line numberDiff line numberDiff line change
@@ -122,13 +122,19 @@ struct ParserWrapper
122122

123123
~ParserWrapper() { freeMemory(); }
124124

125-
CborError init(const QByteArray &ba)
125+
CborError init(const QByteArray &ba, uint32_t flags = 0)
126+
{
127+
return init(ba.constData(), ba.size(), flags);
128+
}
129+
CborError init(const char *ptr, int n, uint32_t flags = 0)
126130
{
127131
freeMemory();
128-
data = allocateMemory(ba.size());
129-
memcpy(data, ba.data(), ba.size());
130-
return cbor_parser_init(data, len, 0, &parser, &first);
132+
data = allocateMemory(n);
133+
memcpy(data, ptr, len);
134+
return cbor_parser_init(data, len, flags, &parser, &first);
131135
}
136+
uint8_t *begin() { return data; }
137+
uint8_t *end() { return data + len; }
132138

133139
uint8_t *allocateMemory(size_t);
134140
void freeMemory();
@@ -244,47 +250,46 @@ bool compareFailed = true;
244250
void compareOne_real(const QByteArray &data, const QString &expected, int line, int n = -1)
245251
{
246252
compareFailed = true;
247-
CborParser parser;
248-
CborValue first;
249-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
253+
ParserWrapper w;
254+
CborError err = w.init(data);
250255
QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
251256

252-
if (cbor_value_get_type(&first) == CborArrayType) {
257+
if (cbor_value_get_type(&w.first) == CborArrayType) {
253258
size_t len;
254259
if (n >= 0) {
255-
QVERIFY(cbor_value_is_length_known(&first));
256-
QCOMPARE(cbor_value_get_array_length(&first, &len), CborNoError);
260+
QVERIFY(cbor_value_is_length_known(&w.first));
261+
QCOMPARE(cbor_value_get_array_length(&w.first, &len), CborNoError);
257262
QCOMPARE(len, size_t(len));
258263
} else {
259-
QVERIFY(!cbor_value_is_length_known(&first));
260-
QCOMPARE(cbor_value_get_array_length(&first, &len), CborErrorUnknownLength);
264+
QVERIFY(!cbor_value_is_length_known(&w.first));
265+
QCOMPARE(cbor_value_get_array_length(&w.first, &len), CborErrorUnknownLength);
261266
}
262-
} else if (cbor_value_get_type(&first) == CborMapType) {
267+
} else if (cbor_value_get_type(&w.first) == CborMapType) {
263268
size_t len;
264269
if (n >= 0) {
265-
QVERIFY(cbor_value_is_length_known(&first));
266-
QCOMPARE(cbor_value_get_map_length(&first, &len), CborNoError);
270+
QVERIFY(cbor_value_is_length_known(&w.first));
271+
QCOMPARE(cbor_value_get_map_length(&w.first, &len), CborNoError);
267272
QCOMPARE(len, size_t(len));
268273
} else {
269-
QVERIFY(!cbor_value_is_length_known(&first));
270-
QCOMPARE(cbor_value_get_map_length(&first, &len), CborErrorUnknownLength);
274+
QVERIFY(!cbor_value_is_length_known(&w.first));
275+
QCOMPARE(cbor_value_get_map_length(&w.first, &len), CborErrorUnknownLength);
271276
}
272-
} else if (cbor_value_is_text_string(&first) || cbor_value_is_byte_string(&first)) {
277+
} else if (cbor_value_is_text_string(&w.first) || cbor_value_is_byte_string(&w.first)) {
273278
size_t len;
274-
QCOMPARE(cbor_value_calculate_string_length(&first, &len), CborNoError);
275-
if (cbor_value_is_length_known(&first)) {
279+
QCOMPARE(cbor_value_calculate_string_length(&w.first, &len), CborNoError);
280+
if (cbor_value_is_length_known(&w.first)) {
276281
size_t len2;
277-
QCOMPARE(cbor_value_get_string_length(&first, &len2), CborNoError);
282+
QCOMPARE(cbor_value_get_string_length(&w.first, &len2), CborNoError);
278283
QCOMPARE(len2, len);
279284
} else {
280-
QCOMPARE(cbor_value_get_string_length(&first, &len), CborErrorUnknownLength);
285+
QCOMPARE(cbor_value_get_string_length(&w.first, &len), CborErrorUnknownLength);
281286
}
282287
}
283288

284-
CborError err2 = cbor_value_validate_basic(&first);
289+
CborError err2 = cbor_value_validate_basic(&w.first);
285290

286291
QString decoded;
287-
err = parseOne(&first, &decoded);
292+
err = parseOne(&w.first, &decoded);
288293
QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) +
289294
"\"; decoded stream:\n" + decoded.toLatin1());
290295
QCOMPARE(decoded, expected);
@@ -293,7 +298,7 @@ void compareOne_real(const QByteArray &data, const QString &expected, int line,
293298
QCOMPARE(err2, err);
294299

295300
// check that we consumed everything
296-
QCOMPARE((void*)cbor_value_get_next_byte(&first), (void*)data.constEnd());
301+
QCOMPARE((void*)cbor_value_get_next_byte(&w.first), (void*)w.end());
297302

298303
compareFailed = false;
299304
}
@@ -459,36 +464,35 @@ void tst_Parser::integers()
459464
QFETCH(qint64, expectedValue);
460465
QFETCH(bool, inInt64Range);
461466

462-
CborParser parser;
463-
CborValue first;
464-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
467+
ParserWrapper w;
468+
CborError err = w.init(data);
465469
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
466-
QVERIFY(cbor_value_is_integer(&first));
470+
QVERIFY(cbor_value_is_integer(&w.first));
467471

468472
uint64_t raw;
469-
cbor_value_get_raw_integer(&first, &raw);
473+
cbor_value_get_raw_integer(&w.first, &raw);
470474
QCOMPARE(quint64(raw), expectedRaw);
471475

472476
if (isNegative) {
473-
QVERIFY(cbor_value_is_negative_integer(&first));
474-
QVERIFY(!cbor_value_is_unsigned_integer(&first));
477+
QVERIFY(cbor_value_is_negative_integer(&w.first));
478+
QVERIFY(!cbor_value_is_unsigned_integer(&w.first));
475479
} else {
476-
QVERIFY(!cbor_value_is_negative_integer(&first));
477-
QVERIFY(cbor_value_is_unsigned_integer(&first));
480+
QVERIFY(!cbor_value_is_negative_integer(&w.first));
481+
QVERIFY(cbor_value_is_unsigned_integer(&w.first));
478482
}
479483

480484
int64_t value;
481485
if (inInt64Range) {
482-
cbor_value_get_int64(&first, &value);
486+
cbor_value_get_int64(&w.first, &value);
483487
QCOMPARE(qint64(value), expectedValue);
484488
}
485489

486-
err = cbor_value_get_int64_checked(&first, &value);
490+
err = cbor_value_get_int64_checked(&w.first, &value);
487491
QCOMPARE(err, inInt64Range ? CborNoError : CborErrorDataTooLarge);
488492

489493
int ivalue;
490494
bool inIntRange = inInt64Range && (expectedValue == int(expectedValue));
491-
err = cbor_value_get_int_checked(&first, &ivalue);
495+
err = cbor_value_get_int_checked(&w.first, &ivalue);
492496
QCOMPARE(err, inIntRange ? CborNoError : CborErrorDataTooLarge);
493497
}
494498

@@ -966,14 +970,13 @@ void tst_Parser::chunkedString_data()
966970
static void chunkedStringTest(const QByteArray &data, const QString &concatenated,
967971
QStringList &chunks, CborType ourType)
968972
{
969-
CborParser parser;
970-
CborValue first;
971-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
973+
ParserWrapper w;
974+
CborError err = w.init(data);
972975
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
973976

974977
CborValue value;
975-
QVERIFY(cbor_value_is_array(&first));
976-
err = cbor_value_enter_container(&first, &value);
978+
QVERIFY(cbor_value_is_array(&w.first));
979+
err = cbor_value_enter_container(&w.first, &value);
977980
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
978981
QVERIFY(cbor_value_is_byte_string(&value) || cbor_value_is_text_string(&value));
979982

@@ -1020,9 +1023,9 @@ static void chunkedStringTest(const QByteArray &data, const QString &concatenate
10201023
// confirm EOF
10211024
QVERIFY(cbor_value_at_end(&value));
10221025

1023-
err = cbor_value_leave_container(&first, &value);
1026+
err = cbor_value_leave_container(&w.first, &value);
10241027
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
1025-
QCOMPARE((void*)cbor_value_get_next_byte(&first), (void*)data.constEnd());
1028+
QCOMPARE((void*)cbor_value_get_next_byte(&w.first), (void*)w.end());
10261029
}
10271030

10281031
void tst_Parser::chunkedString()
@@ -1112,18 +1115,17 @@ void tst_Parser::stringLength()
11121115
QFETCH(QByteArray, data);
11131116
QFETCH(int, expected);
11141117

1115-
CborParser parser;
1116-
CborValue value;
1117-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
1118+
ParserWrapper w;
1119+
CborError err = w.init(data);
11181120
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
11191121

11201122
size_t result;
1121-
err = cbor_value_calculate_string_length(&value, &result);
1123+
err = cbor_value_calculate_string_length(&w.first, &result);
11221124
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
11231125
QCOMPARE(result, size_t(expected));
11241126

1125-
if (cbor_value_is_length_known(&value)) {
1126-
QCOMPARE(cbor_value_get_string_length(&value, &result), CborNoError);
1127+
if (cbor_value_is_length_known(&w.first)) {
1128+
QCOMPARE(cbor_value_get_string_length(&w.first, &result), CborNoError);
11271129
QCOMPARE(result, size_t(expected));
11281130
}
11291131

@@ -1207,25 +1209,24 @@ void compareOneString(const QByteArray &data, const QString &string, bool expect
12071209
{
12081210
compareFailed = true;
12091211

1210-
CborParser parser;
1211-
CborValue value;
1212-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
1212+
ParserWrapper w;
1213+
CborError err = w.init(data);
12131214
QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
12141215

12151216
bool result;
12161217
QByteArray bastring = string.toUtf8();
1217-
err = cbor_value_text_string_equals(&value, bastring.constData(), &result);
1218+
err = cbor_value_text_string_equals(&w.first, bastring.constData(), &result);
12181219
QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
12191220
QCOMPARE(result, expected);
12201221

12211222
if (expected) {
12221223
size_t len;
1223-
cbor_value_skip_tag(&value);
1224-
if (cbor_value_is_length_known(&value)) {
1225-
QCOMPARE(cbor_value_get_string_length(&value, &len), CborNoError);
1224+
cbor_value_skip_tag(&w.first);
1225+
if (cbor_value_is_length_known(&w.first)) {
1226+
QCOMPARE(cbor_value_get_string_length(&w.first, &len), CborNoError);
12261227
QCOMPARE(int(len), bastring.size());
12271228
}
1228-
QCOMPARE(cbor_value_calculate_string_length(&value, &len), CborNoError);
1229+
QCOMPARE(cbor_value_calculate_string_length(&w.first, &len), CborNoError);
12291230
QCOMPARE(int(len), bastring.size());
12301231
}
12311232

@@ -1314,13 +1315,12 @@ void tst_Parser::mapFind()
13141315
QFETCH(QByteArray, data);
13151316
QFETCH(bool, expected);
13161317

1317-
CborParser parser;
1318-
CborValue value;
1319-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
1318+
ParserWrapper w;
1319+
CborError err = w.init(data);
13201320
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
13211321

13221322
CborValue element;
1323-
err = cbor_value_map_find_value(&value, "needle", &element);
1323+
err = cbor_value_map_find_value(&w.first, "needle", &element);
13241324
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
13251325

13261326
if (expected) {
@@ -1391,21 +1391,20 @@ void tst_Parser::checkedIntegers()
13911391
QFETCH(QVariant, result);
13921392
int64_t expected = result.toLongLong();
13931393

1394-
CborParser parser;
1395-
CborValue value;
1396-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &value);
1394+
ParserWrapper w;
1395+
CborError err = w.init(data);
13971396
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
13981397

13991398
int64_t v;
1400-
err = cbor_value_get_int64_checked(&value, &v);
1399+
err = cbor_value_get_int64_checked(&w.first, &v);
14011400
if (result.isNull()) {
14021401
QCOMPARE(err, CborErrorDataTooLarge);
14031402
} else {
14041403
QCOMPARE(v, expected);
14051404
}
14061405

14071406
int v2;
1408-
err = cbor_value_get_int_checked(&value, &v2);
1407+
err = cbor_value_get_int_checked(&w.first, &v2);
14091408
if (result.isNull() || expected < std::numeric_limits<int>::min() || expected > std::numeric_limits<int>::max()) {
14101409
QCOMPARE(err, CborErrorDataTooLarge);
14111410
} else {
@@ -1664,14 +1663,13 @@ void tst_Parser::validation()
16641663
QFETCH(CborError, expectedError);
16651664

16661665
QString decoded;
1667-
CborParser parser;
1668-
CborValue first;
1669-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), flags, &parser, &first);
1666+
ParserWrapper w;
1667+
CborError err = w.init(data, uint32_t(flags));
16701668
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
16711669

1672-
CborError err2 = cbor_value_validate_basic(&first);
1673-
CborError err3 = cbor_value_validate(&first, CborValidateBasic);
1674-
err = parseOne(&first, &decoded);
1670+
CborError err2 = cbor_value_validate_basic(&w.first);
1671+
CborError err3 = cbor_value_validate(&w.first, CborValidateBasic);
1672+
err = parseOne(&w.first, &decoded);
16751673
QCOMPARE(err, expectedError);
16761674
if (!QByteArray(QTest::currentDataTag()).contains("utf8")) {
16771675
QCOMPARE(err2, expectedError);
@@ -2070,12 +2068,11 @@ void tst_Parser::resumeParsing()
20702068
QFETCH(QString, expected);
20712069

20722070
for (int len = 0; len < data.length() - 1; ++len) {
2073-
CborParser parser;
2074-
CborValue first;
2075-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), len, 0, &parser, &first);
2071+
ParserWrapper w;
2072+
CborError err = w.init(data.constData(), len);
20762073
if (!err) {
20772074
QString decoded;
2078-
err = parseOne(&first, &decoded);
2075+
err = parseOne(&w.first, &decoded);
20792076
}
20802077
if (err != CborErrorUnexpectedEOF)
20812078
qDebug() << "Length is" << len;
@@ -2104,14 +2101,13 @@ void tst_Parser::endPointer()
21042101
QFETCH(int, offset);
21052102

21062103
QString decoded;
2107-
CborParser parser;
2108-
CborValue first;
2109-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
2104+
ParserWrapper w;
2105+
CborError err = w.init(data);
21102106
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
21112107

2112-
err = parseOne(&first, &decoded);
2108+
err = parseOne(&w.first, &decoded);
21132109
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
2114-
QCOMPARE(int(first.ptr - reinterpret_cast<const quint8 *>(data.constBegin())), offset);
2110+
QCOMPARE(int(cbor_value_get_next_byte(&w.first) - w.begin()), offset);
21152111
}
21162112

21172113
void tst_Parser::recursionLimit_data()
@@ -2159,24 +2155,23 @@ void tst_Parser::recursionLimit()
21592155
{
21602156
QFETCH(QByteArray, data);
21612157

2162-
CborParser parser;
2163-
CborValue first;
2164-
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
2158+
ParserWrapper w;
2159+
CborError err = w.init(data);
21652160
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
21662161

21672162
// check that it is valid:
2168-
CborValue it = first;
2163+
CborValue it = w.first;
21692164
{
21702165
QString dummy;
21712166
err = parseOne(&it, &dummy);
21722167
QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
21732168
}
21742169

2175-
it = first;
2170+
it = w.first;
21762171
err = cbor_value_advance(&it);
21772172
QCOMPARE(err, CborErrorNestingTooDeep);
21782173

2179-
it = first;
2174+
it = w.first;
21802175
if (cbor_value_is_map(&it)) {
21812176
CborValue dummy;
21822177
err = cbor_value_map_find_value(&it, "foo", &dummy);

0 commit comments

Comments
 (0)