5#include "testing/testing.h"
8#include <initializer_list>
23using std::initializer_list;
34#define STR_N_CAT(dst_init, dst_size, src, result_expect) \
36 char dst[dst_size + 1] = dst_init; \
37 dst[dst_size] = 0xff; \
38 BLI_strncat(dst, src, dst_size); \
39 EXPECT_STREQ(dst, result_expect); \
40 EXPECT_EQ(dst[dst_size], 0xff); \
59TEST(
string, StrCopyEnsurePad)
61#define STRNCPY_ENSURE_PAD_EXPECT(src, dst_expect, dst_maxncpy) \
63 char dst[dst_maxncpy + 5]; \
64 memset(dst, 0xff, sizeof(dst)); \
65 dst[sizeof(dst) - 1] = '\0'; \
66 BLI_strncpy_ensure_pad(dst, src, '*', dst_maxncpy); \
67 EXPECT_STREQ(dst, dst_expect); \
68 EXPECT_STREQ(dst + dst_maxncpy, "\xff\xff\xff\xff"); \
83#undef STRNCPY_ENSURE_PAD_EXPECT
92TEST(
string, StrReplaceRange)
94#define STR_REPLACE_RANGE(src, size, beg, end, dst, result_expect) \
96 char string[size] = src; \
97 BLI_string_replace_range(string, sizeof(string), beg, end, dst); \
98 EXPECT_STREQ(string, result_expect); \
124#undef STR_REPLACE_RANGE
136 const char delim[] = {
'-',
'.',
'_',
'~',
'\\',
'\0'};
137 const char *sep, *suf;
141 const char *
str =
"mat.e-r_ial";
147 EXPECT_STREQ(
"e-r_ial", suf);
152 const char *
str =
".mate-rial--";
158 EXPECT_STREQ(
"mate-rial--", suf);
162 const char *
str =
".__.--_";
168 EXPECT_STREQ(
"__.--_", suf);
172 const char *
str =
"";
177 EXPECT_EQ(sep,
static_cast<void *
>(
nullptr));
178 EXPECT_EQ(suf,
static_cast<void *
>(
nullptr));
182 const char *
str =
"material";
187 EXPECT_EQ(sep,
static_cast<void *
>(
nullptr));
188 EXPECT_EQ(suf,
static_cast<void *
>(
nullptr));
195 const char delim[] = {
'-',
'.',
'_',
'~',
'\\',
'\0'};
196 const char *sep, *suf;
200 const char *
str =
"mat.e-r_ial";
206 EXPECT_STREQ(
"ial", suf);
211 const char *
str =
".mate-rial--";
217 EXPECT_STREQ(
"", suf);
221 const char *
str =
".__.--_";
227 EXPECT_STREQ(
"", suf);
231 const char *
str =
".material";
237 EXPECT_STREQ(
"material", suf);
241 const char *
str =
"";
246 EXPECT_EQ(sep,
static_cast<void *
>(
nullptr));
247 EXPECT_EQ(suf,
static_cast<void *
>(
nullptr));
251 const char *
str =
"material";
256 EXPECT_EQ(sep,
static_cast<void *
>(
nullptr));
257 EXPECT_EQ(suf,
static_cast<void *
>(
nullptr));
264 const char delim[] = {
'-',
'.',
'_',
'~',
'\\',
'\0'};
265 const char *sep, *suf;
271 const char *
str =
"mat.e-r_ia.l";
277 EXPECT_STREQ(
"r_ia.l", suf);
282 const char *
str =
"mate.rial";
287 EXPECT_EQ(sep,
static_cast<void *
>(
nullptr));
288 EXPECT_EQ(suf,
static_cast<void *
>(
nullptr));
295 const uint delim[] = {
'-',
'.',
'_', 0x00F1 , 0x262F ,
'\0'};
296 const char *sep, *suf;
300 const char *
str =
"ma\xc3\xb1te-r\xe2\x98\xafial";
306 EXPECT_STREQ(
"te-r\xe2\x98\xafial", suf);
311 const char *
str =
"\xe2\x98\xafmate-rial-\xc3\xb1";
317 EXPECT_STREQ(
"mate-rial-\xc3\xb1", suf);
321 const char *
str =
"\xe2\x98\xaf.\xc3\xb1_.--\xc3\xb1";
327 EXPECT_STREQ(
".\xc3\xb1_.--\xc3\xb1", suf);
331 const char *
str =
"";
336 EXPECT_EQ(sep,
static_cast<void *
>(
nullptr));
337 EXPECT_EQ(suf,
static_cast<void *
>(
nullptr));
341 const char *
str =
"material";
346 EXPECT_EQ(sep,
static_cast<void *
>(
nullptr));
347 EXPECT_EQ(suf,
static_cast<void *
>(
nullptr));
354 const uint delim[] = {
'-',
'.',
'_', 0x00F1 , 0x262F ,
'\0'};
355 const char *sep, *suf;
359 const char *
str =
"ma\xc3\xb1te-r\xe2\x98\xafial";
365 EXPECT_STREQ(
"ial", suf);
370 const char *
str =
"\xe2\x98\xafmate-rial-\xc3\xb1";
376 EXPECT_STREQ(
"", suf);
380 const char *
str =
"\xe2\x98\xaf.\xc3\xb1_.--\xc3\xb1";
386 EXPECT_STREQ(
"", suf);
390 const char *
str =
".material";
396 EXPECT_STREQ(
"material", suf);
400 const char *
str =
"\xc3\xb1material";
406 EXPECT_STREQ(
"material", suf);
410 const char *
str =
"";
415 EXPECT_EQ(sep,
static_cast<void *
>(
nullptr));
416 EXPECT_EQ(suf,
static_cast<void *
>(
nullptr));
420 const char *
str =
"material";
425 EXPECT_EQ(sep,
static_cast<void *
>(
nullptr));
426 EXPECT_EQ(suf,
static_cast<void *
>(
nullptr));
431TEST(
string, StrPartitionExUtf8)
433 const uint delim[] = {
'-',
'.',
'_', 0x00F1 , 0x262F ,
'\0'};
434 const char *sep, *suf;
440 const char *
str =
"ma\xc3\xb1te-r\xe2\x98\xafial";
447 EXPECT_STREQ(
"te-r\xe2\x98\xafial", suf);
452 const char *
str =
"mate\xe2\x98\xafrial";
457 EXPECT_EQ(sep,
static_cast<void *
>(
nullptr));
458 EXPECT_EQ(suf,
static_cast<void *
>(
nullptr));
469TEST(
string, StrFormatIntGrouped)
475 EXPECT_STREQ(
"0", number_str);
478 EXPECT_STREQ(
"1", number_str);
481 EXPECT_STREQ(
"-1", number_str);
484 EXPECT_STREQ(
"1,000", number_str);
487 EXPECT_STREQ(
"-1,000", number_str);
490 EXPECT_STREQ(
"999", number_str);
493 EXPECT_STREQ(
"-999", number_str);
496 EXPECT_STREQ(
"2,147,483,647", number_str);
499 EXPECT_STREQ(
"-2,147,483,648", number_str);
501 EXPECT_EQ(
sizeof(number_str), strlen(number_str) + 1);
505TEST(
string, StrFormatUint64Grouped)
511 EXPECT_STREQ(
"0", number_str);
514 EXPECT_STREQ(
"1", number_str);
517 EXPECT_STREQ(
"999", number_str);
520 EXPECT_STREQ(
"1,000", number_str);
523 EXPECT_STREQ(
"18,446,744,073,709,551,615", number_str);
525 EXPECT_EQ(
sizeof(number_str), strlen(number_str) + 1);
535TEST(
string, StrFormatByteUnits)
542 EXPECT_STREQ(
"0 B", size_str);
544 EXPECT_STREQ(
"0 B", size_str);
547 EXPECT_STREQ(
"1 B", size_str);
549 EXPECT_STREQ(
"-1 B", size_str);
552 EXPECT_STREQ(
"1 KB", size_str);
554 EXPECT_STREQ(
"-1 KB", size_str);
557 EXPECT_STREQ(
"1 KB", size_str);
559 EXPECT_STREQ(
"-1 KB", size_str);
563 EXPECT_STREQ(
"9223.372 PB", size_str);
565 EXPECT_STREQ(
"-9223.372 PB", size_str);
569 EXPECT_STREQ(
"0 B", size_str);
571 EXPECT_STREQ(
"0 B", size_str);
574 EXPECT_STREQ(
"1 B", size_str);
576 EXPECT_STREQ(
"-1 B", size_str);
579 EXPECT_STREQ(
"1000 B", size_str);
581 EXPECT_STREQ(
"-1000 B", size_str);
584 EXPECT_STREQ(
"1 KiB", size_str);
586 EXPECT_STREQ(
"-1 KiB", size_str);
590 EXPECT_STREQ(
"8192.0 PiB", size_str);
592 EXPECT_STREQ(
"-8192.0 PiB", size_str);
596 EXPECT_STREQ(
"-8191.8472 PiB", size_str);
598 EXPECT_EQ(
sizeof(size_str), strlen(size_str) + 1);
602TEST(
string, StrFormatByteUnitsCompact)
609 EXPECT_STREQ(
"0B", size_str);
611 EXPECT_STREQ(
"155B", size_str);
613 EXPECT_STREQ(
"1K", size_str);
615 EXPECT_STREQ(
".1M", size_str);
617 EXPECT_STREQ(
"1G", size_str);
619 EXPECT_STREQ(
".5E", size_str);
623 EXPECT_STREQ(
"9E", size_str);
627 EXPECT_STREQ(
"0B", size_str);
629 EXPECT_STREQ(
"1K", size_str);
633 EXPECT_STREQ(
"8E", size_str);
643TEST(
string, StrFormatDecimalUnits)
649 EXPECT_STREQ(
"0", size_str);
651 EXPECT_STREQ(
"1", size_str);
653 EXPECT_STREQ(
"10", size_str);
655 EXPECT_STREQ(
"15", size_str);
657 EXPECT_STREQ(
"100", size_str);
659 EXPECT_STREQ(
"155", size_str);
661 EXPECT_STREQ(
"1.0K", size_str);
663 EXPECT_STREQ(
"1.6K", size_str);
665 EXPECT_STREQ(
"10.0K", size_str);
667 EXPECT_STREQ(
"15.6K", size_str);
669 EXPECT_STREQ(
"100K", size_str);
671 EXPECT_STREQ(
"100K", size_str);
673 EXPECT_STREQ(
"156K", size_str);
675 EXPECT_STREQ(
"1.0M", size_str);
677 EXPECT_STREQ(
"1.6M", size_str);
679 EXPECT_STREQ(
"10.0M", size_str);
681 EXPECT_STREQ(
"15.6M", size_str);
683 EXPECT_STREQ(
"100M", size_str);
685 EXPECT_STREQ(
"156M", size_str);
687 EXPECT_STREQ(
"1.0B", size_str);
691 EXPECT_STREQ(
"2.1B", size_str);
694 EXPECT_STREQ(
"0", size_str);
696 EXPECT_STREQ(
"-1", size_str);
698 EXPECT_STREQ(
"-10", size_str);
700 EXPECT_STREQ(
"-15", size_str);
702 EXPECT_STREQ(
"-100", size_str);
704 EXPECT_STREQ(
"-155", size_str);
706 EXPECT_STREQ(
"-1.0K", size_str);
708 EXPECT_STREQ(
"-1.6K", size_str);
710 EXPECT_STREQ(
"-10.0K", size_str);
712 EXPECT_STREQ(
"-15.6K", size_str);
714 EXPECT_STREQ(
"-100K", size_str);
716 EXPECT_STREQ(
"-156K", size_str);
718 EXPECT_STREQ(
"-1.0M", size_str);
720 EXPECT_STREQ(
"-1.6M", size_str);
722 EXPECT_STREQ(
"-10.0M", size_str);
724 EXPECT_STREQ(
"-15.6M", size_str);
726 EXPECT_STREQ(
"-100M", size_str);
728 EXPECT_STREQ(
"-156M", size_str);
730 EXPECT_STREQ(
"-1.0B", size_str);
734 EXPECT_STREQ(
"-2.1B", size_str);
738TEST(
string, StrFormatIntegerUnits)
744 EXPECT_STREQ(
"0", size_str);
746 EXPECT_STREQ(
"1", size_str);
748 EXPECT_STREQ(
"10", size_str);
750 EXPECT_STREQ(
"15", size_str);
752 EXPECT_STREQ(
"100", size_str);
754 EXPECT_STREQ(
"155", size_str);
756 EXPECT_STREQ(
"1K", size_str);
758 EXPECT_STREQ(
"1K", size_str);
760 EXPECT_STREQ(
"10K", size_str);
762 EXPECT_STREQ(
"15K", size_str);
764 EXPECT_STREQ(
".1M", size_str);
766 EXPECT_STREQ(
".1M", size_str);
768 EXPECT_STREQ(
"1M", size_str);
770 EXPECT_STREQ(
"1M", size_str);
772 EXPECT_STREQ(
"2M", size_str);
774 EXPECT_STREQ(
"10M", size_str);
776 EXPECT_STREQ(
"15M", size_str);
778 EXPECT_STREQ(
".1B", size_str);
780 EXPECT_STREQ(
".1B", size_str);
782 EXPECT_STREQ(
".2B", size_str);
784 EXPECT_STREQ(
"1B", size_str);
788 EXPECT_STREQ(
"2B", size_str);
791 EXPECT_STREQ(
"0", size_str);
793 EXPECT_STREQ(
"-1", size_str);
795 EXPECT_STREQ(
"-10", size_str);
797 EXPECT_STREQ(
"-15", size_str);
799 EXPECT_STREQ(
"-100", size_str);
801 EXPECT_STREQ(
"-155", size_str);
803 EXPECT_STREQ(
"-1K", size_str);
805 EXPECT_STREQ(
"-1K", size_str);
807 EXPECT_STREQ(
"-10K", size_str);
809 EXPECT_STREQ(
"-15K", size_str);
811 EXPECT_STREQ(
"-.1M", size_str);
813 EXPECT_STREQ(
"-.1M", size_str);
815 EXPECT_STREQ(
"-1M", size_str);
817 EXPECT_STREQ(
"-1M", size_str);
819 EXPECT_STREQ(
"-10M", size_str);
821 EXPECT_STREQ(
"-15M", size_str);
823 EXPECT_STREQ(
"-.1B", size_str);
825 EXPECT_STREQ(
"-.1B", size_str);
827 EXPECT_STREQ(
"-1B", size_str);
831 EXPECT_STREQ(
"-2B", size_str);
865#define BUFFER_SIZE 128
875 EXPECT_STREQ(buffer_alloc, buffer);
876 MEM_delete(buffer_alloc);
879 for (
int dst_size = buffer_len + 1; dst_size > 0; dst_size--) {
883 EXPECT_EQ(strncmp(dst_tmp, buffer, dst_tmp_len), 0);
896 EXPECT_STREQ(buffer_alloc, buffer);
897 MEM_delete(buffer_alloc);
900 for (
int dst_size = buffer_len + 1; dst_size > 0; dst_size--) {
903 dst_tmp, dst_size,
'|', strings, strings_num);
905 EXPECT_EQ(strncmp(dst_tmp, buffer, dst_tmp_len), 0);
913 const char *strings[] = {
"a",
"b",
"c",
"d",
"e",
"f"};
915 EXPECT_STREQ(buffer,
"abcdef");
917 EXPECT_STREQ(buffer,
"a|b|c|d|e|f");
920 const char *strings[] = {
"aa",
"bb",
"cc",
"dd",
"ee",
"ff"};
922 EXPECT_STREQ(buffer,
"aabbccddeeff");
924 EXPECT_STREQ(buffer,
"aa|bb|cc|dd|ee|ff");
927 const char *strings[] = {
"",
"",
"",
"",
"",
""};
929 EXPECT_STREQ(buffer,
"");
931 EXPECT_STREQ(buffer,
"|||||");
934 const char *strings[] = {
"test"};
936 EXPECT_STREQ(buffer,
"test");
938 EXPECT_STREQ(buffer,
"test");
941 const char *strings[] = {
""};
943 EXPECT_STREQ(buffer,
"");
945 EXPECT_STREQ(buffer,
"");
948 const char *strings[] = {
"a"};
950 EXPECT_STREQ(buffer,
"");
952 EXPECT_STREQ(buffer,
"");
975 os <<
"start: " << word_info.
start <<
", end: " << word_info.
end;
988 const size_t max_length,
989 initializer_list<WordInfo> expected_words_info_init,
992 const vector<WordInfo> expected_words_info = expected_words_info_init;
993 if (max_words != -1) {
994 CHECK_LE(max_words, expected_words_info.size() - 1);
999 const int effective_max_words = (max_words == -1) ? expected_words_info.size() : max_words;
1001 vector<WordInfo> actual_word_info(effective_max_words + 1,
WordInfo(-1, -1));
1006 reinterpret_cast<int (*)[2]
>(actual_word_info.data()),
1007 effective_max_words);
1010 EXPECT_LE(actual_word_num, actual_word_info.size() - 1);
1011 actual_word_info.resize(actual_word_num + 1);
1013 EXPECT_EQ_VECTOR(actual_word_info, expected_words_info);
1017 initializer_list<WordInfo> expected_words_info_init)
1026 testStringFindSplitWords(
"t", {{0, 1}, {-1, -1}});
1027 testStringFindSplitWords(
"test", {{0, 4}, {-1, -1}});
1031 testStringFindSplitWords(
"f t w", {{0, 1}, {2, 1}, {4, 1}, {-1, -1}});
1032 testStringFindSplitWords(
"find three words", {{0, 4}, {5, 5}, {11, 5}, {-1, -1}});
1036 testStringFindSplitWords(
"# ## ### ####", {{0, 1}, {2, 2}, {5, 3}, {9, 4}, {-1, -1}});
1037 testStringFindSplitWords(
"# # # #", {{0, 1}, {3, 1}, {7, 1}, {12, 1}, {-1, -1}});
1041 testStringFindSplitWords(
" t", {{3, 1}, {-1, -1}});
1042 testStringFindSplitWords(
" test", {{3, 4}, {-1, -1}});
1046 testStringFindSplitWords(
"t ", {{0, 1}, {-1, -1}});
1047 testStringFindSplitWords(
"test ", {{0, 4}, {-1, -1}});
1051 testStringFindSplitWords(
" surrounding space test 123 ",
1052 {{3, 11}, {15, 5}, {21, 4}, {28, 3}, {-1, -1}});
1056 testStringFindSplitWords(
"", {{-1, -1}});
1060 testStringFindSplitWords(
" ", {{-1, -1}});
1061 testStringFindSplitWords(
" ", {{-1, -1}});
1065 const string words =
"too many chars";
1066 const int words_len = words.length();
1067 testStringFindSplitWords(words, words_len, {{0, 3}, {4, 4}, {9, 5}, {-1, -1}}, 3);
1068 testStringFindSplitWords(words, words_len, {{0, 3}, {4, 4}, {-1, -1}}, 2);
1069 testStringFindSplitWords(words, words_len, {{0, 3}, {-1, -1}}, 1);
1070 testStringFindSplitWords(words, words_len, {{-1, -1}}, 0);
1074 const string words =
"too many chars";
1075 const int words_len = words.length();
1076 testStringFindSplitWords(words, words_len, {{0, 3}, {4, 4}, {9, 5}, {-1, -1}});
1077 testStringFindSplitWords(words, words_len - 1, {{0, 3}, {4, 4}, {9, 4}, {-1, -1}});
1078 testStringFindSplitWords(words, words_len - 5, {{0, 3}, {4, 4}, {-1, -1}});
1079 testStringFindSplitWords(words, 1, {{0, 1}, {-1, -1}});
1080 testStringFindSplitWords(words, 0, {{-1, -1}});
1142 const char *str_test0 =
"search here";
1161 EXPECT_EQ(res,
static_cast<void *
>(
nullptr));
1171TEST(
string, StringMaxPossibleWordCount)
1220 for (
const auto &item : items) {
1227 for (
const auto &item : items) {
1234 for (
const auto &item : items) {
1246 ret_array.reserve(items.size());
1247 for (
const auto &item : items) {
1248 ret_array.push_back({item[1], item[0]});
1263 const CompareWordsArray
equal{
1266 const CompareWordsArray negative{
1270 CompareWordsArray positive = copyWithSwappedWords(negative);
1272 testReturnsZeroForAll(
equal);
1273 testReturnsLessThanZeroForAll(negative);
1274 testReturnsMoreThanZeroForAll(positive);
1279 const CompareWordsArray
equal{
1284 const CompareWordsArray negative{
1290 CompareWordsArray positive = copyWithSwappedWords(negative);
1292 testReturnsZeroForAll(
equal);
1293 testReturnsLessThanZeroForAll(negative);
1294 testReturnsMoreThanZeroForAll(positive);
1299 const CompareWordsArray
equal{
1304 {
"je møder",
"je møder"},
1306 const CompareWordsArray negative{
1311 {
"je møda",
"je møder"},
1313 CompareWordsArray positive = copyWithSwappedWords(negative);
1315 testReturnsZeroForAll(
equal);
1316 testReturnsLessThanZeroForAll(negative);
1317 testReturnsMoreThanZeroForAll(positive);
1322 const CompareWordsArray
equal{
1329 const CompareWordsArray negative{
1349 CompareWordsArray positive = copyWithSwappedWords(negative);
1351 testReturnsZeroForAll(
equal);
1352 testReturnsLessThanZeroForAll(negative);
1353 testReturnsMoreThanZeroForAll(positive);
1358 const CompareWordsArray
equal{
1364 const CompareWordsArray negative{
1367 {
"foo.bar",
"foo 1.bar"},
1369 CompareWordsArray positive = copyWithSwappedWords(negative);
1371 testReturnsZeroForAll(
equal);
1372 testReturnsLessThanZeroForAll(negative);
1373 testReturnsMoreThanZeroForAll(positive);
1378 const CompareWordsArray
equal{
1384 const CompareWordsArray negative{
1391 const CompareWordsArray positive = copyWithSwappedWords(negative);
1393 testReturnsZeroForAll(
equal);
1394 testReturnsLessThanZeroForAll(negative);
1395 testReturnsMoreThanZeroForAll(positive);
1400 const CompareWordsArray
equal{
1401 {
"00je møder1",
"00je møder1"},
1406 const CompareWordsArray negative{
1407 {
"00je møder0",
"00je møder1"},
1408 {
"05je møder0",
"06je møder1"},
1409 {
"Cube",
"Cube.001"},
1410 {
"Cube.001",
"Cube.002"},
1411 {
"CUbe.001",
"Cube.002"},
1412 {
"CUbe.002",
"Cube.002"},
1414 const CompareWordsArray positive = copyWithSwappedWords(negative);
1416 testReturnsZeroForAll(
equal);
1417 testReturnsLessThanZeroForAll(negative);
1418 testReturnsMoreThanZeroForAll(positive);
1437 size_t dst_test_len;
1439 for (
const auto &item : items) {
1441 EXPECT_LT((strlen(item[0]) * 2) + 1,
sizeof(dst_test));
1443 dst_test_len =
BLI_str_escape(dst_test, item[0],
sizeof(dst_test));
1444 EXPECT_STREQ(dst_test, item[1]);
1445 EXPECT_EQ(dst_test_len, strlen(dst_test));
1448 EXPECT_STREQ(dst_test, item[0]);
1449 EXPECT_EQ(dst_test_len, strlen(dst_test));
1459 const CompareWordsArray
equal{
1466 const CompareWordsArray escaped{
1473 {
"\"\\",
"\\\"\\\\"},
1475 {
"\\\"",
"\\\\\\\""},
1477 {
"\"\\\"",
"\\\"\\\\\\\""},
1480 {
"\"\"\"",
"\\\"\\\"\\\""},
1482 {
"\\\\\\",
"\\\\\\\\\\\\"},
1485 testEscapeWords(
equal);
1486 testEscapeWords(escaped);
1491 const CompareWordsArray escaped{
1501 {
"\n\r\t\a\b\f",
"\\n\\r\\t\\a\\b\\f"},
1503 {
"\n_\r_\t_\a_\b_\f",
"\\n_\\r_\\t_\\a_\\b_\\f"},
1505 {
"\n\\\r\\\t\\\a\\\b\\\f",
"\\n\\\\\\r\\\\\\t\\\\\\a\\\\\\b\\\\\\f"},
1508 testEscapeWords(escaped);
1513#define STR_ESCAPE_TRUNC_EXPECT(src, dst_expect, dst_maxncpy) \
1515 char dst[dst_maxncpy + 1]; \
1516 dst[dst_maxncpy] = 0xff; \
1517 size_t len = BLI_str_escape(dst, src, dst_maxncpy); \
1518 EXPECT_EQ(len, strlen(dst)); \
1519 EXPECT_STREQ(dst, dst_expect); \
1520 EXPECT_EQ(dst[dst_maxncpy], 0xff); \
1551#undef STR_ESCAPE_TRUNC_EXPECT
1557 const char *src =
"A\\n";
1562 EXPECT_STREQ(dst,
"A\\");
1567 EXPECT_STREQ(dst,
"A\\");
1574#define STR_UNESCAPE_EXPECT(src, dst_expect, src_len) \
1576 char dst[src_len + 2]; \
1577 dst[src_len + 1] = 0xff; \
1578 size_t len = BLI_str_unescape(dst, src, src_len); \
1579 EXPECT_EQ(len, strlen(dst)); \
1580 EXPECT_STREQ(dst, dst_expect); \
1581 EXPECT_EQ(dst[src_len + 1], 0xff); \
1590#undef STR_UNESCAPE_EXPECT
1595 EXPECT_STREQ(dst,
"A");
1607 EXPECT_STREQ(
str,
"Hello");
1613 EXPECT_STREQ(
str,
"Hello, ");
#define BLI_STR_FORMAT_INT64_BYTE_UNIT_SIZE
#define BLI_STR_FORMAT_INT32_DECIMAL_UNIT_SIZE
#define BLI_STR_FORMAT_INT32_GROUPED_SIZE
#define BLI_STR_FORMAT_INT32_INTEGER_UNIT_SIZE
#define BLI_STR_FORMAT_UINT64_GROUPED_SIZE
#define BLI_STR_FORMAT_INT64_BYTE_UNIT_COMPACT_SIZE
#define STRNCPY_ENSURE_PAD_EXPECT(src, dst_expect, dst_maxncpy)
#define STR_N_CAT(dst_init, dst_size, src, result_expect)
#define STR_UNESCAPE_EXPECT(src, dst_expect, src_len)
#define STR_ESCAPE_TRUNC_EXPECT(src, dst_expect, dst_maxncpy)
#define STR_REPLACE_RANGE(src, size, beg, end, dst, result_expect)
Read Blender memory allocation and freeing.
CompareWordsArray copyWithSwappedWords(const CompareWordsArray &items)
void testReturnsLessThanZeroForAll(const CompareWordsArray &items)
void testReturnsZeroForAll(const CompareWordsArray &items)
void testReturnsMoreThanZeroForAll(const CompareWordsArray &items)
vector< std::array< const char *, 2 > > CompareWordsArray
StringCasecmpNatural()=default
vector< std::array< const char *, 2 > > CompareWordsArray
void testEscapeWords(const CompareWordsArray &items)
void testStringFindSplitWords(const string &str, const size_t max_length, initializer_list< WordInfo > expected_words_info_init, int max_words=-1)
void testStringFindSplitWords(const string &str, initializer_list< WordInfo > expected_words_info_init)
StringFindSplitWords()=default
VecBase< bool, D > equal(VecOp< T, D >, VecOp< T, D >) RET
#define EXPECT_FALSE(result)
#define EXPECT_GT(result, expect)
#define EXPECT_LT(result, expect)
#define EXPECT_TRUE(result)
#define EXPECT_LE(result, expect)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
std::ostream & operator<<(std::ostream &stream, const AssetCatalogPath &path_to_append)
void BLI_str_format_byte_unit(char dst[BLI_STR_FORMAT_INT64_BYTE_UNIT_SIZE], long long int bytes, bool base_10) ATTR_NONNULL(1)
bool BLI_string_is_decimal(const char *string) ATTR_NONNULL(1)
void BLI_str_format_decimal_unit(char dst[BLI_STR_FORMAT_INT32_DECIMAL_UNIT_SIZE], int number_to_format) ATTR_NONNULL(1)
unsigned __int64 uint64_t
char * STRNCPY(char(&dst)[N], const char *src)
int char char int int int BLI_strcasecmp_natural(const char *s1, const char *s2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
int bool bool bool size_t BLI_str_partition(const char *str, const char delim[], const char **sep, const char **suf) ATTR_NONNULL(1
int bool bool BLI_str_endswith(const char *__restrict str, const char *__restrict end) ATTR_NONNULL(1
char * BLI_string_join_arrayN(const char *strings[], uint strings_num) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BLI_str_format_byte_unit_compact(char dst[BLI_STR_FORMAT_INT64_BYTE_UNIT_COMPACT_SIZE], long long int bytes, bool base_10) ATTR_NONNULL(1)
bool bool int BLI_string_find_split_words(const char *str, size_t str_maxlen, char delim, int r_words[][2], int words_max) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
static void string_join_array_test_truncate(const char *strings[], int strings_num, char buffer[BUFFER_SIZE])
char * BLI_string_join_array_by_sep_charN(char sep, const char *strings[], uint strings_num) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
bool bool int bool BLI_string_elem_split_by_delim(const char *haystack, const char delim, const char *needle) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
size_t size_t BLI_str_rpartition_utf8(const char *str, const unsigned int delim[], const char **r_sep, const char **r_suf) ATTR_NONNULL(1
size_t BLI_str_partition_utf8(const char *str, const unsigned int delim[], const char **r_sep, const char **r_suf) ATTR_NONNULL(1
char char size_t BLI_str_escape(char *__restrict dst, StringRef src, size_t dst_maxncpy) ATTR_NONNULL(1)
int bool bool bool size_t size_t size_t int BLI_string_max_possible_word_count(int str_len) ATTR_WARN_UNUSED_RESULT
TEST_F(BrushTest, deep_copy)
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
int char char int int int int size_t BLI_strnlen(const char *str, size_t maxlen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
size_t BLI_string_join_array_by_sep_char(char *result, size_t result_maxncpy, char sep, const char *strings[], uint strings_num) ATTR_NONNULL()
size_t BLI_str_unescape_ex(char *__restrict dst, const char *__restrict src, size_t src_len, size_t dst_maxncpy, bool *r_is_complete) ATTR_NONNULL(1
size_t BLI_str_format_int_grouped(char dst[BLI_STR_FORMAT_INT32_GROUPED_SIZE], int num) ATTR_NONNULL(1)
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void BLI_str_format_integer_unit(char dst[BLI_STR_FORMAT_INT32_INTEGER_UNIT_SIZE], int number_to_format) ATTR_NONNULL(1)
int bool BLI_str_startswith(const char *__restrict str, const char *__restrict start) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
size_t size_t size_t BLI_str_partition_ex_utf8(const char *str, const char *end, const unsigned int delim[], const char **r_sep, const char **r_suf, bool from_right) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
int bool bool bool size_t size_t size_t BLI_str_partition_ex(const char *str, const char *end, const char delim[], const char **sep, const char **suf, bool from_right) ATTR_NONNULL(1
int bool bool bool size_t size_t BLI_str_rpartition(const char *str, const char delim[], const char **sep, const char **suf) ATTR_NONNULL(1
size_t size_t BLI_str_unescape(char *__restrict dst, const char *__restrict src, size_t src_len) ATTR_NONNULL(1
static void string_join_array_with_sep_char_test_truncate(const char *strings[], int strings_num, char buffer[BUFFER_SIZE])
size_t BLI_string_join_array(char *result, size_t result_maxncpy, const char *strings[], uint strings_num) ATTR_NONNULL()
int char char * BLI_strncasestr(const char *s, const char *find, size_t len) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
size_t BLI_str_format_uint64_grouped(char dst[BLI_STR_FORMAT_UINT64_GROUPED_SIZE], uint64_t num) ATTR_NONNULL(1)
bool operator==(const WordInfo &other) const
WordInfo(int start, int end)