Blender V5.3
BLI_path_utils_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "testing/testing.h"
6
7#include "IMB_imbuf.hh"
8
9#include "BLI_fileops.hh"
10#include "BLI_path_utils.hh"
11#include "BLI_string.hh"
12#include "BLI_string_utils.hh"
13
14namespace blender {
15
16#define DO_PERF_TESTS 0
17
18/* -------------------------------------------------------------------- */
21
22#ifdef WIN32
23# define ABS_PREFIX "C:"
24#else
25# define ABS_PREFIX ""
26#endif
27
28static void str_replace_char_with_relative_exception(char *str, char src, char dst)
29{
30 /* Always keep "//" or more leading slashes (special meaning). */
31 if (src == '/') {
32 if (str[0] == '/' && str[1] == '/') {
33 str += 2;
34 while (*str == '/') {
35 str++;
36 }
37 }
38 }
40}
41
42static char *str_replace_char_strdup(const char *str, char src, char dst)
43{
44 if (str == nullptr) {
45 return nullptr;
46 }
47 char *str_dupe = strdup(str);
48 BLI_string_replace_char(str_dupe, src, dst);
49 return str_dupe;
50}
51
53
54/* -------------------------------------------------------------------- */
57
58#define NORMALIZE(input, output_expect) \
59 { \
60 char path[FILE_MAX] = input; \
61 if (SEP == '\\') { \
62 str_replace_char_with_relative_exception(path, '/', '\\'); \
63 } \
64 const int path_len_test = BLI_path_normalize(path); \
65 if (SEP == '\\') { \
66 BLI_string_replace_char(path, '\\', '/'); \
67 } \
68 EXPECT_STREQ(path, output_expect); \
69 EXPECT_EQ(path_len_test, strlen(path)); \
70 } \
71 ((void)0)
72
73/* #BLI_path_normalize: do nothing. */
74TEST(path_utils, Normalize_Nop)
75{
76 NORMALIZE(".", ".");
77 NORMALIZE("./", "./");
78 NORMALIZE("/", "/");
79 NORMALIZE("//", "//");
80 NORMALIZE("//a", "//a");
81}
82
83TEST(path_utils, Normalize_NopRelative)
84{
85 NORMALIZE("..", "..");
86 NORMALIZE("../", "../");
87 NORMALIZE("../", "../");
88 NORMALIZE("../..", "../..");
89 NORMALIZE("../../", "../../");
90}
91
92/* #BLI_path_normalize: "/./" -> "/" */
93TEST(path_utils, Normalize_Dot)
94{
95 NORMALIZE("/./", "/");
96 NORMALIZE("/a/./b/./c/./", "/a/b/c/");
97 NORMALIZE("/./././", "/");
98 NORMALIZE("/a/./././b/", "/a/b/");
99}
100/* #BLI_path_normalize: complex "/./" -> "/", "//" -> "/", "./path/../" -> "./". */
101TEST(path_utils, Normalize_ComplexAbsolute)
102{
103 NORMALIZE("/a/./b/./c/./.././.././", "/a/");
104 NORMALIZE("/a//.//b//.//c//.//..//.//..//.//", "/a/");
105}
106TEST(path_utils, Normalize_ComplexRelative)
107{
108 NORMALIZE("a/b/c/d/e/f/g/../a/../b/../../c/../../../d/../../../..", ".");
109 NORMALIZE("a/b/c/d/e/f/g/../a/../../../../b/../../../c/../../d/..", ".");
110}
111/* #BLI_path_normalize: "//" -> "/" */
112TEST(path_utils, Normalize_DoubleSlash)
113{
114 NORMALIZE("//", "//"); /* Exception, double forward slash. */
115 NORMALIZE(".//", "./");
116 NORMALIZE("a////", "a/");
117 NORMALIZE("./a////", "a/");
118}
119/* #BLI_path_normalize: "foo/bar/../" -> "foo/" */
120TEST(path_utils, Normalize_Parent)
121{
122 NORMALIZE("/a/b/c/../../../", "/");
123 NORMALIZE("/a/../a/b/../b/c/../c/", "/a/b/c/");
124}
125/* #BLI_path_normalize: with too many "/../", match Python's behavior. */
126TEST(path_utils, Normalize_UnbalancedAbsolute)
127{
128 NORMALIZE("/../", "/");
129 NORMALIZE("/../a", "/a");
130 NORMALIZE("/a/b/c/../../../../../d", "/d");
131 NORMALIZE("/a/b/c/../../../../d", "/d");
132 NORMALIZE("/a/b/c/../../../d", "/d");
133
134 /* Use a longer path as it may hit corner cases. */
135 NORMALIZE("/home/username/Downloads/../../../../../Users/Example/Desktop/test.jpg",
136 "/Users/Example/Desktop/test.jpg");
137}
138
139/* #BLI_path_normalize: with relative paths that result in leading "../". */
140TEST(path_utils, Normalize_UnbalancedRelative)
141{
142 NORMALIZE("./a/b/c/../../../", ".");
143 NORMALIZE("a/b/c/../../../", ".");
144 NORMALIZE("//a/b/c/../../../", "//");
145
146 NORMALIZE("./a/../../../", "../../");
147 NORMALIZE("a/../../../", "../../");
148
149 NORMALIZE("///a/../../../", "//../../");
150 NORMALIZE("//./a/../../../", "//../../");
151
152 NORMALIZE("../a/../../../", "../../../");
153 NORMALIZE("a/b/../c/../../d/../../../e/../../../../f", "../../../../../f");
154 NORMALIZE(".../.../a/.../b/../c/../../d/../../../e/../../../.../../f", "../f");
155}
156
157TEST(path_utils, Normalize_UnbalancedRelativeTrailing)
158{
159 NORMALIZE("./a/b/c/../../..", ".");
160 NORMALIZE("a/b/c/../../..", ".");
161 NORMALIZE("//a/b/c/../../..", "//");
162
163 NORMALIZE("./a/../../..", "../..");
164 NORMALIZE("a/../../..", "../..");
165
166 NORMALIZE("///a/../../..", "//../..");
167 NORMALIZE("//./a/../../..", "//../..");
168
169 NORMALIZE("../a/../../..", "../../..");
170}
171
172#undef NORMALIZE
173
175
176/* -------------------------------------------------------------------- */
181
182TEST(path_utils, CompareNormalized)
183{
184 /* Trailing slash should not matter. */
185 EXPECT_EQ(BLI_path_cmp_normalized("/tmp/", "/tmp"), 0);
186 /* Slash direction should not matter. */
187 EXPECT_EQ(BLI_path_cmp_normalized("c:\\tmp\\", "c:/tmp/"), 0);
188 /* Empty paths should be supported. */
190
192}
193
195
196/* -------------------------------------------------------------------- */
199
200#define PARENT_DIR(input, output_expect) \
201 { \
202 char path[FILE_MAX] = input; \
203 if (SEP == '\\') { \
204 BLI_string_replace_char(path, '/', '\\'); \
205 } \
206 BLI_path_parent_dir(path); \
207 if (SEP == '\\') { \
208 BLI_string_replace_char(path, '\\', '/'); \
209 } \
210 EXPECT_STREQ(path, output_expect); \
211 } \
212 ((void)0)
213
214TEST(path_utils, ParentDir_Simple)
215{
216 PARENT_DIR("/a/b/", "/a/");
217 PARENT_DIR("/a/b", "/a/");
218 PARENT_DIR("/a", "/");
219}
220
221TEST(path_utils, ParentDir_NOP)
222{
223 PARENT_DIR("/", "/");
224 PARENT_DIR("", "");
225 PARENT_DIR(".", ".");
226 PARENT_DIR("./", "./");
227 PARENT_DIR(".//", ".//");
228 PARENT_DIR("./.", "./.");
229}
230
231TEST(path_utils, ParentDir_TrailingPeriod)
232{
233 /* Ensure trailing dots aren't confused with parent path. */
234 PARENT_DIR("/.../.../.../", "/.../.../");
235 PARENT_DIR("/.../.../...", "/.../.../");
236
237 PARENT_DIR("/a../b../c../", "/a../b../");
238 PARENT_DIR("/a../b../c..", "/a../b../");
239
240 PARENT_DIR("/a./b./c./", "/a./b./");
241 PARENT_DIR("/a./b./c.", "/a./b./");
242}
243
244TEST(path_utils, ParentDir_Complex)
245{
246 PARENT_DIR("./a/", "./");
247 PARENT_DIR("./a", "./");
248 PARENT_DIR("../a/", "../");
249 PARENT_DIR("../a", "../");
250
251 /* Test unexpanded template variables. */
252 PARENT_DIR("{test_variable}/a", "{test_variable}/");
253 PARENT_DIR("/a/{test_variable}", "/a/");
254 /* While this is not correct in that the template variable could contain a path string,
255 * We just check that the code doesn't error out when it encounters a template variable.
256 */
257 PARENT_DIR("{test_variable}/a/{test_variable}", "{test_variable}/a/");
258}
259
260#undef PARENT_DIR
261
263
264/* -------------------------------------------------------------------- */
267
268#define PARENT_DIR_END(input, offset_expect) \
269 { \
270 const char *path = input; \
271 const char *path_end = BLI_path_parent_dir_end(path, strlen(path)); \
272 EXPECT_EQ(path_end ? int(path_end - path) : -1, offset_expect) << "path: " << path; \
273 } \
274 ((void)0)
275
276TEST(path_utils, ParentDirEnd_Simple)
277{
278 PARENT_DIR_END("/a/b", 2);
279 PARENT_DIR_END("/a/b/c", 4);
280 PARENT_DIR_END("/a", -1);
281 PARENT_DIR_END("a", -1);
282}
283
284TEST(path_utils, ParentDirEnd_Redundant)
285{
286 /* Examples from the doc-string. */
287 PARENT_DIR_END("/test///dir/./file", 11);
288 PARENT_DIR_END("/test/dir/subdir//file", 16);
289
290 PARENT_DIR_END("/a/./b", 2);
291 PARENT_DIR_END("a/./b", 1);
292 PARENT_DIR_END("./x", 1);
293}
294
295#undef PARENT_DIR_END
296
298
299/* -------------------------------------------------------------------- */
302
303#define AT_INDEX(str_input, index_input, str_expect) \
304 { \
305 char path[] = str_input; \
306 /* Test input assumes forward slash, support back-slash on WIN32. */ \
307 if (SEP == '\\') { \
308 BLI_string_replace_char(path, '/', '\\'); \
309 } \
310 const char *expect = str_expect; \
311 int index_output, len_output; \
312 const bool ret = BLI_path_name_at_index(path, index_input, &index_output, &len_output); \
313 if (expect == nullptr) { \
314 EXPECT_FALSE(ret); \
315 } \
316 else { \
317 EXPECT_TRUE(ret); \
318 EXPECT_EQ(len_output, strlen(expect)); \
319 path[index_output + len_output] = '\0'; \
320 EXPECT_STREQ(&path[index_output], expect); \
321 } \
322 } \
323 ((void)0)
324
325TEST(path_utils, NameAtIndex_Single)
326{
327 AT_INDEX("/a", 0, "a");
328 AT_INDEX("/a/", 0, "a");
329 AT_INDEX("a/", 0, "a");
330 AT_INDEX("//a//", 0, "a");
331 AT_INDEX("a/b", 0, "a");
332
333 AT_INDEX("/a", 1, nullptr);
334 AT_INDEX("/a/", 1, nullptr);
335 AT_INDEX("a/", 1, nullptr);
336 AT_INDEX("//a//", 1, nullptr);
337}
338TEST(path_utils, NameAtIndex_SingleNeg)
339{
340 AT_INDEX("/a", -1, "a");
341 AT_INDEX("/a/", -1, "a");
342 AT_INDEX("a/", -1, "a");
343 AT_INDEX("//a//", -1, "a");
344 AT_INDEX("a/b", -1, "b");
345
346 AT_INDEX("/a", -2, nullptr);
347 AT_INDEX("/a/", -2, nullptr);
348 AT_INDEX("a/", -2, nullptr);
349 AT_INDEX("//a//", -2, nullptr);
350}
351
352TEST(path_utils, NameAtIndex_Double)
353{
354 AT_INDEX("/ab", 0, "ab");
355 AT_INDEX("/ab/", 0, "ab");
356 AT_INDEX("ab/", 0, "ab");
357 AT_INDEX("//ab//", 0, "ab");
358 AT_INDEX("ab/c", 0, "ab");
359
360 AT_INDEX("/ab", 1, nullptr);
361 AT_INDEX("/ab/", 1, nullptr);
362 AT_INDEX("ab/", 1, nullptr);
363 AT_INDEX("//ab//", 1, nullptr);
364}
365
366TEST(path_utils, NameAtIndex_DoublNeg)
367{
368 AT_INDEX("/ab", -1, "ab");
369 AT_INDEX("/ab/", -1, "ab");
370 AT_INDEX("ab/", -1, "ab");
371 AT_INDEX("//ab//", -1, "ab");
372 AT_INDEX("ab/c", -1, "c");
373
374 AT_INDEX("/ab", -2, nullptr);
375 AT_INDEX("/ab/", -2, nullptr);
376 AT_INDEX("ab/", -2, nullptr);
377 AT_INDEX("//ab//", -2, nullptr);
378}
379
380TEST(path_utils, NameAtIndex_Misc)
381{
382 AT_INDEX("/how/now/brown/cow", 0, "how");
383 AT_INDEX("/how/now/brown/cow", 1, "now");
384 AT_INDEX("/how/now/brown/cow", 2, "brown");
385 AT_INDEX("/how/now/brown/cow", 3, "cow");
386 AT_INDEX("/how/now/brown/cow", 4, nullptr);
387 AT_INDEX("/how/now/brown/cow/", 4, nullptr);
388}
389
390TEST(path_utils, NameAtIndex_MiscNeg)
391{
392 AT_INDEX("/how/now/brown/cow", 0, "how");
393 AT_INDEX("/how/now/brown/cow", 1, "now");
394 AT_INDEX("/how/now/brown/cow", 2, "brown");
395 AT_INDEX("/how/now/brown/cow", 3, "cow");
396 AT_INDEX("/how/now/brown/cow", 4, nullptr);
397 AT_INDEX("/how/now/brown/cow/", 4, nullptr);
398}
399
400#define TEST_STR "./a/./b/./c/."
401
402TEST(path_utils, NameAtIndex_SingleDot)
403{
404 AT_INDEX(TEST_STR, 0, ".");
405 AT_INDEX(TEST_STR, 1, "a");
406 AT_INDEX(TEST_STR, 2, "b");
407 AT_INDEX(TEST_STR, 3, "c");
408 AT_INDEX(TEST_STR, 4, nullptr);
409}
410
411TEST(path_utils, NameAtIndex_SingleDotNeg)
412{
413 AT_INDEX(TEST_STR, -5, nullptr);
414 AT_INDEX(TEST_STR, -4, ".");
415 AT_INDEX(TEST_STR, -3, "a");
416 AT_INDEX(TEST_STR, -2, "b");
417 AT_INDEX(TEST_STR, -1, "c");
418}
419
420#undef TEST_STR
421
422#define TEST_STR ".//a//.//b//.//c//.//"
423
424TEST(path_utils, NameAtIndex_SingleDotDoubleSlash)
425{
426 AT_INDEX(TEST_STR, 0, ".");
427 AT_INDEX(TEST_STR, 1, "a");
428 AT_INDEX(TEST_STR, 2, "b");
429 AT_INDEX(TEST_STR, 3, "c");
430 AT_INDEX(TEST_STR, 4, nullptr);
431}
432
433TEST(path_utils, NameAtIndex_SingleDotDoubleSlashNeg)
434{
435 AT_INDEX(TEST_STR, -5, nullptr);
436 AT_INDEX(TEST_STR, -4, ".");
437 AT_INDEX(TEST_STR, -3, "a");
438 AT_INDEX(TEST_STR, -2, "b");
439 AT_INDEX(TEST_STR, -1, "c");
440}
441
442#undef TEST_STR
443
444TEST(path_utils, NameAtIndex_SingleDotSeries)
445{
446 AT_INDEX("abc/././/././xyz", 0, "abc");
447 AT_INDEX("abc/././/././xyz", 1, "xyz");
448 AT_INDEX("abc/././/././xyz", 2, nullptr);
449}
450
451TEST(path_utils, NameAtIndex_SingleDotSeriesNeg)
452{
453 AT_INDEX("abc/././/././xyz", -3, nullptr);
454 AT_INDEX("abc/././/././xyz", -2, "abc");
455 AT_INDEX("abc/././/././xyz", -1, "xyz");
456}
457
458TEST(path_utils, NameAtIndex_MiscComplex)
459{
460 AT_INDEX("how//now/brown/cow", 0, "how");
461 AT_INDEX("//how///now//brown/cow", 1, "now");
462 AT_INDEX("/how/now///brown//cow", 2, "brown");
463 AT_INDEX("/how/now/brown/cow///", 3, "cow");
464 AT_INDEX("/how/now/brown//cow", 4, nullptr);
465 AT_INDEX("how/now/brown//cow/", 4, nullptr);
466}
467
468TEST(path_utils, NameAtIndex_MiscComplexNeg)
469{
470 AT_INDEX("how//now/brown/cow", -4, "how");
471 AT_INDEX("//how///now//brown/cow", -3, "now");
472 AT_INDEX("/how/now///brown//cow", -2, "brown");
473 AT_INDEX("/how/now/brown/cow///", -1, "cow");
474 AT_INDEX("/how/now/brown//cow", -5, nullptr);
475 AT_INDEX("how/now/brown//cow/", -5, nullptr);
476}
477
478TEST(path_utils, NameAtIndex_NoneComplex)
479{
480 AT_INDEX("", 0, nullptr);
481 AT_INDEX("/", 0, nullptr);
482 AT_INDEX("//", 0, nullptr);
483 AT_INDEX("///", 0, nullptr);
484}
485
486TEST(path_utils, NameAtIndex_NoneComplexNeg)
487{
488 AT_INDEX("", -1, nullptr);
489 AT_INDEX("/", -1, nullptr);
490 AT_INDEX("//", -1, nullptr);
491 AT_INDEX("///", -1, nullptr);
492}
493
494#undef AT_INDEX
495
497
498/* -------------------------------------------------------------------- */
501
502TEST(path_utils, IsUnc)
503{
504 EXPECT_TRUE(BLI_path_is_unc("\\\\server_name\\share_name"));
505 EXPECT_TRUE(BLI_path_is_unc("\\\\.\\C:\\file.txt"));
506 EXPECT_TRUE(BLI_path_is_unc("\\\\?\\C:\\file.txt"));
507
510 EXPECT_FALSE(BLI_path_is_unc("..\\relative\\path"));
511 EXPECT_FALSE(BLI_path_is_unc(".\\relative\\path"));
512 EXPECT_FALSE(BLI_path_is_unc("\\a_single_backslash"));
513 EXPECT_FALSE(BLI_path_is_unc("//must_be_backslashes"));
514}
515
517
518#ifdef WIN32
519
520/* -------------------------------------------------------------------- */
523
524# define PATH_NORMALIZE_UNC(input, output_expect) \
525 { \
526 char path[FILE_MAX]; \
527 STRNCPY(path, input); \
528 BLI_path_normalize_unc(path, sizeof(path)); \
529 EXPECT_STREQ(path, output_expect); \
530 } \
531 ((void)0)
532
533TEST(path_utils, NormalizeUNC)
534{
535 /* Long paths with a drive. */
536 PATH_NORMALIZE_UNC("\\\\?\\C:\\dir\\file", "C:\\dir\\file");
537 /* Long UNC paths. */
538 PATH_NORMALIZE_UNC("\\\\?\\UNC\\server\\share\\dir", "\\\\server\\share\\dir");
539 /* A slash is added after the share. */
540 PATH_NORMALIZE_UNC("\\\\?\\UNC\\server\\share", "\\\\server\\share\\");
541 /* Other paths are left as-is. */
542 PATH_NORMALIZE_UNC("C:\\dir\\file", "C:\\dir\\file");
543 PATH_NORMALIZE_UNC("\\\\server\\share\\dir", "\\\\server\\share\\dir");
544}
545
546# undef PATH_NORMALIZE_UNC
547
549
550#endif /* WIN32 */
551
552/* -------------------------------------------------------------------- */
555
574
576
577/* -------------------------------------------------------------------- */
580
600
602
603/* -------------------------------------------------------------------- */
606
624
626
627/* -------------------------------------------------------------------- */
630
631/* For systems with `/` path separator (non WIN32). */
632#define JOIN_FORWARD_SLASH(str_expect, out_size, ...) \
633 { \
634 const char *expect = str_expect; \
635 char result[(out_size) + 1024]; \
636 /* Check we don't write past the last byte. */ \
637 result[out_size] = '\0'; \
638 BLI_path_join(result, out_size, __VA_ARGS__); \
639 EXPECT_STREQ(result, expect); \
640 EXPECT_EQ(result[out_size], '\0'); \
641 } \
642 ((void)0)
643
644/* For systems with `\` path separator (WIN32).
645 * Perform additional manipulation to behave as if input arguments used `\` separators.
646 * Needed since #BLI_path_join uses native slashes. */
647#define JOIN_BACK_SLASH(str_expect, out_size, ...) \
648 { \
649 const char *expect = str_expect; \
650 char result[(out_size) + 1024]; \
651 const char *input_forward_slash[] = {__VA_ARGS__}; \
652 char *input_back_slash[ARRAY_SIZE(input_forward_slash)] = {nullptr}; \
653 for (int i = 0; i < ARRAY_SIZE(input_forward_slash); i++) { \
654 input_back_slash[i] = strdup(input_forward_slash[i]); \
655 BLI_string_replace_char(input_back_slash[i], '/', '\\'); \
656 } \
657 /* Check we don't write past the last byte. */ \
658 result[out_size] = '\0'; \
659 BLI_path_join_array(result, \
660 out_size, \
661 const_cast<const char **>(input_back_slash), \
662 ARRAY_SIZE(input_back_slash)); \
663 BLI_string_replace_char(result, '\\', '/'); \
664 EXPECT_STREQ(result, expect); \
665 EXPECT_EQ(result[out_size], '\0'); \
666 for (int i = 0; i < ARRAY_SIZE(input_forward_slash); i++) { \
667 free(input_back_slash[i]); \
668 } \
669 } \
670 ((void)0)
671
672#ifdef WIN32
673# define JOIN JOIN_BACK_SLASH
674#else
675# define JOIN JOIN_FORWARD_SLASH
676#endif
677
678TEST(path_utils, JoinNop)
679{
680 JOIN("", 100, "");
681 JOIN("", 100, "", "");
682 JOIN("", 100, "", "", "");
683 JOIN("/", 100, "/", "", "");
684 JOIN("/", 100, "/", "/");
685 JOIN("/", 100, "/", "", "/");
686 JOIN("/", 100, "/", "", "/", "");
687}
688
689TEST(path_utils, JoinSingle)
690{
691 JOIN("test", 100, "test");
692 JOIN("", 100, "");
693 JOIN("a", 100, "a");
694 JOIN("/a", 100, "/a");
695 JOIN("a/", 100, "a/");
696 JOIN("/a/", 100, "/a/");
697 JOIN("/a/", 100, "/a//");
698 JOIN("//a/", 100, "//a//");
699}
700
701TEST(path_utils, JoinTriple)
702{
703 JOIN("/a/b/c", 100, "/a", "b", "c");
704 JOIN("/a/b/c", 100, "/a/", "/b/", "/c");
705 JOIN("/a/b/c", 100, "/a/b/", "/c");
706 JOIN("/a/b/c", 100, "/a/b/c");
707 JOIN("/a/b/c", 100, "/", "a/b/c");
708
709 JOIN("/a/b/c/", 100, "/a/", "/b/", "/c/");
710 JOIN("/a/b/c/", 100, "/a/b/c/");
711 JOIN("/a/b/c/", 100, "/a/b/", "/c/");
712 JOIN("/a/b/c/", 100, "/a/b/c", "/");
713 JOIN("/a/b/c/", 100, "/", "a/b/c", "/");
714}
715
716TEST(path_utils, JoinTruncateShort)
717{
718 JOIN("", 1, "/");
719 JOIN("/", 2, "/");
720 JOIN("a", 2, "", "aa");
721 JOIN("a", 2, "", "a/");
722 JOIN("a/b", 4, "a", "bc");
723 JOIN("ab/", 4, "ab", "c");
724 JOIN("/a/", 4, "/a", "b");
725 JOIN("/a/", 4, "/a/", "b/");
726 JOIN("/a/", 4, "/a", "/b/");
727 JOIN("/a/", 4, "/", "a/b/");
728 JOIN("//a", 4, "//", "a/b/");
729
730 JOIN("/a/b", 5, "/a", "b", "c");
731}
732
733TEST(path_utils, JoinTruncateLong)
734{
735 JOIN("", 1, "//", "//longer", "path");
736 JOIN("/", 2, "//", "//longer", "path");
737 JOIN("//", 3, "//", "//longer", "path");
738 JOIN("//l", 4, "//", "//longer", "path");
739 /* snip */
740 JOIN("//longe", 8, "//", "//longer", "path");
741 JOIN("//longer", 9, "//", "//longer", "path");
742 JOIN("//longer/", 10, "//", "//longer", "path");
743 JOIN("//longer/p", 11, "//", "//longer", "path");
744 JOIN("//longer/pa", 12, "//", "//longer", "path");
745 JOIN("//longer/pat", 13, "//", "//longer", "path");
746 JOIN("//longer/path", 14, "//", "//longer", "path"); /* not truncated. */
747 JOIN("//longer/path", 14, "//", "//longer", "path/");
748 JOIN("//longer/path/", 15, "//", "//longer", "path/"); /* not truncated. */
749 JOIN("//longer/path/", 15, "//", "//longer", "path/", "trunc");
750 JOIN("//longer/path/t", 16, "//", "//longer", "path/", "trunc");
751}
752
753TEST(path_utils, JoinComplex)
754{
755 JOIN("/a/b/c/d/e/f/g/", 100, "/", "a/b", "//////c/d", "", "e", "f", "g//");
756 JOIN("/aa/bb/cc/dd/ee/ff/gg/", 100, "/", "aa/bb", "//////cc/dd", "", "ee", "ff", "gg//");
757 JOIN("1/2/3/", 100, "1", "////////", "", "2", "3///");
758}
759
760TEST(path_utils, JoinRelativePrefix)
761{
762 JOIN("//a/b/c", 100, "//a", "b", "c");
763 JOIN("//a/b/c", 100, "//", "//a//", "//b//", "//c");
764 JOIN("//a/b/c", 100, "//", "//", "a", "//", "b", "//", "c");
765}
766
767#undef JOIN
768#undef JOIN_BACK_SLASH
769#undef JOIN_FORWARD_SLASH
770
772
773/* -------------------------------------------------------------------- */
776
777/* For systems with `/` path separator (non WIN32). */
778#define APPEND(str_expect, size, path, filename) \
779 { \
780 const char *expect = str_expect; \
781 char result[(size) + 1024] = path; \
782 char filename_native[] = filename; \
783 /* Check we don't write past the last byte. */ \
784 if (SEP == '\\') { \
785 BLI_string_replace_char(filename_native, '/', '\\'); \
786 BLI_string_replace_char(result, '/', '\\'); \
787 } \
788 BLI_path_append(result, size, filename_native); \
789 if (SEP == '\\') { \
790 BLI_string_replace_char(result, '\\', '/'); \
791 } \
792 EXPECT_STREQ(result, expect); \
793 } \
794 ((void)0)
795
796TEST(path_utils, AppendFile)
797{
798 APPEND("a/b", 100, "a", "b");
799 APPEND("a/b", 100, "a/", "b");
800}
801
802TEST(path_utils, AppendFile_Truncate)
803{
804 APPEND("/A", 3, "/", "ABC");
805 APPEND("/", 2, "/", "test");
806 APPEND("X", 2, "X", "ABC");
807 APPEND("X/", 3, "X/", "ABC");
808}
809
810#undef APPEND
811
813
814/* -------------------------------------------------------------------- */
817
818TEST(path_utils, Frame)
819{
820 bool ret;
821
822 {
823 char path[FILE_MAX] = "";
824 ret = BLI_path_frame(path, sizeof(path), 123, 1);
826 EXPECT_STREQ(path, "123");
827 }
828
829 {
830 char path[FILE_MAX] = "";
831 ret = BLI_path_frame(path, sizeof(path), 123, 12);
833 EXPECT_STREQ(path, "000000000123");
834 }
835
836 {
837 char path[FILE_MAX] = "test_";
838 ret = BLI_path_frame(path, sizeof(path), 123, 1);
840 EXPECT_STREQ(path, "test_123");
841 }
842
843 {
844 char path[FILE_MAX] = "test_";
845 ret = BLI_path_frame(path, sizeof(path), 1, 12);
847 EXPECT_STREQ(path, "test_000000000001");
848 }
849
850 {
851 char path[FILE_MAX] = "test_############";
852 ret = BLI_path_frame(path, sizeof(path), 1, 0);
854 EXPECT_STREQ(path, "test_000000000001");
855 }
856
857 {
858 char path[FILE_MAX] = "test_#_#_middle";
859 ret = BLI_path_frame(path, sizeof(path), 123, 0);
861 EXPECT_STREQ(path, "test_#_123_middle");
862 }
863
864 /* intentionally fail */
865 {
866 char path[FILE_MAX] = "";
867 ret = BLI_path_frame(path, sizeof(path), 123, 0);
869 EXPECT_STREQ(path, "");
870 }
871
872 {
873 char path[FILE_MAX] = "test_middle";
874 ret = BLI_path_frame(path, sizeof(path), 123, 0);
876 EXPECT_STREQ(path, "test_middle");
877 }
878
879 /* negative frame numbers */
880 {
881 char path[FILE_MAX] = "test_####";
882 ret = BLI_path_frame(path, sizeof(path), -1, 4);
884 EXPECT_STREQ(path, "test_-0001");
885 }
886 {
887 char path[FILE_MAX] = "test_####";
888 ret = BLI_path_frame(path, sizeof(path), -100, 4);
890 EXPECT_STREQ(path, "test_-0100");
891 }
892
893 /* Ensure very large ranges work. */
894 {
895 char path[FILE_MAX * 2];
896 memset(path, '#', sizeof(path));
897 path[sizeof(path) - 1] = '\0';
898 ret = BLI_path_frame(path, sizeof(path), 123456789, 0);
899 EXPECT_TRUE(BLI_str_endswith(path, "0123456789"));
900 }
901
902 /* No room to add the digits, the path is left unchanged. */
903 {
904 char path[8 + 5];
905 memset(path, 0xff, sizeof(path));
906 path[sizeof(path) - 1] = '\0';
907 BLI_strncpy(path, "test_ab", 8);
908 ret = BLI_path_frame(path, 8, 123, 4);
910 EXPECT_STREQ(path, "test_ab");
911 EXPECT_STREQ(path + 8, "\xff\xff\xff\xff");
912 }
913}
914
916
917/* -------------------------------------------------------------------- */
920
921TEST(path_utils, SplitDirfile)
922{
923 {
924 const char *path = "";
925 char dir[FILE_MAX], file[FILE_MAX];
926 BLI_path_split_dir_file(path, dir, sizeof(dir), file, sizeof(file));
927 EXPECT_STREQ(dir, "");
928 EXPECT_STREQ(file, "");
929 }
930
931 {
932 const char *path = "/";
933 char dir[FILE_MAX], file[FILE_MAX];
934 BLI_path_split_dir_file(path, dir, sizeof(dir), file, sizeof(file));
935 EXPECT_STREQ(dir, "/");
936 EXPECT_STREQ(file, "");
937 }
938
939 {
940 const char *path = "fileonly";
941 char dir[FILE_MAX], file[FILE_MAX];
942 BLI_path_split_dir_file(path, dir, sizeof(dir), file, sizeof(file));
943 EXPECT_STREQ(dir, "");
944 EXPECT_STREQ(file, "fileonly");
945 }
946
947 {
948 const char *path = "dironly/";
949 char dir[FILE_MAX], file[FILE_MAX];
950 BLI_path_split_dir_file(path, dir, sizeof(dir), file, sizeof(file));
951 EXPECT_STREQ(dir, "dironly/");
952 EXPECT_STREQ(file, "");
953 }
954
955 {
956 const char *path = "/a/b";
957 char dir[FILE_MAX], file[FILE_MAX];
958 BLI_path_split_dir_file(path, dir, sizeof(dir), file, sizeof(file));
959 EXPECT_STREQ(dir, "/a/");
960 EXPECT_STREQ(file, "b");
961 }
962
963 {
964 const char *path = "/dirtoobig/filetoobig";
965 char dir[5], file[5];
966 BLI_path_split_dir_file(path, dir, sizeof(dir), file, sizeof(file));
967 EXPECT_STREQ(dir, "/dir");
968 EXPECT_STREQ(file, "file");
969
970 BLI_path_split_dir_file(path, dir, 1, file, 1);
971 EXPECT_STREQ(dir, "");
972 EXPECT_STREQ(file, "");
973 }
974}
975
977
978/* -------------------------------------------------------------------- */
981
982#define PATH_FRAME_STRIP(input_path, expect_path, expect_ext) \
983 { \
984 char path[FILE_MAX]; \
985 char ext[FILE_MAX]; \
986 STRNCPY(path, (input_path)); \
987 BLI_path_frame_strip(path, ext, sizeof(ext)); \
988 EXPECT_STREQ(path, expect_path); \
989 EXPECT_STREQ(ext, expect_ext); \
990 } \
991 ((void)0)
992
993TEST(path_utils, FrameStrip)
994{
995 PATH_FRAME_STRIP("", "", "");
996 PATH_FRAME_STRIP("nonum.abc", "nonum", ".abc");
997 PATH_FRAME_STRIP("fileonly.001.abc", "fileonly.###", ".abc");
998 PATH_FRAME_STRIP("/abspath/to/somefile.001.abc", "/abspath/to/somefile.###", ".abc");
999 PATH_FRAME_STRIP("/ext/longer/somefile.001.alembic", "/ext/longer/somefile.###", ".alembic");
1000 PATH_FRAME_STRIP("/ext/shorter/somefile.123001.abc", "/ext/shorter/somefile.######", ".abc");
1001
1002 /* Check int overflow scenario. */
1003 PATH_FRAME_STRIP("1234567890.png", "##########", ".png");
1004 PATH_FRAME_STRIP("12345678901.png", "12345678901", ".png");
1005}
1006#undef PATH_FRAME_STRIP
1007
1009
1010/* -------------------------------------------------------------------- */
1013
1014TEST(path_utils, Extension)
1015{
1016 EXPECT_EQ(BLI_path_extension("some.def/file"), nullptr);
1017 EXPECT_EQ(BLI_path_extension("Text"), nullptr);
1018 EXPECT_EQ(BLI_path_extension("Text…001"), nullptr);
1019 EXPECT_EQ(BLI_path_extension(".hidden"), nullptr);
1020 EXPECT_EQ(BLI_path_extension(".hidden/"), nullptr);
1021 EXPECT_EQ(BLI_path_extension("/.hidden"), nullptr);
1022 EXPECT_EQ(BLI_path_extension("dir/.hidden"), nullptr);
1023 EXPECT_EQ(BLI_path_extension("/dir/.hidden"), nullptr);
1024
1025 EXPECT_EQ(BLI_path_extension("."), nullptr);
1026 EXPECT_EQ(BLI_path_extension(".."), nullptr);
1027 EXPECT_EQ(BLI_path_extension("..."), nullptr);
1028 EXPECT_STREQ(BLI_path_extension("...a."), ".");
1029 EXPECT_STREQ(BLI_path_extension("...a.."), ".");
1030 EXPECT_EQ(BLI_path_extension("...a../"), nullptr);
1031
1032 EXPECT_STREQ(BLI_path_extension("some/file."), ".");
1033 EXPECT_STREQ(BLI_path_extension("some/file.tar.gz"), ".gz");
1034 EXPECT_STREQ(BLI_path_extension("some.def/file.abc"), ".abc");
1035 EXPECT_STREQ(BLI_path_extension("C:\\some.def\\file.abc"), ".abc");
1036 EXPECT_STREQ(BLI_path_extension("Text.001"), ".001");
1037}
1038
1040
1041/* -------------------------------------------------------------------- */
1044
1045#define PATH_EXTENSION_CHECK(input_path, input_ext, expect_ext) \
1046 { \
1047 const bool ret = BLI_path_extension_check(input_path, input_ext); \
1048 if (STREQ(input_ext, expect_ext)) { \
1049 EXPECT_TRUE(ret); \
1050 } \
1051 else { \
1052 EXPECT_FALSE(ret); \
1053 } \
1054 } \
1055 ((void)0)
1056
1057TEST(path_utils, ExtensionCheck)
1058{
1059 PATH_EXTENSION_CHECK("a/b/c.exe", ".exe", ".exe");
1060 PATH_EXTENSION_CHECK("correct/path/to/file.h", ".h", ".h");
1061 PATH_EXTENSION_CHECK("correct/path/to/file.BLEND", ".BLEND", ".BLEND");
1062 PATH_EXTENSION_CHECK("../tricky/path/to/file.h", ".h", ".h");
1063 PATH_EXTENSION_CHECK("../dirty//../path\\to/file.h", ".h", ".h");
1064 PATH_EXTENSION_CHECK("a/b/c.veryveryverylonglonglongextension",
1065 ".veryveryverylonglonglongextension",
1066 ".veryveryverylonglonglongextension");
1067 PATH_EXTENSION_CHECK("filename.PNG", "pnG", "pnG");
1068 PATH_EXTENSION_CHECK("a/b/c.h.exe", ".exe", ".exe");
1069 PATH_EXTENSION_CHECK("a/b/c.h.exe", "exe", "exe");
1070 PATH_EXTENSION_CHECK("a/b/c.exe", "c.exe", "c.exe");
1071 PATH_EXTENSION_CHECK("a/b/noext", "noext", "noext");
1072
1073 PATH_EXTENSION_CHECK("a/b/c.exe", ".png", ".exe");
1074 PATH_EXTENSION_CHECK("a/b/c.exe", "c.png", ".exe");
1075 PATH_EXTENSION_CHECK("a/b/s.l", "l.s", "s.l");
1076 PATH_EXTENSION_CHECK(".hiddenfolder", "", ".hiddenfolder");
1077 PATH_EXTENSION_CHECK("../dirty//../path\\to/actual.h.file.ext", ".h", ".ext");
1078 PATH_EXTENSION_CHECK("..\\dirty//../path//to/.hiddenfile.JPEG", ".hiddenfile", ".JPEG");
1079}
1080#undef PATH_EXTENSION_CHECK
1081
1083
1084/* -------------------------------------------------------------------- */
1087
1088#define PATH_EXTENSION_REPLACE_WITH_MAXLEN( \
1089 input_path, input_ext, expect_result, expect_path, maxlen) \
1090 { \
1091 BLI_assert(maxlen <= FILE_MAX); \
1092 char path[FILE_MAX]; \
1093 STRNCPY(path, input_path); \
1094 const bool ret = BLI_path_extension_replace(path, maxlen, input_ext); \
1095 if (expect_result) { \
1096 EXPECT_TRUE(ret); \
1097 } \
1098 else { \
1099 EXPECT_FALSE(ret); \
1100 } \
1101 EXPECT_STREQ(path, expect_path); \
1102 } \
1103 ((void)0)
1104
1105#define PATH_EXTENSION_REPLACE(input_path, input_ext, expect_result, expect_path) \
1106 PATH_EXTENSION_REPLACE_WITH_MAXLEN(input_path, input_ext, expect_result, expect_path, FILE_MAX)
1107
1108TEST(path_utils, ExtensionReplace)
1109{
1110 PATH_EXTENSION_REPLACE("test", ".txt", true, "test.txt");
1111 PATH_EXTENSION_REPLACE("test.", ".txt", true, "test.txt");
1112 /* Unlike #BLI_path_extension_ensure, excess '.' are not stripped. */
1113 PATH_EXTENSION_REPLACE("test..", ".txt", true, "test..txt");
1114
1115 PATH_EXTENSION_REPLACE("test.txt", ".txt", true, "test.txt");
1116 PATH_EXTENSION_REPLACE("test.ext", ".txt", true, "test.txt");
1117
1118 PATH_EXTENSION_REPLACE("test", "_txt", true, "test_txt");
1119 PATH_EXTENSION_REPLACE("test.ext", "_txt", true, "test_txt");
1120
1121 PATH_EXTENSION_REPLACE("test", "", true, "test");
1122
1123 /* Same as #BLI_path_extension_strip. */
1124 PATH_EXTENSION_REPLACE("test.txt", "", true, "test");
1125
1126 /* Empty strings. */
1127 PATH_EXTENSION_REPLACE("test", "", true, "test");
1128 PATH_EXTENSION_REPLACE("", "_txt", true, "_txt");
1129 PATH_EXTENSION_REPLACE("", "", true, "");
1130
1131 /* Ensure leading '.' isn't treated as an extension. */
1132 PATH_EXTENSION_REPLACE(".hidden", ".hidden", true, ".hidden.hidden");
1133 PATH_EXTENSION_REPLACE("..hidden", ".hidden", true, "..hidden.hidden");
1134 PATH_EXTENSION_REPLACE("._.hidden", ".hidden", true, "._.hidden");
1135}
1136
1137TEST(path_utils, ExtensionReplace_Overflow)
1138{
1139 /* Small values. */
1140 PATH_EXTENSION_REPLACE_WITH_MAXLEN("test", ".txt", false, "test", 0);
1141 PATH_EXTENSION_REPLACE_WITH_MAXLEN("test", ".txt", false, "test", 1);
1142 /* One under fails, and exactly enough space succeeds. */
1143 PATH_EXTENSION_REPLACE_WITH_MAXLEN("test", ".txt", false, "test", 8);
1144 PATH_EXTENSION_REPLACE_WITH_MAXLEN("test", ".txt", true, "test.txt", 9);
1145
1146 PATH_EXTENSION_REPLACE_WITH_MAXLEN("test.xx", ".txt", false, "test.xx", 8);
1147 PATH_EXTENSION_REPLACE_WITH_MAXLEN("test.xx", ".txt", true, "test.txt", 9);
1148}
1149
1150#undef PATH_EXTENSION_REPLACE
1151#undef PATH_EXTENSION_REPLACE_WITH_MAXLEN
1152
1154
1155/* -------------------------------------------------------------------- */
1158
1159#define PATH_EXTENSION_ENSURE_WITH_MAXLEN( \
1160 input_path, input_ext, expect_result, expect_path, maxlen) \
1161 { \
1162 BLI_assert(maxlen <= FILE_MAX); \
1163 char path[FILE_MAX]; \
1164 STRNCPY(path, input_path); \
1165 const bool ret = BLI_path_extension_ensure(path, maxlen, input_ext); \
1166 if (expect_result) { \
1167 EXPECT_TRUE(ret); \
1168 } \
1169 else { \
1170 EXPECT_FALSE(ret); \
1171 } \
1172 EXPECT_STREQ(path, expect_path); \
1173 } \
1174 ((void)0)
1175
1176#define PATH_EXTENSION_ENSURE(input_path, input_ext, expect_result, expect_path) \
1177 PATH_EXTENSION_ENSURE_WITH_MAXLEN(input_path, input_ext, expect_result, expect_path, FILE_MAX)
1178
1179TEST(path_utils, ExtensionEnsure)
1180{
1181 PATH_EXTENSION_ENSURE("test", ".txt", true, "test.txt");
1182 PATH_EXTENSION_ENSURE("test.", ".txt", true, "test.txt");
1183 PATH_EXTENSION_ENSURE("test..", ".txt", true, "test.txt");
1184
1185 PATH_EXTENSION_ENSURE("test.txt", ".txt", true, "test.txt");
1186 PATH_EXTENSION_ENSURE("test.ext", ".txt", true, "test.ext.txt");
1187
1188 PATH_EXTENSION_ENSURE("test", "_txt", true, "test_txt");
1189 PATH_EXTENSION_ENSURE("test.ext", "_txt", true, "test.ext_txt");
1190
1191 /* An empty string does nothing (unlike replace which strips). */
1192 PATH_EXTENSION_ENSURE("test.txt", "", true, "test.txt");
1193
1194 /* Empty strings. */
1195 PATH_EXTENSION_ENSURE("test", "", true, "test");
1196 PATH_EXTENSION_ENSURE("", "_txt", true, "_txt");
1197 PATH_EXTENSION_ENSURE("", "", true, "");
1198
1199 /* Ensure leading '.' isn't treated as an extension. */
1200 PATH_EXTENSION_ENSURE(".hidden", ".hidden", true, ".hidden.hidden");
1201 PATH_EXTENSION_ENSURE("..hidden", ".hidden", true, "..hidden.hidden");
1202 PATH_EXTENSION_ENSURE("._.hidden", ".hidden", true, "._.hidden");
1203}
1204
1205TEST(path_utils, ExtensionEnsure_Overflow)
1206{
1207 /* Small values. */
1208 PATH_EXTENSION_ENSURE_WITH_MAXLEN("test", ".txt", false, "test", 0);
1209 PATH_EXTENSION_ENSURE_WITH_MAXLEN("test", ".txt", false, "test", 1);
1210 /* One under fails, and exactly enough space succeeds. */
1211 PATH_EXTENSION_ENSURE_WITH_MAXLEN("test", ".txt", false, "test", 8);
1212 PATH_EXTENSION_ENSURE_WITH_MAXLEN("test", ".txt", true, "test.txt", 9);
1213}
1214
1215#undef PATH_EXTENSION_ENSURE
1216#undef PATH_EXTENSION_ENSURE_WITH_MAXLEN
1217
1219
1220/* -------------------------------------------------------------------- */
1223
1224#define PATH_FRAME_CHECK_CHARS(input_path, expect_hasChars) \
1225 { \
1226 const bool ret = BLI_path_frame_check_chars(input_path); \
1227 if (expect_hasChars) { \
1228 EXPECT_TRUE(ret); \
1229 } \
1230 else { \
1231 EXPECT_FALSE(ret); \
1232 } \
1233 } \
1234 ((void)0)
1235
1236TEST(path_utils, FrameCheckChars)
1237{
1238 PATH_FRAME_CHECK_CHARS("a#", true);
1239 PATH_FRAME_CHECK_CHARS("aaaaa#", true);
1240 PATH_FRAME_CHECK_CHARS("#aaaaa", true);
1241 PATH_FRAME_CHECK_CHARS("a##.###", true);
1242 PATH_FRAME_CHECK_CHARS("####.abc#", true);
1243 PATH_FRAME_CHECK_CHARS("path/to/chars/a#", true);
1244 PATH_FRAME_CHECK_CHARS("path/to/chars/123#123.exe", true);
1245
1246 PATH_FRAME_CHECK_CHARS("&", false);
1247 PATH_FRAME_CHECK_CHARS("\35", false);
1248 PATH_FRAME_CHECK_CHARS("path#/to#/chars#/$.h", false);
1249 PATH_FRAME_CHECK_CHARS("path#/to#/chars#/nochars.h", false);
1250 PATH_FRAME_CHECK_CHARS("..\\dirty\\path#/..//to#\\chars#/nochars.h", false);
1251 PATH_FRAME_CHECK_CHARS("..\\dirty\\path#/..//to#/chars#\\nochars.h", false);
1252}
1253#undef PATH_FRAME_CHECK_CHARS
1254
1256
1257/* -------------------------------------------------------------------- */
1260
1261#define PATH_FRAME_RANGE(input_path, sta, end, digits, expect_outpath) \
1262 { \
1263 char path[FILE_MAX]; \
1264 bool ret; \
1265 STRNCPY(path, input_path); \
1266 ret = BLI_path_frame_range(path, sizeof(path), sta, end, digits); \
1267 if (expect_outpath == nullptr) { \
1268 EXPECT_FALSE(ret); \
1269 } \
1270 else { \
1271 EXPECT_TRUE(ret); \
1272 EXPECT_STREQ(path, expect_outpath); \
1273 } \
1274 } \
1275 ((void)0)
1276
1277TEST(path_utils, FrameRange)
1278{
1279 int dummy = -1;
1280 PATH_FRAME_RANGE("#", 1, 2, dummy, "1-2");
1281 PATH_FRAME_RANGE("##", 1, 2, dummy, "01-02");
1282 PATH_FRAME_RANGE("##", 1000, 2000, dummy, "1000-2000");
1283 PATH_FRAME_RANGE("###", 100, 200, dummy, "100-200");
1284 PATH_FRAME_RANGE("###", 8, 9, dummy, "008-009");
1285
1286 PATH_FRAME_RANGE("", 100, 200, 1, "100-200");
1287 PATH_FRAME_RANGE("", 123, 321, 4, "0123-0321");
1288 PATH_FRAME_RANGE("", 1, 0, 20, "00000000000000000001-00000000000000000000");
1289
1290 /* No room to add the digits, the path is left unchanged. */
1291 {
1292 char path[8 + 5];
1293 memset(path, 0xff, sizeof(path));
1294 path[sizeof(path) - 1] = '\0';
1295 BLI_strncpy(path, "test_ab", 8);
1296 EXPECT_FALSE(BLI_path_frame_range(path, 8, 1, 2, 4));
1297 EXPECT_STREQ(path, "test_ab");
1298 EXPECT_STREQ(path + 8, "\xff\xff\xff\xff");
1299 }
1300}
1301#undef PATH_FRAME_RANGE
1302
1304
1305/* -------------------------------------------------------------------- */
1308
1309#define PATH_FRAME_GET(input_path, expect_frame, expect_numdigits, expect_pathisvalid) \
1310 { \
1311 char path[FILE_MAX]; \
1312 int out_frame = -1, out_numdigits = -1; \
1313 STRNCPY(path, input_path); \
1314 const bool ret = BLI_path_frame_get(path, &out_frame, &out_numdigits); \
1315 if (expect_pathisvalid) { \
1316 EXPECT_TRUE(ret); \
1317 } \
1318 else { \
1319 EXPECT_FALSE(ret); \
1320 } \
1321 EXPECT_EQ(out_frame, expect_frame); \
1322 EXPECT_EQ(out_numdigits, expect_numdigits); \
1323 } \
1324 ((void)0)
1325
1326TEST(path_utils, FrameGet)
1327{
1328 PATH_FRAME_GET("001.avi", 1, 3, true);
1329 PATH_FRAME_GET("0000299.ext", 299, 7, true);
1330 PATH_FRAME_GET("path/to/frame_2810.dummy_quite_long_extension", 2810, 4, true);
1331 PATH_FRAME_GET("notframe_7_frame00018.bla", 18, 5, true);
1332
1333 /* Check int overflow scenario. */
1334 PATH_FRAME_GET("1234567890.png", 1234567890, 10, true);
1335 PATH_FRAME_GET("12345678901.png", -1, 11, false);
1336
1337 PATH_FRAME_GET("nonum.abc", -1, 0, false);
1338 PATH_FRAME_GET("", -1, -1, false);
1339}
1340#undef PATH_FRAME_GET
1341
1343
1344/* -------------------------------------------------------------------- */
1347
1348#define PATH_SEQ_DECODE(path_literal, expect_result, expect_head, expect_tail, expect_numdigits) \
1349 { \
1350 const char *path = path_literal; \
1351 char head[FILE_MAX]; \
1352 char tail[FILE_MAX]; \
1353 ushort numdigits = 0; \
1354 const int result = BLI_path_sequence_decode( \
1355 path, head, sizeof(head), tail, sizeof(tail), &numdigits); \
1356 EXPECT_EQ(result, expect_result); \
1357 EXPECT_STREQ(head, expect_head); \
1358 EXPECT_STREQ(tail, expect_tail); \
1359 EXPECT_EQ(numdigits, expect_numdigits); \
1360 } \
1361 (void)0;
1362
1363TEST(path_utils, SequenceDecode)
1364{
1365 /* Basic use. */
1366 PATH_SEQ_DECODE("file_123.txt", 123, "file_", ".txt", 3);
1367 PATH_SEQ_DECODE("file_123.321", 123, "file_", ".321", 3);
1368 PATH_SEQ_DECODE(".file_123.txt", 123, ".file_", ".txt", 3);
1369
1370 /* No-op. */
1371 PATH_SEQ_DECODE("file.txt", 0, "file", ".txt", 0);
1372 PATH_SEQ_DECODE("file.123", 0, "file", ".123", 0);
1373 PATH_SEQ_DECODE("file", 0, "file", "", 0);
1374 PATH_SEQ_DECODE("file_123.txt/", 0, "file_123.txt/", "", 0);
1375}
1376
1377#undef PATH_SEQ_DECODE
1378
1380
1381/* -------------------------------------------------------------------- */
1384
1385#define PATH_SUFFIX(path_literal, path_literal_max, sep, suffix, expect_result, expect_path) \
1386 { \
1387 char path[FILE_MAX] = path_literal; \
1388 const bool result = BLI_path_suffix(path, path_literal_max, suffix, sep); \
1389 EXPECT_EQ(result, expect_result); \
1390 EXPECT_STREQ(path, expect_path); \
1391 } \
1392 (void)0;
1393
1394TEST(path_utils, Suffix)
1395{
1396 /* Extension. */
1397 PATH_SUFFIX("file.txt", FILE_MAX, "_", "123", true, "file_123.txt");
1398 PATH_SUFFIX("/dir/file.txt", FILE_MAX, "_", "123", true, "/dir/file_123.txt");
1399 /* No-extension. */
1400 PATH_SUFFIX("file", FILE_MAX, "_", "123", true, "file_123");
1401 PATH_SUFFIX("/dir/file", FILE_MAX, "_", "123", true, "/dir/file_123");
1402 /* No-op. */
1403 PATH_SUFFIX("file.txt", FILE_MAX, "", "", true, "file.txt");
1404 /* Size limit, too short by 1. */
1405 PATH_SUFFIX("file.txt", 10, "A", "B", false, "file.txt");
1406 /* Size limit, fits exactly. */
1407 PATH_SUFFIX("file.txt", 11, "A", "B", true, "fileAB.txt");
1408 /* Empty path. */
1409 PATH_SUFFIX("", FILE_MAX, "_", "123", true, "_123");
1410 /* Empty input/output. */
1411 PATH_SUFFIX("", FILE_MAX, "", "", true, "");
1412
1413 /* Long suffix. */
1414 PATH_SUFFIX("file.txt", FILE_MAX, "_", "1234567890", true, "file_1234567890.txt");
1415 /* Long extension. */
1416 PATH_SUFFIX("file.txt1234567890", FILE_MAX, "_", "123", true, "file_123.txt1234567890");
1417}
1418
1419#undef PATH_SUFFIX
1420
1422
1423/* -------------------------------------------------------------------- */
1426
1427#define PATH_SLASH_FIND(path, expect_index) \
1428 { \
1429 const char *result = BLI_path_slash_find(path); \
1430 EXPECT_EQ(result, &path[expect_index]); \
1431 } \
1432 (void)0;
1433
1434TEST(path_util, SlashFind)
1435{
1436 PATH_SLASH_FIND("/", 0);
1437 PATH_SLASH_FIND("\\", 0);
1438 PATH_SLASH_FIND("\\tmp\\", 0);
1439 PATH_SLASH_FIND("/tmp\\", 0);
1440 PATH_SLASH_FIND("\\tmp/", 0);
1441 PATH_SLASH_FIND("/tmp/", 0);
1442 PATH_SLASH_FIND("tmp\\", 3);
1443 PATH_SLASH_FIND("tmp/", 3);
1444
1445 EXPECT_EQ(BLI_path_slash_find("no_slashes"), nullptr);
1446 EXPECT_EQ(BLI_path_slash_find(""), nullptr);
1447 EXPECT_EQ(BLI_path_slash_find("."), nullptr);
1448}
1449
1450#undef PATH_SLASH_FIND
1451
1453
1454/* -------------------------------------------------------------------- */
1457
1458#define PATH_SLASH_RFIND(path, expect_index) \
1459 { \
1460 const char *result = BLI_path_slash_rfind(path); \
1461 EXPECT_STREQ(result, &path[expect_index]); \
1462 } \
1463 (void)0;
1464
1465TEST(path_util, SlashRFind)
1466{
1467 PATH_SLASH_RFIND("/", 0);
1468 PATH_SLASH_RFIND("\\", 0);
1469 PATH_SLASH_RFIND("\\tmp\\", 4);
1470 PATH_SLASH_RFIND("/tmp\\", 4);
1471 PATH_SLASH_RFIND("\\tmp/", 4);
1472 PATH_SLASH_RFIND("/tmp/", 4);
1473 PATH_SLASH_RFIND("tmp\\", 3);
1474 PATH_SLASH_RFIND("tmp/", 3);
1475 PATH_SLASH_RFIND("/tmp", 0);
1476 PATH_SLASH_RFIND("\\tmp", 0);
1477
1478 EXPECT_EQ(BLI_path_slash_rfind("no_slashes"), nullptr);
1479 EXPECT_EQ(BLI_path_slash_rfind(""), nullptr);
1480 EXPECT_EQ(BLI_path_slash_rfind("."), nullptr);
1481}
1482
1483#undef PATH_SLASH_RFIND
1484
1486
1487/* -------------------------------------------------------------------- */
1490
1491#define PATH_SLASH_ENSURE(input, size, output_expect, length_expect) \
1492 { \
1493 char path[size] = input; \
1494 if (SEP == '\\') { \
1495 BLI_string_replace_char(path, '/', '\\'); \
1496 } \
1497 int result = BLI_path_slash_ensure(path, size); \
1498 if (SEP == '\\') { \
1499 BLI_string_replace_char(path, '\\', '/'); \
1500 } \
1501 EXPECT_STREQ(path, output_expect); \
1502 EXPECT_EQ(result, length_expect); \
1503 } \
1504 ((void)0)
1505
1506TEST(path_util, SlashEnsure)
1507{
1508 PATH_SLASH_ENSURE("/tmp", FILE_MAX, "/tmp/", 5);
1509 PATH_SLASH_ENSURE("", FILE_MAX, "/", 1);
1510 PATH_SLASH_ENSURE("", 2, "/", 1);
1511
1512 /* no change */
1513 PATH_SLASH_ENSURE("/tmp/", FILE_MAX, "/tmp/", 5);
1514 PATH_SLASH_ENSURE("/", FILE_MAX, "/", 1);
1515
1516 /* Not enough space reserved to add a slash, so do nothing. */
1517 PATH_SLASH_ENSURE("", 1, "", 0);
1518 PATH_SLASH_ENSURE("/tmp", 5, "/tmp", 4);
1519}
1520
1521#undef PATH_SLASH_ENSURE
1522
1524
1525/* -------------------------------------------------------------------- */
1528
1529#define PATH_SLASH_RSTRIP(input, expected) \
1530 { \
1531 char path[FILE_MAX] = input; \
1532 if (SEP == '\\') { \
1533 BLI_string_replace_char(path, '/', '\\'); \
1534 } \
1535 BLI_path_slash_rstrip(path); \
1536 if (SEP == '\\') { \
1537 BLI_string_replace_char(path, '\\', '/'); \
1538 } \
1539 EXPECT_STREQ(path, expected); \
1540 } \
1541 ((void)0)
1542
1543TEST(path_util, SlashRStrip)
1544{
1545 PATH_SLASH_RSTRIP("/brown/cow/", "/brown/cow");
1546 PATH_SLASH_RSTRIP("/brown/cow", "/brown/cow");
1547 PATH_SLASH_RSTRIP("/brown/", "/brown");
1548 PATH_SLASH_RSTRIP("/brown", "/brown");
1549 PATH_SLASH_RSTRIP("/brown/../", "/brown/..");
1550 PATH_SLASH_RSTRIP("/brown/..", "/brown/..");
1551 PATH_SLASH_RSTRIP("/brown///", "/brown");
1552 PATH_SLASH_RSTRIP("/", "");
1553 PATH_SLASH_RSTRIP("", "");
1554 PATH_SLASH_RSTRIP(".", ".");
1555}
1556
1557#undef PATH_SLASH_RSTRIP
1558
1560
1561/* -------------------------------------------------------------------- */
1564
1565#define PATH_SLASH_SKIP(input, expected) \
1566 { \
1567 char path[FILE_MAX] = input; \
1568 if (SEP == '\\') { \
1569 BLI_string_replace_char(path, '/', '\\'); \
1570 } \
1571 const char *skipped = BLI_path_slash_skip(path); \
1572 if (SEP == '\\') { \
1573 BLI_string_replace_char(path, '\\', '/'); \
1574 } \
1575 EXPECT_STREQ(skipped, expected); \
1576 } \
1577 ((void)0)
1578
1579TEST(path_util, SlashSkip)
1580{
1581 PATH_SLASH_SKIP("/brown", "brown");
1582 PATH_SLASH_SKIP("brown", "brown");
1583 PATH_SLASH_SKIP("////brown", "brown");
1584 PATH_SLASH_SKIP("/../brown", "../brown");
1585 PATH_SLASH_SKIP("../brown", "../brown");
1586 PATH_SLASH_SKIP("/", "");
1587 PATH_SLASH_SKIP("/////", "");
1588 PATH_SLASH_SKIP("", "");
1589 PATH_SLASH_SKIP(".", ".");
1590}
1591
1592#undef PATH_SLASH_SKIP
1593
1595
1596/* -------------------------------------------------------------------- */
1599
1600#define PATH_SLASH_NATIVE(input, expected) \
1601 { \
1602 char path[FILE_MAX] = input; \
1603 BLI_path_slash_native(path); \
1604 EXPECT_STREQ(path, expected); \
1605 } \
1606 ((void)0)
1607
1608TEST(path_util, SlashNative)
1609{
1610#ifdef WIN32
1611 PATH_SLASH_NATIVE("C:/", "C:\\");
1612 PATH_SLASH_NATIVE("C:\\", "C:\\");
1613 PATH_SLASH_NATIVE("C:\\tmp\\", "C:\\tmp\\");
1614 PATH_SLASH_NATIVE("C:/tmp\\", "C:\\tmp\\");
1615 PATH_SLASH_NATIVE("C:\\tmp/", "C:\\tmp\\");
1616 PATH_SLASH_NATIVE("C:/tmp/", "C:\\tmp\\");
1617 PATH_SLASH_NATIVE("tmp\\", "tmp\\");
1618 PATH_SLASH_NATIVE("tmp/", "tmp\\");
1619 PATH_SLASH_NATIVE("..\\tmp\\", "..\\tmp\\");
1620 PATH_SLASH_NATIVE("../tmp/", "..\\tmp\\");
1621 PATH_SLASH_NATIVE("C:/tmp", "C:\\tmp");
1622 PATH_SLASH_NATIVE("C:\\tmp", "C:\\tmp");
1623 PATH_SLASH_NATIVE("tmp", "tmp");
1624 PATH_SLASH_NATIVE("", "");
1625 PATH_SLASH_NATIVE(".", ".");
1626
1627 PATH_SLASH_NATIVE("\\\\server\\share", "\\\\server\\share");
1628 PATH_SLASH_NATIVE("\\\\server/share", "\\\\server\\share");
1629 PATH_SLASH_NATIVE("\\\\?\\server\\share", "\\\\?\\server\\share");
1630 PATH_SLASH_NATIVE("\\\\?\\server/share", "\\\\?\\server\\share");
1631 PATH_SLASH_NATIVE("\\\\?\\C:\\file.txt", "\\\\?\\C:\\file.txt");
1632 PATH_SLASH_NATIVE("\\\\?\\C:/file.txt", "\\\\?\\C:\\file.txt");
1633#else
1634 PATH_SLASH_NATIVE("/", "/");
1635 PATH_SLASH_NATIVE("\\", "/");
1636 PATH_SLASH_NATIVE("\\tmp\\", "/tmp/");
1637 PATH_SLASH_NATIVE("/tmp\\", "/tmp/");
1638 PATH_SLASH_NATIVE("\\tmp/", "/tmp/");
1639 PATH_SLASH_NATIVE("/tmp/", "/tmp/");
1640 PATH_SLASH_NATIVE("tmp\\", "tmp/");
1641 PATH_SLASH_NATIVE("tmp/", "tmp/");
1642 PATH_SLASH_NATIVE("..\\tmp\\", "../tmp/");
1643 PATH_SLASH_NATIVE("../tmp/", "../tmp/");
1644 PATH_SLASH_NATIVE("/tmp", "/tmp");
1645 PATH_SLASH_NATIVE("\\tmp", "/tmp");
1646 PATH_SLASH_NATIVE("tmp", "tmp");
1647 PATH_SLASH_NATIVE("", "");
1648 PATH_SLASH_NATIVE(".", ".");
1649
1650 PATH_SLASH_NATIVE("\\\\server\\share", "\\\\server/share");
1651 PATH_SLASH_NATIVE("\\\\server/share", "\\\\server/share");
1652 PATH_SLASH_NATIVE("\\\\?\\server\\share", "\\\\?\\server/share");
1653 PATH_SLASH_NATIVE("\\\\?\\server/share", "\\\\?\\server/share");
1654 PATH_SLASH_NATIVE("\\\\?\\home\\user\\file.txt", "\\\\?\\home/user/file.txt");
1655 PATH_SLASH_NATIVE("\\\\?\\home\\user/file.txt", "\\\\?\\home/user/file.txt");
1656#endif
1657}
1658
1659#undef PATH_SLASH_NATIVE
1660
1662
1663/* -------------------------------------------------------------------- */
1666
1667#define PATH_REL(abs_path, ref_path, rel_path_expect) \
1668 { \
1669 char path[FILE_MAX]; \
1670 const char *ref_path_test = ref_path; \
1671 STRNCPY(path, abs_path); \
1672 if (SEP == '\\') { \
1673 BLI_string_replace_char(path, '/', '\\'); \
1674 ref_path_test = str_replace_char_strdup(ref_path_test, '/', '\\'); \
1675 } \
1676 BLI_path_rel(path, ref_path_test); \
1677 if (SEP == '\\') { \
1678 BLI_string_replace_char(path, '\\', '/'); \
1679 free((void *)ref_path_test); \
1680 } \
1681 EXPECT_STREQ(path, rel_path_expect); \
1682 } \
1683 void(0)
1684
1685TEST(path_utils, RelPath_Simple)
1686{
1687 PATH_REL(ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/foo/bar/", "//blender.blend");
1688}
1689
1690TEST(path_utils, RelPath_SimpleSubdir)
1691{
1692 PATH_REL(ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/foo/bar", "//bar/blender.blend");
1693}
1694
1695TEST(path_utils, RelPath_SameDir)
1696{
1697 PATH_REL(ABS_PREFIX "/foo/bar", ABS_PREFIX "/foo/bar/", "//");
1698 PATH_REL(ABS_PREFIX "/foo/bar/", ABS_PREFIX "/foo/bar/", "//");
1699}
1700
1701TEST(path_utils, RelPath_ParentDir)
1702{
1703 /* Only entire directory names match, not any prefix. */
1704 PATH_REL(ABS_PREFIX "/foo/baz/blender.blend", ABS_PREFIX "/foo/bar/", "//../baz/blender.blend");
1705 PATH_REL(
1706 ABS_PREFIX "/foo/barz/blender.blend", ABS_PREFIX "/foo/bar/", "//../barz/blender.blend");
1707}
1708
1709TEST(path_utils, RelPath_NoCommonRoot)
1710{
1711 /* Relative paths are left unchanged, there is no common root to be relative to. */
1712 PATH_REL("blender.blend", ABS_PREFIX "/foo/bar/", "blender.blend");
1713}
1714
1715TEST(path_utils, RelPath_BufferOverflowRoot)
1716{
1717 char abs_path_in[FILE_MAX];
1718 const char *abs_prefix = ABS_PREFIX "/";
1719 for (int i = STRNCPY_RLEN(abs_path_in, abs_prefix); i < FILE_MAX - 1; i++) {
1720 abs_path_in[i] = 'A';
1721 }
1722 abs_path_in[FILE_MAX - 1] = '\0';
1723 char abs_path_out[FILE_MAX];
1724 for (int i = STRNCPY_RLEN(abs_path_out, "//"); i < FILE_MAX - 1; i++) {
1725 abs_path_out[i] = 'A';
1726 }
1727 abs_path_out[FILE_MAX - std::max((strlen(abs_prefix) - 1), size_t(1))] = '\0';
1728 PATH_REL(abs_path_in, abs_prefix, abs_path_out);
1729}
1730
1731TEST(path_utils, RelPath_BufferOverflowSubdir)
1732{
1733 char abs_path_in[FILE_MAX];
1734 const char *ref_path_in = ABS_PREFIX "/foo/bar/";
1735 const size_t ref_path_in_len = strlen(ref_path_in);
1736 for (int i = STRNCPY_RLEN(abs_path_in, ref_path_in); i < FILE_MAX - 1; i++) {
1737 abs_path_in[i] = 'A';
1738 }
1739 abs_path_in[FILE_MAX - 1] = '\0';
1740 char abs_path_out[FILE_MAX];
1741 for (int i = STRNCPY_RLEN(abs_path_out, "//"); i < FILE_MAX - (int(ref_path_in_len) - 1); i++) {
1742 abs_path_out[i] = 'A';
1743 }
1744 abs_path_out[FILE_MAX - std::max((ref_path_in_len - 1), size_t(1))] = '\0';
1745 PATH_REL(abs_path_in, ref_path_in, abs_path_out);
1746}
1747
1748#undef PATH_REL
1749
1751
1752/* -------------------------------------------------------------------- */
1755
1756#define PATH_ABS(rel_path, base_path, abs_path_expect, result_expect) \
1757 { \
1758 char path[FILE_MAX]; \
1759 const char *base_path_test = base_path; \
1760 STRNCPY(path, rel_path); \
1761 if (SEP == '\\') { \
1762 base_path_test = str_replace_char_strdup(base_path_test, '/', '\\'); \
1763 } \
1764 const bool result_test = BLI_path_abs(path, base_path_test); \
1765 if (SEP == '\\') { \
1766 BLI_string_replace_char(path, '\\', '/'); \
1767 free((void *)base_path_test); \
1768 } \
1769 EXPECT_STREQ(path, abs_path_expect); \
1770 EXPECT_EQ(result_test, result_expect); \
1771 } \
1772 void(0)
1773
1774TEST(path_utils, AbsPath_Simple)
1775{
1776 PATH_ABS("//a.png", ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/foo/bar/a.png", true);
1777 PATH_ABS("//a/b.png", ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/foo/bar/a/b.png", true);
1778}
1779
1780TEST(path_utils, AbsPath_BaseDir)
1781{
1782 /* The last component of the base is ignored. */
1783 PATH_ABS("//a.png", ABS_PREFIX "/foo/bar/", ABS_PREFIX "/foo/bar/a.png", true);
1784 PATH_ABS("//a.png", ABS_PREFIX "/foo/bar", ABS_PREFIX "/foo/a.png", true);
1785 PATH_ABS("//a.png", ABS_PREFIX "/blender.blend", ABS_PREFIX "/a.png", true);
1786}
1787
1788TEST(path_utils, AbsPath_PrefixOnly)
1789{
1790 PATH_ABS("//", ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/foo/bar/", true);
1791 PATH_ABS("///", ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/foo/bar/", true);
1792 PATH_ABS("//", "", "", true);
1793}
1794
1795TEST(path_utils, AbsPath_ParentDir)
1796{
1797 PATH_ABS("//../a.png", ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/foo/a.png", true);
1798 PATH_ABS("//../../../a.png", ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/a.png", true);
1799}
1800
1801TEST(path_utils, AbsPath_BackSlash)
1802{
1803 PATH_ABS("//a\\b.png", ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/foo/bar/a/b.png", true);
1804}
1805
1806TEST(path_utils, AbsPath_NotRelative)
1807{
1808 /* Absolute paths are returned unchanged. */
1809 PATH_ABS(
1810 ABS_PREFIX "/a/b.png", ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/a/b.png", false);
1811}
1812
1813#ifndef WIN32
1814TEST(path_utils, AbsPath_Win32DriveOnPosix)
1815{
1816 PATH_ABS("C:\\foo.JPG", "/foo/bar/blender.blend", "/c/foo.JPG", false);
1817}
1818#endif
1819
1820TEST(path_utils, AbsPath_ExtraSlashes)
1821{
1822 PATH_ABS("///a.png", ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/foo/bar/a.png", true);
1823 PATH_ABS("////a.png", ABS_PREFIX "/foo/bar/blender.blend", ABS_PREFIX "/foo/bar/a.png", true);
1824}
1825
1826TEST(path_utils, AbsPath_NoBaseDir)
1827{
1828 PATH_ABS("//a.png", "", "a.png", true);
1829 PATH_ABS("//a/b.png", "", "a/b.png", true);
1830 PATH_ABS("//a.png", "blender.blend", "a.png", true);
1831 PATH_ABS("//../a.png", "", "../a.png", true);
1832}
1833
1834TEST(path_utils, AbsPath_NoBaseDirExtraSlashes)
1835{
1836 /* Must not become an absolute path. */
1837 PATH_ABS("///a.png", "", "a.png", true);
1838 PATH_ABS("////a.png", "", "a.png", true);
1839 PATH_ABS("///a.png", "blender.blend", "a.png", true);
1840 PATH_ABS("///", "", "", true);
1841}
1842
1843TEST(path_utils, AbsPath_BufferOverflow)
1844{
1845 const char *base_dir = ABS_PREFIX "/foo/bar/";
1846 char rel_path_in[FILE_MAX];
1847 for (int i = STRNCPY_RLEN(rel_path_in, "//"); i < FILE_MAX - 1; i++) {
1848 rel_path_in[i] = 'A';
1849 }
1850 rel_path_in[FILE_MAX - 1] = '\0';
1851 char abs_path_out[FILE_MAX];
1852 for (int i = STRNCPY_RLEN(abs_path_out, base_dir); i < FILE_MAX - 1; i++) {
1853 abs_path_out[i] = 'A';
1854 }
1855 abs_path_out[FILE_MAX - 1] = '\0';
1856 PATH_ABS(rel_path_in, ABS_PREFIX "/foo/bar/blender.blend", abs_path_out, true);
1857}
1858
1859#undef PATH_ABS
1860
1862
1863/* -------------------------------------------------------------------- */
1866
1867TEST(path_utils, PathIsRel)
1868{
1869 EXPECT_TRUE(BLI_path_is_rel("//file.txt"));
1870
1873 EXPECT_FALSE(BLI_path_is_rel("\\file.txt"));
1874 EXPECT_FALSE(BLI_path_is_rel("\\\\file.txt"));
1875 EXPECT_FALSE(BLI_path_is_rel(".hide/file.txt"));
1876 EXPECT_FALSE(BLI_path_is_rel("file.txt"));
1877 EXPECT_FALSE(BLI_path_is_rel("C:/file.txt"));
1878 EXPECT_FALSE(BLI_path_is_rel("../file.txt"));
1879 EXPECT_FALSE(BLI_path_is_rel("\\\\host\\server\\file.txt"));
1880 EXPECT_FALSE(BLI_path_is_rel("\\\\?\\C:\\server\\file.txt"));
1881}
1882
1884
1885/* -------------------------------------------------------------------- */
1888
1889TEST(path_utils, PathIsAbsFromCwd)
1890{
1891#ifdef WIN32
1894
1896 EXPECT_TRUE(BLI_path_is_abs_from_cwd("C:/file.txt"));
1897 EXPECT_TRUE(BLI_path_is_abs_from_cwd("C:\\file.txt"));
1898 EXPECT_TRUE(BLI_path_is_abs_from_cwd("\\\\host\\server\\file.txt"));
1899 EXPECT_TRUE(BLI_path_is_abs_from_cwd("\\\\?\\C:\\server\\file.txt"));
1900#else
1903
1905 EXPECT_FALSE(BLI_path_is_abs_from_cwd("C:/file.txt"));
1906 EXPECT_FALSE(BLI_path_is_abs_from_cwd("C:\\file.txt"));
1907 EXPECT_FALSE(BLI_path_is_abs_from_cwd("\\\\host\\server\\file.txt"));
1908 EXPECT_FALSE(BLI_path_is_abs_from_cwd("\\\\?\\C:\\server\\file.txt"));
1909#endif
1910
1914 EXPECT_FALSE(BLI_path_is_abs_from_cwd("../file.txt"));
1916}
1917
1919
1920/* -------------------------------------------------------------------- */
1923
1924TEST(path_utils, Contains)
1925{
1926 EXPECT_TRUE(BLI_path_contains("/some/path", "/some/path")) << "A path contains itself";
1927 EXPECT_TRUE(BLI_path_contains("/some/path/", "/some/path"))
1928 << "A trailing slash on the container makes no difference";
1929 EXPECT_TRUE(BLI_path_contains("/some/path", "/some/path/"))
1930 << "A trailing slash on the containee makes no difference";
1931 EXPECT_TRUE(BLI_path_contains("/some/path", "/some/path/inside"))
1932 << "A path contains its subdirectory";
1933 EXPECT_TRUE(BLI_path_contains("/some/path", "/some/path/../path/inside"))
1934 << "Paths should be normalized";
1935 EXPECT_TRUE(BLI_path_contains("C:\\some\\path", "C:\\some\\path\\inside"))
1936 << "Windows paths should be supported as well";
1937
1938 EXPECT_FALSE(BLI_path_contains("C:\\some\\path", "C:\\some\\other\\path"))
1939 << "Windows paths should be supported as well";
1940 EXPECT_FALSE(BLI_path_contains("/some/path", "/"))
1941 << "Root directory not be contained in a subdirectory";
1942 EXPECT_FALSE(BLI_path_contains("/some/path", "/some/path/../outside"))
1943 << "Paths should be normalized";
1944 EXPECT_FALSE(BLI_path_contains("/some/path", "/some/path_library"))
1945 << "Just sharing a suffix is not enough, path semantics should be followed";
1946 EXPECT_FALSE(BLI_path_contains("/some/path", "./contents"))
1947 << "Relative paths are not supported";
1948 EXPECT_FALSE(BLI_path_contains("", "/some/path")) << "Empty container path contains nothing";
1949}
1950
1951#ifdef WIN32
1952TEST(path_utils, Contains_Windows_case_insensitive)
1953{
1954 EXPECT_TRUE(BLI_path_contains("C:\\some\\path", "c:\\SOME\\path\\inside"))
1955 << "On Windows path comparison should ignore case";
1956 EXPECT_TRUE(BLI_path_contains("\\\\Server\\Share", "\\\\server/SHARE\\inside"))
1957 << "On Windows UNC server and share should ignore case and slash direction";
1958 EXPECT_TRUE(BLI_path_contains("\\\\server\\share", "\\\\server\\share"))
1959 << "A UNC share contains itself";
1960 EXPECT_FALSE(BLI_path_contains("\\\\server\\share", "\\\\server\\other\\inside"))
1961 << "Different UNC shares";
1962 EXPECT_FALSE(BLI_path_relative_to("\\\\server", "\\\\server\\share\\", true, nullptr, 0))
1963 << "A UNC server is not a parent of its shares";
1964}
1965#endif /* WIN32 */
1966
1968
1969/* -------------------------------------------------------------------- */
1972
1973TEST(path_utils, RelativeTo)
1974{
1975 char relative[FILE_MAX];
1976
1977 EXPECT_TRUE(BLI_path_relative_to("/some/path", "/some/path", false, relative, sizeof(relative)));
1978 EXPECT_STREQ(relative, "") << "Path is relative to itself";
1979
1981 BLI_path_relative_to("/some/path", "/some/path/", false, relative, sizeof(relative)));
1982 EXPECT_STREQ(relative, "") << "Trailing slash makes no difference";
1983
1985 BLI_path_relative_to("/some/path/inside", "/some/path", false, relative, sizeof(relative)));
1986 EXPECT_STREQ(relative, "inside");
1987
1989 BLI_path_relative_to("/some/path/in/side", "/some/path/", false, relative, sizeof(relative)))
1990 << "Trailing slash on base makes no difference";
1991 EXPECT_STREQ(relative, "in" SEP_STR "side");
1992
1994 "/some/path/../path/inside", "/some/path", false, relative, sizeof(relative)));
1995 EXPECT_STREQ(relative, "inside") << "Relative path is normalized";
1996
1997 STRNCPY(relative, "uninitialized");
1999 BLI_path_relative_to("/some/path_library", "/some/path", false, relative, sizeof(relative)));
2000 EXPECT_STREQ(relative, "");
2001
2002 STRNCPY(relative, "uninitialized");
2004 BLI_path_relative_to("/some/outside", "/some/path", false, relative, sizeof(relative)));
2005 EXPECT_STREQ(relative, "");
2006
2007 EXPECT_FALSE(BLI_path_relative_to("//inside", "/some/path", true, relative, sizeof(relative)))
2008 << "Blend file relative paths are not supported";
2009
2010#ifdef WIN32
2011 /* Case insensitive on Windows only. */
2013 "c:\\SOME\\path\\InSide", "C:\\some\\path", false, relative, sizeof(relative)));
2014 EXPECT_STREQ(relative, "InSide") << "Case insensitive on Windows";
2015
2017 "D:\\some\\path\\inside", "C:\\some\\path", true, relative, sizeof(relative)))
2018 << "Another drive has no common root";
2019#endif
2020}
2021
2022TEST(path_utils, RelativeTo_walk_up)
2023{
2024 char relative[FILE_MAX];
2025
2027 BLI_path_relative_to("/some/path/inside", "/some/path", true, relative, sizeof(relative)));
2028 EXPECT_STREQ(relative, "inside");
2029
2030 EXPECT_TRUE(BLI_path_relative_to("/some/path", "/some/path", true, relative, sizeof(relative)));
2031 EXPECT_STREQ(relative, "") << "Equal paths";
2032
2034 BLI_path_relative_to("/some/outside", "/some/path", true, relative, sizeof(relative)));
2035 EXPECT_STREQ(relative, ".." SEP_STR "outside");
2036
2038 BLI_path_relative_to("/some/path_library", "/some/path", true, relative, sizeof(relative)));
2039 EXPECT_STREQ(relative, ".." SEP_STR "path_library") << "Sibling path";
2040
2041 EXPECT_TRUE(BLI_path_relative_to("/a/b/c/d", "/a/x/y", true, relative, sizeof(relative)));
2042 EXPECT_STREQ(relative, ".." SEP_STR ".." SEP_STR "b" SEP_STR "c" SEP_STR "d");
2043
2045 BLI_path_relative_to("/some", "/some/path/inside", true, relative, sizeof(relative)));
2046 EXPECT_STREQ(relative, ".." SEP_STR ".." SEP_STR) << "Parent of the base directory";
2047}
2048
2050
2051/* -------------------------------------------------------------------- */
2054
2055TEST(path_utils, HasHiddenComponents)
2056{
2057 /* No hidden components: */
2081
2082 /* NOTE: path component that is just a dot is not considered hidden. */
2090
2091 /* Does contain hidden components: */
2103
2104 /* Tilde at end of path component: considered hidden. */
2113}
2114
2115#if DO_PERF_TESTS
2116
2117# include "BLI_timeit.hh"
2118
2119TEST(path_utils, HasHiddenComponents_Performance)
2120{
2121 SCOPED_TIMER(__func__);
2122 const char *test_paths[] = {
2123 "test.txt",
2124 "test/a_fairly_long/path/here/shall_we/ok.txt",
2125 "test/a_fairly_long/path/here/.with_a_hidden_component/shall_we/ok.txt",
2126 "test/.another_path_with_hidden_component/yes.txt",
2127 "test/another/path/with/.hidden_filename",
2128 };
2129 const int RUN_COUNT = 10'000'000;
2130 int hidden = 0;
2131 for (int i = 0; i < RUN_COUNT; i++) {
2132 for (int j = 0; j < ARRAY_SIZE(test_paths); j++) {
2133 hidden += BLI_path_has_hidden_component(test_paths[j]) ? 1 : 0;
2134 }
2135 }
2136 EXPECT_EQ(RUN_COUNT * 3, hidden);
2137}
2138
2139#endif
2140
2142
2143#undef ABS_PREFIX
2144
2145} // namespace blender
File and directory operations.
#define FILE_MAX
#define PATH_EXTENSION_REPLACE(input_path, input_ext, expect_result, expect_path)
#define PATH_SLASH_NATIVE(input, expected)
#define PATH_FRAME_RANGE(input_path, sta, end, digits, expect_outpath)
#define PATH_SLASH_RSTRIP(input, expected)
#define JOIN
#define PATH_SLASH_ENSURE(input, size, output_expect, length_expect)
#define PATH_ABS(rel_path, base_path, abs_path_expect, result_expect)
#define PATH_EXTENSION_CHECK(input_path, input_ext, expect_ext)
#define PATH_SLASH_FIND(path, expect_index)
#define PATH_FRAME_STRIP(input_path, expect_path, expect_ext)
#define APPEND(str_expect, size, path, filename)
#define TEST_STR
#define PATH_SLASH_RFIND(path, expect_index)
#define PATH_SEQ_DECODE(path_literal, expect_result, expect_head, expect_tail, expect_numdigits)
#define AT_INDEX(str_input, index_input, str_expect)
#define ABS_PREFIX
#define PATH_EXTENSION_REPLACE_WITH_MAXLEN(input_path, input_ext, expect_result, expect_path, maxlen)
#define PATH_SLASH_SKIP(input, expected)
#define NORMALIZE(input, output_expect)
#define PATH_EXTENSION_ENSURE_WITH_MAXLEN(input_path, input_ext, expect_result, expect_path, maxlen)
#define PATH_FRAME_GET(input_path, expect_frame, expect_numdigits, expect_pathisvalid)
#define PATH_FRAME_CHECK_CHARS(input_path, expect_hasChars)
#define PARENT_DIR(input, output_expect)
#define PATH_SUFFIX(path_literal, path_literal_max, sep, suffix, expect_result, expect_path)
#define PATH_REL(abs_path, ref_path, rel_path_expect)
#define PARENT_DIR_END(input, offset_expect)
#define PATH_EXTENSION_ENSURE(input_path, input_ext, expect_result, expect_path)
#define STRNCPY_RLEN(dst, src)
#define SCOPED_TIMER(name)
Definition BLI_timeit.hh:64
#define str(s)
#define EXPECT_FALSE(result)
#define TEST(a, b)
#define EXPECT_NE(result, expect)
#define EXPECT_TRUE(result)
BMesh Iterators.
bool BLI_path_is_win32_drive_with_slash(const char *path)
bool BLI_path_is_win32_drive(const char *path)
char * STRNCPY(char(&dst)[N], const char *src)
int bool bool BLI_str_endswith(const char *__restrict str, const char *__restrict end) ATTR_NONNULL(1
void BLI_string_replace_char(char *str, char src, char dst) ATTR_NONNULL(1)
const char * BLI_path_extension(const char *filepath) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
bool BLI_path_frame(char *path, size_t path_maxncpy, int frame, int digits) ATTR_NONNULL(1)
bool BLI_path_relative_to(const char *path, const char *base_dir, bool walk_up, char *r_path_relative, size_t r_path_relative_maxncpy) ATTR_NONNULL(1
bool BLI_path_frame_range(char *path, size_t path_maxncpy, int sta, int end, int digits) ATTR_NONNULL(1)
TEST(array_store, Nop)
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
bool BLI_path_is_unc(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
int BLI_path_cmp_normalized(const char *p1, const char *p2) ATTR_NONNULL(1
bool BLI_path_is_abs_from_cwd(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
bool BLI_path_is_win32_drive_only(const char *path)
static char * str_replace_char_strdup(const char *str, char src, char dst)
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
bool BLI_path_is_rel(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
bool BLI_path_contains(const char *container_path, const char *containee_path) ATTR_NONNULL(1
void BLI_path_split_dir_file(const char *filepath, char *dir, size_t dir_maxncpy, char *file, size_t file_maxncpy) ATTR_NONNULL(1
bool BLI_path_has_hidden_component(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
const char * BLI_path_slash_find(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
static void str_replace_char_with_relative_exception(char *str, char src, char dst)
const char * BLI_path_slash_rfind(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
#define SEP_STR
Definition unit.cc:41