Differential D1679 Diff 5622 tests/gtests/blenlib/BLI_path_util_test.cc

Changeset View

Standalone View

tests/gtests/blenlib/BLI_path_util_test.cc

Context not available.
	EXPECT_STREQ("", file);	EXPECT_STREQ("", file);
	}	}
	}	}

		/* BLI_split_name_num */

		TEST(path_util, PathUtilSplitNameNumSimple)
		{
		const char *name = "/any/path/file567";
		char true_name[16], delimiter='e';
		int number, len;

		len = BLI_split_name_num(true_name, &number, name, delimiter);

		EXPECT_EQ(len, 13);
		EXPECT_EQ(number, 567);
		EXPECT_STREQ(true_name, "/any/path/fil");
		}

		TEST(path_util, PathUtilSplitNameNumWithoutDelimiter)
		{
		const char *name = "/any/path/file567";
		char true_name[16], delimiter='.';
		int number, len;

		len = BLI_split_name_num(true_name, &number, name, delimiter);

		EXPECT_EQ(len, 17);
		EXPECT_EQ(number, 0);
		EXPECT_STREQ(true_name, "/any/path/file567");
		}

		TEST(path_util, PathUtilSplitNameNumWithoutDelimiterAndNumber)
		{
		const char *name = "/any/path/file";
		char true_name[16], delimiter='.';
		int number, len;

		len = BLI_split_name_num(true_name, &number, name, delimiter);

		EXPECT_EQ(len, 14);
		EXPECT_EQ(number, 0);
		EXPECT_STREQ(true_name, name);
		}

		TEST(path_util, PathUtilSplitNameNumNumberWithDelimiter)
		{
		const char *name = "e567";
		char true_name[16], delimiter='e';
		int number, len;

		len = BLI_split_name_num(true_name, &number, name, delimiter);

		EXPECT_EQ(len, 0);
		EXPECT_EQ(number, 567);
		EXPECT_STREQ(true_name, "");
		}

		TEST(path_util, PathUtilSplitNameNumNumberWithoutDelimiter)
		{
		const char *name = "567";
		char true_name[16], delimiter='e';
		int number, len;

		len = BLI_split_name_num(true_name, &number, name, delimiter);

		EXPECT_EQ(len, 3);
		EXPECT_EQ(number, 0);
		EXPECT_STREQ(true_name, "567");
		}

		TEST(path_util, PathUtilSplitNameNumCoveredNumber)
		{
		const char *name = "e567a";
		char true_name[16], delimiter='e';
		int number, len;

		len = BLI_split_name_num(true_name, &number, name, delimiter);

		EXPECT_EQ(len, 5);
		EXPECT_EQ(number, 0);
		EXPECT_STREQ(true_name, "e567a");
		}

		TEST(path_util, PathUtilSplitNameNumMultipleNumbers)
		{
		const char *name = "/any/path/4564.567aa543";
		char true_name[16], delimiter='.';
		int number, len;

		len = BLI_split_name_num(true_name, &number, name, delimiter);

		EXPECT_EQ(len, 23);
		EXPECT_EQ(number, 0);
		EXPECT_STREQ(true_name, "/any/path/4564.567aa543");
		}

		TEST(path_util, PathUtilSplitNameNumMultipleNumbersAndDelimiters)
		{
		const char *name = "/any/path/4564.567aa.543";
		char true_name[16], delimiter='.';
		int number, len;

		len = BLI_split_name_num(true_name, &number, name, delimiter);

		EXPECT_EQ(len, 20);
		EXPECT_EQ(number, 543);
		EXPECT_STREQ(true_name, "/any/path/4564.567aa");
		}


		/* BLI_make_file_string */

		TEST(path_util, PathUtilMakeFileStringAbsolutePath)
		{
		const char *name = "filename";
		const char *dir = "mydir/subdir";
		const char *relabase = "/any/path/file";

		char result_string[30];

		BLI_make_file_string(relabase, result_string, dir, name);

		EXPECT_STREQ(result_string, "mydir/subdir/filename");
		}

		TEST(path_util, PathUtilMakeFileStringAbsolutePathWithSlash)
		{
		const char *name = "filename";
		const char *dir = "mydir/subdir/";
		const char *relabase = "/any/path/file";

		char result_string[30];

		BLI_make_file_string(relabase, result_string, dir, name);

		EXPECT_STREQ(result_string, "mydir/subdir/filename");
		}

		TEST(path_util, PathUtilMakeFileStringRelativePath)
		{
		const char *name = "filename";
		const char *dir = "//mydir/subdir";
		const char *relabase = "/any/path/";

		char result_string[40];

		BLI_make_file_string(relabase, result_string, dir, name);

		EXPECT_STREQ(result_string, "/any/path/mydir/subdir/filename");
		}

		TEST(path_util, PathUtilMakeFileStringRelativePathAndBaseWithAnotherFile)
		{
		const char *name = "filename";
		const char *dir = "//mydir/subdir";
		const char *relabase = "/any/path/another_file";

		char result_string[40];

		BLI_make_file_string(relabase, result_string, dir, name);

		EXPECT_STREQ(result_string, "/any/path/mydir/subdir/filename");
		}

		TEST(path_util, PathUtilMakeFileStringEmptyFile)
		{
		const char *name = "";
		const char *dir = "//mydir/subdir";
		const char *relabase = "/any/path/another_file";

		char result_string[40];

		BLI_make_file_string(relabase, result_string, dir, name);

		EXPECT_STREQ(result_string, "/any/path/mydir/subdir/");
		}

		TEST(path_util, PathUtilMakeFileStringEmptyPath)
		{
		const char *name = "filename";
		const char *dir = "";
		const char *relabase = "/any/path/another_file";

		char result_string[40];

		BLI_make_file_string(relabase, result_string, dir, name);

		EXPECT_STREQ(result_string, "/filename");
		}

		TEST(path_util, PathUtilMakeFileStringEmptyRelativePath)
		{
		const char *name = "filename";
		const char *dir = "//";
		const char *relabase = "/any/path/another_file";

		char result_string[40];

		BLI_make_file_string(relabase, result_string, dir, name);

		EXPECT_STREQ(result_string, "/any/path/filename");
		}


		/* BLI_path_sufix */

		TEST(path_util, PathUtilPathSufixSimple)
		{
		char name[20] = "filename";

		const char *separator = "_____";
		const char *suffix = "SUFFIX";
		const int maxlen = 20;

		bool res = BLI_path_suffix(name, maxlen, suffix, separator);

		EXPECT_TRUE(res);
		EXPECT_STREQ(name, "filename_____SUFFIX");
		}

		TEST(path_util, PathUtilPathSufixNotEnoughSpace)
		{
		char name[20] = "filename";

		const char *separator = "_____";
		const char *suffix = "SUFFIX1";
		const int maxlen = 20;

		bool res = BLI_path_suffix(name, maxlen, suffix, separator);

		EXPECT_FALSE(res);
		}


		/* BLI_path_frame_range */

		TEST(path_util, PathUtilPathFrameRangeWithoutHashes)
		{
		char name[20] = "filename__";

		const int digits = 3, start = 21, end = 40;

		bool res = BLI_path_frame_range(name, start, end, digits);

		EXPECT_TRUE(res);
		EXPECT_STREQ(name, "filename__021-040");
		}

		TEST(path_util, PathUtilPathFrameRangeTooFewHashes)
		{
		char name[16] = "filename__#.txt";

		const int digits = 3, start = 21, end = 40;

		bool res = BLI_path_frame_range(name, start, end, digits);

		EXPECT_TRUE(res);
		EXPECT_STREQ(name, "filename__21-40.txt");
		}

		TEST(path_util, PathUtilPathFrameRangeEnoughHashes)
		{
		char name[50] = "filename_###_.txt";

		const int digits = 3, start = 21, end = 40;

		bool res = BLI_path_frame_range(name, start, end, digits);

		EXPECT_TRUE(res);
		EXPECT_STREQ(name, "filename_021-040_.txt");
		}


		/* BLI_string_dec */

		TEST(path_util, PathUtilStringDecWithoutNumber)
		{
		const char * name = "/any/path/filename";

		char head[20], tail[20];
		short unsigned numlen;

		int res = BLI_stringdec(name, head, tail, &numlen);

		EXPECT_EQ(0, res);
		EXPECT_EQ(0, numlen);
		EXPECT_STREQ(head, name);
		EXPECT_STREQ(tail, "");
		}

		TEST(path_util, PathUtilStringDecWithoutNumberExt)
		{
		const char * name = "/any/path/filename.ext";

		char head[30], tail[20];
		short unsigned numlen;

		int res = BLI_stringdec(name, head, tail, &numlen);

		EXPECT_EQ(0, res);
		EXPECT_EQ(0, numlen);
		EXPECT_STREQ(head, "/any/path/filename");
		EXPECT_STREQ(tail, ".ext");
		}

		TEST(path_util, PathUtilStringDecWithNumber)
		{
		const char * name = "/any/path/filename72";

		char head[30], tail[20];
		short unsigned numlen;

		int res = BLI_stringdec(name, head, tail, &numlen);

		EXPECT_EQ(72, res);
		EXPECT_EQ(2, numlen);
		EXPECT_STREQ(head, "/any/path/filename");
		EXPECT_STREQ(tail, "");
		}

		TEST(path_util, PathUtilStringDecWithNumberExt)
		{
		const char * name = "/any/path/filename72.ext64";

		char head[30], tail[20];
		short unsigned numlen;

		int res = BLI_stringdec(name, head, tail, &numlen);

		EXPECT_EQ(res,72);
		EXPECT_EQ(numlen,2);
		EXPECT_STREQ(head, "/any/path/filename");
		EXPECT_STREQ(tail, ".ext64");
		}

		TEST(path_util, PathUtilStringDecNumberInTheMiddle)
		{
		const char * name = "/any/path/file0072name.ext";

		char head[30], tail[20];
		short unsigned numlen;

		int res = BLI_stringdec(name, head, tail, &numlen);

		EXPECT_EQ(res,72);
		EXPECT_EQ(numlen,4);
		EXPECT_STREQ(head, "/any/path/file");
		EXPECT_STREQ(tail, "name.ext");
		}

		TEST(path_util, PathUtilStringDecTwoNumbers)
		{
		const char * name = "/any/path/file53name012.ext";

		char head[30], tail[20];
		short unsigned numlen;

		int res = BLI_stringdec(name, head, tail, &numlen);

		EXPECT_EQ(res,12);
		EXPECT_EQ(numlen,3);
		EXPECT_STREQ(head, "/any/path/file53name");
		EXPECT_STREQ(tail, ".ext");
		}

		TEST(path_util, PathUtilStringDecNumberInExt)
		{
		const char * name = "/any/path32/filename.ext64";

		char head[30], tail[20];
		short unsigned numlen;

		int res = BLI_stringdec(name, head, tail, &numlen);

		EXPECT_EQ(res,0);
		EXPECT_EQ(numlen,0);
		EXPECT_STREQ(head, "/any/path32/filename");
		EXPECT_STREQ(tail, ".ext64");
		}


		/* BLI_string_enc */

		TEST(path_util, PathUtilStringEncTight)
		{
		char result[30];

		const char * head = "/any/path/file";
		const char * tail = ".ext";

		short unsigned numlen = 1;
		int num = 52;

		BLI_stringenc(result, head, tail, numlen, num);

		EXPECT_STREQ(result, "/any/path/file52.ext");
		}

		TEST(path_util, PathUtilStringEncLoose)
		{
		char result[30];

		const char * head = "/any/path/file";
		const char * tail = ".ext";

		short unsigned numlen = 5;
		int num = 52;

		BLI_stringenc(result, head, tail, numlen, num);

		EXPECT_STREQ(result, "/any/path/file00052.ext");
		}


		/* BLI_string_dec then BLI_string_enc */

		TEST(path_util, PathUtilStringDecThenEncSimple)
		{
		const char * name = "/any/path/file53name012.ext";

		char head[30], tail[20], result[30];
		short unsigned numlen;

		int num = BLI_stringdec(name, head, tail, &numlen);
		BLI_stringenc(result, head, tail, numlen, num);

		EXPECT_STREQ("/any/path/file53name012.ext", result);
		}

		TEST(path_util, PathUtilStringDecThenEncNumberInExt)
		{
		const char * name = "/any/path64/filename.ext64";

		char head[30], tail[20], result[30];
		short unsigned numlen;

		int num = BLI_stringdec(name, head, tail, &numlen);
		BLI_stringenc(result, head, tail, numlen, num);

		EXPECT_STREQ(result, "/any/path64/filename.ext64");
		}


		/* BLI_string_enc then BLI_string_dec */

		TEST(path_util, PathUtilStringEncThenDecSimple)
		{
		char result[30];

		char head[15] = "/any/path/file";
		char tail[5] = ".ext";

		short unsigned numlen = 1;
		int num = 52;

		BLI_stringenc(result, head, tail, numlen, num);
		int res = BLI_stringdec(result, head, tail, &numlen);

		EXPECT_EQ(52, res);
		EXPECT_EQ(2, numlen);
		EXPECT_STREQ(head, "/any/path/file");
		EXPECT_STREQ(tail, ".ext");
		}

		TEST(path_util, PathUtilStringEncThenDecAdditionalNumbers)
		{
		char result[30];

		char head[17] = "/any/path32/file";
		char tail[7] = ".ext64";

		short unsigned numlen = 5;
		int num = 52;

		BLI_stringenc(result, head, tail, numlen, num);
		int res = BLI_stringdec(result, head, tail, &numlen);

		EXPECT_EQ(52, res);
		EXPECT_EQ(5, numlen);
		EXPECT_STREQ(head, "/any/path32/file");
		EXPECT_STREQ(tail, ".ext64");
		}


		/* BLI_path_abs */

		TEST(path_util, PathUtilPathAbsSimple)
		{
		char path[30] = "//any/path/file";
		const char * base = "/some/base/path/";

		int res = BLI_path_abs(path, base);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "/some/base/path/any/path/file");
		}

		TEST(path_util, PathUtilPathAbsStrangeSlashes)
		{
		char path[30] = "//any/path\\file";
		const char * base = "/some/base\\path/file";

		int res = BLI_path_abs(path, base);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "/some/base/path/any/path/file");
		}

		TEST(path_util, PathUtilPathAbsStrangeSlashesAbsolute)
		{
		char path[30] = "/any/path\\file";
		const char * base = "/some/base\\path/file";

		int res = BLI_path_abs(path, base);

		EXPECT_FALSE(res);
		EXPECT_STREQ(path, "/any/path/file");
		}


		/* BLI_path_rel */

		TEST(path_util, PathUtilPathRelSimple)
		{
		char path[30] = "//any/path/file";
		const char * base = "/some/base/path/";

		BLI_path_rel(path, base);

		EXPECT_STREQ(path, "//any/path/file");
		}

		TEST(path_util, PathUtilPathRelAbsolute)
		{
		char path[30] = "/any/path/file";
		const char * base = "/some/base/path/";

		BLI_path_rel(path, base);

		EXPECT_STREQ(path, "//../../../any/path/file");
		}

		TEST(path_util, PathUtilPathRelAbsoluteBackslashes)
		{
		char path[30] = "/any/path\\file";
		const char * base = "/some\\/base/path/file";

		BLI_path_rel(path, base);

		EXPECT_STREQ(path, "//../../../any/path/file");
		}

		TEST(path_util, PathUtilPathRelAbsoluteCommonDir)
		{
		char path[30] = "/any/path\\file";
		const char * base = "/any/some\\/path/file";

		BLI_path_rel(path, base);

		EXPECT_STREQ(path, "//../../path/file");
		}


		/* BLI_join_dirfileJoinDirFile */

		TEST(path_util, PathUtilJoinDirFileWithSlash)
		{
		const char * file = "filename.ext";
		const char * dir = "/any/path/";

		char result[30];
		const int maxlen = 6;

		BLI_join_dirfile(result, maxlen, dir, file);

		EXPECT_STREQ(result, "/any/");
		}

		TEST(path_util, PathUtilJoinDirFileWithoutSlash)
		{
		const char * file = "filename.ext";
		const char * dir = "/any/path/no_slash";

		char result[40];
		const int maxlen = 40;

		BLI_join_dirfile(result, maxlen, dir, file);

		EXPECT_STREQ(result, "/any/path/no_slash/filename.ext");
		}


		/* BLI_replace_extension */

		TEST(path_util, PathUtilReplaceExtensionSimple)
		{
		char path[26] = "/any/path/filename.ext";
		const char * ext = ".abcdef";

		const int maxlen = 26;

		bool res = BLI_replace_extension(path, maxlen, ext);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "/any/path/filename.abcdef");
		}

		TEST(path_util, PathUtilReplaceExtensionNotEnoughSpace)
		{
		char path[26] = "/any/path/filename.ext";
		const char * ext = ".abcdef";

		const int maxlen = 25;

		bool res = BLI_replace_extension(path, maxlen, ext);

		EXPECT_FALSE(res);
		EXPECT_STREQ(path, "/any/path/filename.ext");
		}

		TEST(path_util, PathUtilReplaceExtensionShorterExtension)
		{
		char path[26] = "/any/path/filename.ext";
		const char * ext = ".a";

		const int maxlen = 26;

		bool res = BLI_replace_extension(path, maxlen, ext);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "/any/path/filename.a");
		}


		/* BLI_ensure_extension */

		TEST(path_util, PathUtilEnsureExtensionObvious)
		{
		char path[25] = "/any/path/filename.ext";
		const char * ext = ".ext";

		const int maxlen = 25;

		bool res = BLI_ensure_extension(path, maxlen, ext);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "/any/path/filename.ext");
		}

		TEST(path_util, PathUtilEnsureExtensionSimple)
		{
		char path[25] = "/any/path/filename";
		const char * ext = ".ext";

		const int maxlen = 25;

		bool res = BLI_ensure_extension(path, maxlen, ext);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "/any/path/filename.ext");
		}

		TEST(path_util, PathUtilEnsureExtensionNotEnoghSpace)
		{
		char path[25] = "/any/path/filename";
		const char * ext = ".ext";

		const int maxlen = 22;

		bool res = BLI_ensure_extension(path, maxlen, ext);

		EXPECT_FALSE(res);
		EXPECT_STREQ(path, "/any/path/filename");
		}

		TEST(path_util, PathUtilEnsureExtensionAdditionalDots)
		{
		char path[25] = "/any/path/filename....";
		const char * ext = ".ext";

		const int maxlen = 25;

		bool res = BLI_ensure_extension(path, maxlen, ext);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "/any/path/filename.ext");
		}


		/* BLI_ensure_filename */

		TEST(path_util, PathUtilEnsureFilenameObvious)
		{
		char path[30] = "/any/path/filename.ext";
		const char * filename = "filename.ext";

		const int maxlen = 30;

		bool res = BLI_ensure_filename(path, maxlen, filename);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "/any/path/filename.ext");
		}

		TEST(path_util, PathUtilEnsureFilenameSimple)
		{
		char path[30] = "/any/path/random_name.txt";
		const char * filename = "filename.ext";

		const int maxlen = 30;

		bool res = BLI_ensure_filename(path, maxlen, filename);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "/any/path/filename.ext");
		}

		TEST(path_util, PathUtilEnsureFilenameLonger)
		{
		char path[27] = "/any/path/short.a";
		const char * filename = "quite_longer.ext";

		const int maxlen = 27;

		bool res = BLI_ensure_filename(path, maxlen, filename);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "/any/path/quite_longer.ext");
		}

		TEST(path_util, PathUtilEnsureFilenameTooLong)
		{
		char path[25] = "/any/path/short.a";
		const char * filename = "quite_longer.ext";

		const int maxlen = 25;

		bool res = BLI_ensure_filename(path, maxlen, filename);

		EXPECT_FALSE(res);
		EXPECT_STREQ(path, "/any/path/short.a");
		}

		TEST(path_util, PathUtilEnsureFilenameWithoutDirs)
		{
		char path[25] = "no_dirs";
		const char * filename = "just_replace.txt";

		const int maxlen = 25;

		bool res = BLI_ensure_filename(path, maxlen, filename);

		EXPECT_TRUE(res);
		EXPECT_STREQ(path, "just_replace.txt");
		}
Context not available.