Inside Bitcoin

1251    BOOST_CHECK(success);
1252    BOOST_CHECK_EQUAL(SpanToStr(sp), "xy,z()");
1253
1254    success = Func("xy", sp);
1255    BOOST_CHECK(!success);
1256
1257    // Expr(...): return expression that span begins with, update span to skip it
1258    std::span<const char> result;
1259
1260    input = "(n*(n-1))/2";
1261    sp = input;
1262    result = Expr(sp);
1263    BOOST_CHECK_EQUAL(SpanToStr(result), "(n*(n-1))/2");
1264    BOOST_CHECK_EQUAL(SpanToStr(sp), "");
1265
1266    input = "foo,bar";
1267    sp = input;
1268    result = Expr(sp);
1269    BOOST_CHECK_EQUAL(SpanToStr(result), "foo");
1270    BOOST_CHECK_EQUAL(SpanToStr(sp), ",bar");
1271
1272    input = "(aaaaa,bbbbb()),c";
1273    sp = input;
1274    result = Expr(sp);
1275    BOOST_CHECK_EQUAL(SpanToStr(result), "(aaaaa,bbbbb())");
1276    BOOST_CHECK_EQUAL(SpanToStr(sp), ",c");
1277
1278    input = "xyz)foo";
1279    sp = input;
1280    result = Expr(sp);
1281    BOOST_CHECK_EQUAL(SpanToStr(result), "xyz");
1282    BOOST_CHECK_EQUAL(SpanToStr(sp), ")foo");
1283
1284    input = "((a),(b),(c)),xxx";
1285    sp = input;
1286    result = Expr(sp);
1287    BOOST_CHECK_EQUAL(SpanToStr(result), "((a),(b),(c))");
1288    BOOST_CHECK_EQUAL(SpanToStr(sp), ",xxx");
1289
1290    // Split(...): split a string on every instance of sep, return vector
1291    std::vector<std::span<const char>> results;
1292
1293    input = "xxx";
1294    results = Split(input, 'x');
1295    BOOST_CHECK_EQUAL(results.size(), 4U);
1296    BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
1297    BOOST_CHECK_EQUAL(SpanToStr(results[1]), "");
1298    BOOST_CHECK_EQUAL(SpanToStr(results[2]), "");
1299    BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
1300
1301    input = "one#two#three";
1302    results = Split(input, '-');
1303    BOOST_CHECK_EQUAL(results.size(), 1U);
1304    BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one#two#three");
1305
1306    input = "one#two#three";
1307    results = Split(input, '#');
1308    BOOST_CHECK_EQUAL(results.size(), 3U);
1309    BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one");
1310    BOOST_CHECK_EQUAL(SpanToStr(results[1]), "two");
1311    BOOST_CHECK_EQUAL(SpanToStr(results[2]), "three");
1312
1313    results = Split(input, '#', /*include_sep=*/true);
1314    BOOST_CHECK_EQUAL(results.size(), 3U);
1315    BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one#");
1316    BOOST_CHECK_EQUAL(SpanToStr(results[1]), "two#");
1317    BOOST_CHECK_EQUAL(SpanToStr(results[2]), "three");
1318
1319    input = "*foo*bar*";
1320    results = Split(input, '*');
1321    BOOST_CHECK_EQUAL(results.size(), 4U);
1322    BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
1323    BOOST_CHECK_EQUAL(SpanToStr(results[1]), "foo");
1324    BOOST_CHECK_EQUAL(SpanToStr(results[2]), "bar");
1325    BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
1326
1327    results = Split(input, '*', /*include_sep=*/true);
1328    BOOST_CHECK_EQUAL(results.size(), 4U);
1329    BOOST_CHECK_EQUAL(SpanToStr(results[0]), "*");
1330    BOOST_CHECK_EQUAL(SpanToStr(results[1]), "foo*");
1331    BOOST_CHECK_EQUAL(SpanToStr(results[2]), "bar*");
1332    BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
1333}
1334
1335BOOST_AUTO_TEST_CASE(test_SplitString)
1336{
1337    // Empty string.
1338    {
1339        std::vector<std::string> result = SplitString("", '-');
1340        BOOST_CHECK_EQUAL(result.size(), 1);
1341        BOOST_CHECK_EQUAL(result[0], "");
1342    }
1343
1344    // Empty items.
1345    {
1346        std::vector<std::string> result = SplitString("-", '-');
1347        BOOST_CHECK_EQUAL(result.size(), 2);
1348        BOOST_CHECK_EQUAL(result[0], "");
1349        BOOST_CHECK_EQUAL(result[1], "");
1350    }
1351
1352    // More empty items.
1353    {
1354        std::vector<std::string> result = SplitString("--", '-');
1355        BOOST_CHECK_EQUAL(result.size(), 3);
1356        BOOST_CHECK_EQUAL(result[0], "");
1357        BOOST_CHECK_EQUAL(result[1], "");
1358        BOOST_CHECK_EQUAL(result[2], "");
1359    }
1360
1361    // Separator is not present.
1362    {
1363        std::vector<std::string> result = SplitString("abc", '-');
1364        BOOST_CHECK_EQUAL(result.size(), 1);
1365        BOOST_CHECK_EQUAL(result[0], "abc");
1366    }
1367
1368    // Basic behavior.
1369    {
1370        std::vector<std::string> result = SplitString("a-b", '-');
1371        BOOST_CHECK_EQUAL(result.size(), 2);
1372        BOOST_CHECK_EQUAL(result[0], "a");
1373        BOOST_CHECK_EQUAL(result[1], "b");
1374    }
1375
1376    // Case-sensitivity of the separator.
1377    {
1378        std::vector<std::string> result = SplitString("AAA", 'a');
1379        BOOST_CHECK_EQUAL(result.size(), 1);
1380        BOOST_CHECK_EQUAL(result[0], "AAA");
1381    }
1382
1383    // multiple split characters
1384    {
1385        using V = std::vector<std::string>;
1386        BOOST_TEST(SplitString("a,b.c:d;e", ",;") == V({"a", "b.c:d", "e"}));
1387        BOOST_TEST(SplitString("a,b.c:d;e", ",;:.") == V({"a", "b", "c", "d", "e"}));
1388        BOOST_TEST(SplitString("a,b.c:d;e", "") == V({"a,b.c:d;e"}));
1389        BOOST_TEST(SplitString("aaa", "bcdefg") == V({"aaa"}));
1390        BOOST_TEST(SplitString("x\0a,b"s, "\0"s) == V({"x", "a,b"}));
1391        BOOST_TEST(SplitString("x\0a,b"s, '\0') == V({"x", "a,b"}));
1392        BOOST_TEST(SplitString("x\0a,b"s, "\0,"s) == V({"x", "a", "b"}));
1393        BOOST_TEST(SplitString("abcdefg", "bcd") == V({"a", "", "", "efg"}));
1394    }
1395}
1396
1397BOOST_AUTO_TEST_CASE(test_LogEscapeMessage)
1398{
1399    // ASCII and UTF-8 must pass through unaltered.
1400    BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage("Valid log message貓"), "Valid log message貓");
1401    // Newlines must pass through unaltered.
1402    BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage("Message\n with newlines\n"), "Message\n with newlines\n");
1403    // Other control characters are escaped in C syntax.
1404    BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage("\x01\x7f Corrupted log message\x0d"), R"(\x01\x7f Corrupted log message\x0d)");
1405    // Embedded NULL characters are escaped too.
1406    const std::string NUL("O\x00O", 3);
1407    BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage(NUL), R"(O\x00O)");
1408}
1409
1410namespace {
1411
1412struct Tracker
1413{
1414    //! Points to the original object (possibly itself) we moved/copied from
1415    const Tracker* origin;
1416    //! How many copies where involved between the original object and this one (moves are not counted)
1417    int copies{0};
1418
1419    Tracker() noexcept : origin(this) {}
1420    Tracker(const Tracker& t) noexcept : origin(t.origin), copies(t.copies + 1) {}
1421    Tracker(Tracker&& t) noexcept : origin(t.origin), copies(t.copies) {}
1422    Tracker& operator=(const Tracker& t) noexcept
1423    {
1424        if (this != &t) {
1425            origin = t.origin;
1426            copies = t.copies + 1;
1427        }
1428        return *this;
1429    }
1430};
1431
1432}
1433
1434BOOST_AUTO_TEST_CASE(test_tracked_vector)
1435{
1436    Tracker t1;
1437    Tracker t2;
1438    Tracker t3;
1439
1440    BOOST_CHECK(t1.origin == &t1);
1441    BOOST_CHECK(t2.origin == &t2);
1442    BOOST_CHECK(t3.origin == &t3);
1443
1444    auto v1 = Vector(t1);
1445    BOOST_CHECK_EQUAL(v1.size(), 1U);
1446    BOOST_CHECK(v1[0].origin == &t1);
1447    BOOST_CHECK_EQUAL(v1[0].copies, 1);
1448
1449    auto v2 = Vector(std::move(t2));
1450    BOOST_CHECK_EQUAL(v2.size(), 1U);
1451    BOOST_CHECK(v2[0].origin == &t2); // NOLINT(*-use-after-move)
1452    BOOST_CHECK_EQUAL(v2[0].copies, 0);
1453
1454    auto v3 = Vector(t1, std::move(t2));
1455    BOOST_CHECK_EQUAL(v3.size(), 2U);
1456    BOOST_CHECK(v3[0].origin == &t1);
1457    BOOST_CHECK(v3[1].origin == &t2); // NOLINT(*-use-after-move)
1458    BOOST_CHECK_EQUAL(v3[0].copies, 1);
1459    BOOST_CHECK_EQUAL(v3[1].copies, 0);
1460
1461    auto v4 = Vector(std::move(v3[0]), v3[1], std::move(t3));
1462    BOOST_CHECK_EQUAL(v4.size(), 3U);
1463    BOOST_CHECK(v4[0].origin == &t1);
1464    BOOST_CHECK(v4[1].origin == &t2);
1465    BOOST_CHECK(v4[2].origin == &t3); // NOLINT(*-use-after-move)
1466    BOOST_CHECK_EQUAL(v4[0].copies, 1);
1467    BOOST_CHECK_EQUAL(v4[1].copies, 1);
1468    BOOST_CHECK_EQUAL(v4[2].copies, 0);
1469
1470    auto v5 = Cat(v1, v4);
1471    BOOST_CHECK_EQUAL(v5.size(), 4U);
1472    BOOST_CHECK(v5[0].origin == &t1);
1473    BOOST_CHECK(v5[1].origin == &t1);
1474    BOOST_CHECK(v5[2].origin == &t2);
1475    BOOST_CHECK(v5[3].origin == &t3);
1476    BOOST_CHECK_EQUAL(v5[0].copies, 2);
1477    BOOST_CHECK_EQUAL(v5[1].copies, 2);
1478    BOOST_CHECK_EQUAL(v5[2].copies, 2);
1479    BOOST_CHECK_EQUAL(v5[3].copies, 1);
1480
1481    auto v6 = Cat(std::move(v1), v3);
1482    BOOST_CHECK_EQUAL(v6.size(), 3U);
1483    BOOST_CHECK(v6[0].origin == &t1);
1484    BOOST_CHECK(v6[1].origin == &t1);
1485    BOOST_CHECK(v6[2].origin == &t2);
1486    BOOST_CHECK_EQUAL(v6[0].copies, 1);
1487    BOOST_CHECK_EQUAL(v6[1].copies, 2);
1488    BOOST_CHECK_EQUAL(v6[2].copies, 1);
1489
1490    auto v7 = Cat(v2, std::move(v4));
1491    BOOST_CHECK_EQUAL(v7.size(), 4U);
1492    BOOST_CHECK(v7[0].origin == &t2);
1493    BOOST_CHECK(v7[1].origin == &t1);
1494    BOOST_CHECK(v7[2].origin == &t2);
1495    BOOST_CHECK(v7[3].origin == &t3);
1496    BOOST_CHECK_EQUAL(v7[0].copies, 1);
1497    BOOST_CHECK_EQUAL(v7[1].copies, 1);
1498    BOOST_CHECK_EQUAL(v7[2].copies, 1);
1499    BOOST_CHECK_EQUAL(v7[3].copies, 0);
1500