3 #include "testing/testing.h"
6 #include <initializer_list>
17 using std::initializer_list;
28 const char delim[] = {
'-',
'.',
'_',
'~',
'\\',
'\0'};
29 const char *sep, *suf;
33 const char *
str =
"mat.e-r_ial";
39 EXPECT_STREQ(
"e-r_ial", suf);
44 const char *
str =
".mate-rial--";
50 EXPECT_STREQ(
"mate-rial--", suf);
54 const char *
str =
".__.--_";
60 EXPECT_STREQ(
"__.--_", suf);
74 const char *
str =
"material";
85 TEST(
string, StrRPartition)
87 const char delim[] = {
'-',
'.',
'_',
'~',
'\\',
'\0'};
88 const char *sep, *suf;
92 const char *
str =
"mat.e-r_ial";
98 EXPECT_STREQ(
"ial", suf);
103 const char *
str =
".mate-rial--";
109 EXPECT_STREQ(
"", suf);
113 const char *
str =
".__.--_";
119 EXPECT_STREQ(
"", suf);
123 const char *
str =
"";
133 const char *
str =
"material";
146 const char delim[] = {
'-',
'.',
'_',
'~',
'\\',
'\0'};
147 const char *sep, *suf;
153 const char *
str =
"mat.e-r_ia.l";
159 EXPECT_STREQ(
"r_ia.l", suf);
164 const char *
str =
"mate.rial";
177 const unsigned int delim[] = {
'-',
'.',
'_', 0x00F1 , 0x262F ,
'\0'};
178 const char *sep, *suf;
182 const char *
str =
"ma\xc3\xb1te-r\xe2\x98\xafial";
188 EXPECT_STREQ(
"te-r\xe2\x98\xafial", suf);
193 const char *
str =
"\xe2\x98\xafmate-rial-\xc3\xb1";
199 EXPECT_STREQ(
"mate-rial-\xc3\xb1", suf);
203 const char *
str =
"\xe2\x98\xaf.\xc3\xb1_.--\xc3\xb1";
209 EXPECT_STREQ(
".\xc3\xb1_.--\xc3\xb1", suf);
213 const char *
str =
"";
223 const char *
str =
"material";
234 TEST(
string, StrRPartitionUtf8)
236 const unsigned int delim[] = {
'-',
'.',
'_', 0x00F1 , 0x262F ,
'\0'};
237 const char *sep, *suf;
241 const char *
str =
"ma\xc3\xb1te-r\xe2\x98\xafial";
247 EXPECT_STREQ(
"ial", suf);
252 const char *
str =
"\xe2\x98\xafmate-rial-\xc3\xb1";
258 EXPECT_STREQ(
"", suf);
262 const char *
str =
"\xe2\x98\xaf.\xc3\xb1_.--\xc3\xb1";
268 EXPECT_STREQ(
"", suf);
272 const char *
str =
"";
282 const char *
str =
"material";
293 TEST(
string, StrPartitionExUtf8)
295 const unsigned int delim[] = {
'-',
'.',
'_', 0x00F1 , 0x262F ,
'\0'};
296 const char *sep, *suf;
302 const char *
str =
"ma\xc3\xb1te-r\xe2\x98\xafial";
309 EXPECT_STREQ(
"te-r\xe2\x98\xafial", suf);
314 const char *
str =
"mate\xe2\x98\xafrial";
325 TEST(
string, StrFormatIntGrouped)
331 EXPECT_STREQ(
"0", number_str);
334 EXPECT_STREQ(
"1", number_str);
337 EXPECT_STREQ(
"-1", number_str);
340 EXPECT_STREQ(
"-2,147,483,648", number_str);
343 EXPECT_STREQ(
"2,147,483,647", number_str);
346 EXPECT_STREQ(
"1,000", number_str);
349 EXPECT_STREQ(
"-1,000", number_str);
352 EXPECT_STREQ(
"999", number_str);
355 EXPECT_STREQ(
"-999", number_str);
359 TEST(
string, StrFormatByteUnits)
366 EXPECT_STREQ(
"0 B", size_str);
368 EXPECT_STREQ(
"0 B", size_str);
371 EXPECT_STREQ(
"1 B", size_str);
373 EXPECT_STREQ(
"-1 B", size_str);
376 EXPECT_STREQ(
"1 KB", size_str);
378 EXPECT_STREQ(
"-1 KB", size_str);
381 EXPECT_STREQ(
"1 KB", size_str);
383 EXPECT_STREQ(
"-1 KB", size_str);
387 EXPECT_STREQ(
"9223.372 PB", size_str);
389 EXPECT_STREQ(
"-9223.372 PB", size_str);
393 EXPECT_STREQ(
"0 B", size_str);
395 EXPECT_STREQ(
"0 B", size_str);
398 EXPECT_STREQ(
"1 B", size_str);
400 EXPECT_STREQ(
"-1 B", size_str);
403 EXPECT_STREQ(
"1000 B", size_str);
405 EXPECT_STREQ(
"-1000 B", size_str);
408 EXPECT_STREQ(
"1 KiB", size_str);
410 EXPECT_STREQ(
"-1 KiB", size_str);
414 EXPECT_STREQ(
"8192.0 PiB", size_str);
416 EXPECT_STREQ(
"-8192.0 PiB", size_str);
420 EXPECT_STREQ(
"-8191.8472 PiB", size_str);
424 TEST(
string, StrFormatDecimalUnits)
430 EXPECT_STREQ(
"0", size_str);
432 EXPECT_STREQ(
"1", size_str);
434 EXPECT_STREQ(
"10", size_str);
436 EXPECT_STREQ(
"15", size_str);
438 EXPECT_STREQ(
"100", size_str);
440 EXPECT_STREQ(
"155", size_str);
442 EXPECT_STREQ(
"1.0K", size_str);
444 EXPECT_STREQ(
"1.6K", size_str);
446 EXPECT_STREQ(
"10.0K", size_str);
448 EXPECT_STREQ(
"15.6K", size_str);
450 EXPECT_STREQ(
"100K", size_str);
452 EXPECT_STREQ(
"100K", size_str);
454 EXPECT_STREQ(
"156K", size_str);
456 EXPECT_STREQ(
"1.0M", size_str);
458 EXPECT_STREQ(
"1.6M", size_str);
460 EXPECT_STREQ(
"10.0M", size_str);
462 EXPECT_STREQ(
"15.6M", size_str);
464 EXPECT_STREQ(
"100M", size_str);
466 EXPECT_STREQ(
"156M", size_str);
468 EXPECT_STREQ(
"1.0B", size_str);
472 EXPECT_STREQ(
"2.1B", size_str);
475 EXPECT_STREQ(
"0", size_str);
477 EXPECT_STREQ(
"-1", size_str);
479 EXPECT_STREQ(
"-10", size_str);
481 EXPECT_STREQ(
"-15", size_str);
483 EXPECT_STREQ(
"-100", size_str);
485 EXPECT_STREQ(
"-155", size_str);
487 EXPECT_STREQ(
"-1.0K", size_str);
489 EXPECT_STREQ(
"-1.6K", size_str);
491 EXPECT_STREQ(
"-10.0K", size_str);
493 EXPECT_STREQ(
"-15.6K", size_str);
495 EXPECT_STREQ(
"-100K", size_str);
497 EXPECT_STREQ(
"-156K", size_str);
499 EXPECT_STREQ(
"-1.0M", size_str);
501 EXPECT_STREQ(
"-1.6M", size_str);
503 EXPECT_STREQ(
"-10.0M", size_str);
505 EXPECT_STREQ(
"-15.6M", size_str);
507 EXPECT_STREQ(
"-100M", size_str);
509 EXPECT_STREQ(
"-156M", size_str);
511 EXPECT_STREQ(
"-1.0B", size_str);
515 EXPECT_STREQ(
"-2.1B", size_str);
531 os <<
"start: " << word_info.
start <<
", end: " << word_info.
end;
544 const size_t max_length,
545 initializer_list<WordInfo> expected_words_info_init,
549 if (max_words != -1) {
550 CHECK_LE(max_words, expected_words_info.size() - 1);
555 const int effective_max_words = (max_words == -1) ? expected_words_info.size() : max_words;
562 reinterpret_cast<int(*)[2]
>(actual_word_info.data()),
563 effective_max_words);
566 EXPECT_LE(actual_word_num, actual_word_info.size() - 1);
567 actual_word_info.resize(actual_word_num + 1);
569 EXPECT_EQ_VECTOR(actual_word_info, expected_words_info);
573 initializer_list<WordInfo> expected_words_info_init)
582 testStringFindSplitWords(
"t", {{0, 1}, {-1, -1}});
583 testStringFindSplitWords(
"test", {{0, 4}, {-1, -1}});
587 testStringFindSplitWords(
"f t w", {{0, 1}, {2, 1}, {4, 1}, {-1, -1}});
588 testStringFindSplitWords(
"find three words", {{0, 4}, {5, 5}, {11, 5}, {-1, -1}});
592 testStringFindSplitWords(
"# ## ### ####", {{0, 1}, {2, 2}, {5, 3}, {9, 4}, {-1, -1}});
593 testStringFindSplitWords(
"# # # #", {{0, 1}, {3, 1}, {7, 1}, {12, 1}, {-1, -1}});
597 testStringFindSplitWords(
" t", {{3, 1}, {-1, -1}});
598 testStringFindSplitWords(
" test", {{3, 4}, {-1, -1}});
602 testStringFindSplitWords(
"t ", {{0, 1}, {-1, -1}});
603 testStringFindSplitWords(
"test ", {{0, 4}, {-1, -1}});
607 testStringFindSplitWords(
" surrounding space test 123 ",
608 {{3, 11}, {15, 5}, {21, 4}, {28, 3}, {-1, -1}});
612 testStringFindSplitWords(
"", {{-1, -1}});
616 testStringFindSplitWords(
" ", {{-1, -1}});
617 testStringFindSplitWords(
" ", {{-1, -1}});
621 const string words =
"too many chars";
622 const int words_len = words.length();
623 testStringFindSplitWords(words, words_len, {{0, 3}, {4, 4}, {9, 5}, {-1, -1}}, 3);
624 testStringFindSplitWords(words, words_len, {{0, 3}, {4, 4}, {-1, -1}}, 2);
625 testStringFindSplitWords(words, words_len, {{0, 3}, {-1, -1}}, 1);
626 testStringFindSplitWords(words, words_len, {{-1, -1}}, 0);
630 const string words =
"too many chars";
631 const int words_len = words.length();
632 testStringFindSplitWords(words, words_len, {{0, 3}, {4, 4}, {9, 5}, {-1, -1}});
633 testStringFindSplitWords(words, words_len - 1, {{0, 3}, {4, 4}, {9, 4}, {-1, -1}});
634 testStringFindSplitWords(words, words_len - 5, {{0, 3}, {4, 4}, {-1, -1}});
635 testStringFindSplitWords(words, 1, {{0, 1}, {-1, -1}});
636 testStringFindSplitWords(words, 0, {{-1, -1}});
640 TEST(
string, StringStrncasestr)
642 const char *str_test0 =
"search here";
665 TEST(
string, StringMaxPossibleWordCount)
702 for (
const auto &item : items) {
709 for (
const auto &item : items) {
716 for (
const auto &item : items) {
728 ret_array.reserve(items.size());
729 for (
const auto &item : items) {
730 ret_array.push_back({item[1], item[0]});
739 const CompareWordsArray equal{
742 const CompareWordsArray negative{
746 CompareWordsArray positive = copyWithSwappedWords(negative);
748 testReturnsZeroForAll(equal);
749 testReturnsLessThanZeroForAll(negative);
750 testReturnsMoreThanZeroForAll(positive);
755 const CompareWordsArray equal{
760 const CompareWordsArray negative{
766 CompareWordsArray positive = copyWithSwappedWords(negative);
768 testReturnsZeroForAll(equal);
769 testReturnsLessThanZeroForAll(negative);
770 testReturnsMoreThanZeroForAll(positive);
775 const CompareWordsArray equal{
780 {
"je møder",
"je møder"},
782 const CompareWordsArray negative{
787 {
"je møda",
"je møder"},
789 CompareWordsArray positive = copyWithSwappedWords(negative);
791 testReturnsZeroForAll(equal);
792 testReturnsLessThanZeroForAll(negative);
793 testReturnsMoreThanZeroForAll(positive);
798 const CompareWordsArray equal{
805 const CompareWordsArray negative{
825 CompareWordsArray positive = copyWithSwappedWords(negative);
827 testReturnsZeroForAll(equal);
828 testReturnsLessThanZeroForAll(negative);
829 testReturnsMoreThanZeroForAll(positive);
834 const CompareWordsArray equal{
840 const CompareWordsArray negative{
843 {
"foo.bar",
"foo 1.bar"},
845 CompareWordsArray positive = copyWithSwappedWords(negative);
847 testReturnsZeroForAll(equal);
848 testReturnsLessThanZeroForAll(negative);
849 testReturnsMoreThanZeroForAll(positive);
854 const CompareWordsArray equal{
860 const CompareWordsArray negative{
867 const CompareWordsArray positive = copyWithSwappedWords(negative);
869 testReturnsZeroForAll(equal);
870 testReturnsLessThanZeroForAll(negative);
871 testReturnsMoreThanZeroForAll(positive);
876 const CompareWordsArray equal{
877 {
"00je møder1",
"00je møder1"},
882 const CompareWordsArray negative{
883 {
"00je møder0",
"00je møder1"},
884 {
"05je møder0",
"06je møder1"},
885 {
"Cube",
"Cube.001"},
886 {
"Cube.001",
"Cube.002"},
887 {
"CUbe.001",
"Cube.002"},
888 {
"CUbe.002",
"Cube.002"},
890 const CompareWordsArray positive = copyWithSwappedWords(negative);
892 testReturnsZeroForAll(equal);
893 testReturnsLessThanZeroForAll(negative);
894 testReturnsMoreThanZeroForAll(positive);
909 for (
const auto &item : items) {
912 EXPECT_STREQ(dst_test, item[1]);
913 EXPECT_EQ(dst_test_len, strlen(dst_test));
916 EXPECT_STREQ(dst_test, item[0]);
917 EXPECT_EQ(dst_test_len, strlen(dst_test));
927 const CompareWordsArray equal{
934 const CompareWordsArray escaped{
941 {
"\"\\",
"\\\"\\\\"},
943 {
"\\\"",
"\\\\\\\""},
945 {
"\"\\\"",
"\\\"\\\\\\\""},
948 {
"\"\"\"",
"\\\"\\\"\\\""},
950 {
"\\\\\\",
"\\\\\\\\\\\\"},
953 testEscapeWords(equal);
954 testEscapeWords(escaped);
959 const CompareWordsArray escaped{
969 {
"\n\r\t\a\b\f",
"\\n\\r\\t\\a\\b\\f"},
971 {
"\n_\r_\t_\a_\b_\f",
"\\n_\\r_\\t_\\a_\\b_\\f"},
973 {
"\n\\\r\\\t\\\a\\\b\\\f",
"\\n\\\\\\r\\\\\\t\\\\\\a\\\\\\b\\\\\\f"},
976 testEscapeWords(escaped);
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
size_t int BLI_string_max_possible_word_count(int str_len)
size_t BLI_str_unescape(char *__restrict dst, const char *__restrict src, size_t src_maxncpy) ATTR_NONNULL()
char * BLI_strncasestr(const char *s, const char *find, size_t len) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
int BLI_strcasecmp_natural(const char *s1, const char *s2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
int BLI_string_find_split_words(const char *str, size_t len, char delim, int r_words[][2], int words_max) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BLI_str_format_decimal_unit(char dst[7], int number_to_format) ATTR_NONNULL()
size_t BLI_str_partition(const char *str, const char delim[], const char **sep, const char **suf) ATTR_NONNULL()
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
size_t BLI_str_format_int_grouped(char dst[16], int num) ATTR_NONNULL()
size_t BLI_str_rpartition(const char *str, const char delim[], const char **sep, const char **suf) ATTR_NONNULL()
void BLI_str_format_byte_unit(char dst[15], long long int bytes, bool base_10) ATTR_NONNULL()
size_t size_t char size_t BLI_str_escape(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL()
TEST(string, StrPartition)
TEST_F(StringFindSplitWords, Simple)
static std::ostream & operator<<(std::ostream &os, const WordInfo &word_info)
size_t BLI_str_partition_utf8(const char *str, const unsigned int delim[], const char **sep, const char **suf) ATTR_NONNULL(1
size_t size_t BLI_str_rpartition_utf8(const char *str, const unsigned int delim[], const char **sep, const char **suf) 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 **sep, const char **suf, bool from_right) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
bool BLI_string_is_decimal(const char *string) ATTR_NONNULL()
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a vector
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
void testReturnsMoreThanZeroForAll(const CompareWordsArray &items)
void testReturnsZeroForAll(const CompareWordsArray &items)
void testReturnsLessThanZeroForAll(const CompareWordsArray &items)
StringCasecmpNatural()=default
CompareWordsArray copyWithSwappedWords(const CompareWordsArray &items)
void testEscapeWords(const CompareWordsArray &items)
void testStringFindSplitWords(const string &str, initializer_list< WordInfo > expected_words_info_init)
StringFindSplitWords()=default
void testStringFindSplitWords(const string &str, const size_t max_length, initializer_list< WordInfo > expected_words_info_init, int max_words=-1)
bool operator==(const WordInfo &other) const
WordInfo(int start, int end)