edg-l/ddnet
1
0
Fork 0
mirror of https://github.com/ddnet/ddnet.git synced 2024-10-21 08:18:18 +00:00
Code Issues Packages Projects Releases Wiki Activity
ddnet/src/test/str.cpp

319 lines
9.8 KiB
C++
Raw Normal View History

Add possibility to ban players by name This uses the Unicode confusable data together with judging how close two strings are by using the Levenshtein distance. Adds the commands `name_ban`, `name_unban` and `name_bans`. Kicks players who join using a banned name and doesn't allow ingame players to change their names to the banned ones.
2018-03-06 17:41:18 +00:00
#include <gtest/gtest.h>
#include <base/system.h>
TEST(Str, Dist)
{
EXPECT_EQ(str_utf8_dist("aaa", "aaa"), 0);
EXPECT_EQ(str_utf8_dist("123", "123"), 0);
EXPECT_EQ(str_utf8_dist("", ""), 0);
EXPECT_EQ(str_utf8_dist("a", "b"), 1);
EXPECT_EQ(str_utf8_dist("", "aaa"), 3);
EXPECT_EQ(str_utf8_dist("123", ""), 3);
EXPECT_EQ(str_utf8_dist("ä", ""), 1);
EXPECT_EQ(str_utf8_dist("Hëllö", "Hello"), 2);
// https://en.wikipedia.org/w/index.php?title=Levenshtein_distance&oldid=828480025#Example
EXPECT_EQ(str_utf8_dist("kitten", "sitting"), 3);
EXPECT_EQ(str_utf8_dist("flaw", "lawn"), 2);
EXPECT_EQ(str_utf8_dist("saturday", "sunday"), 3);
}
Fix some system.c insanity `str_utf8_isspace` now returns true if the passed code point renders as a space, instead of when not. Add `str_utf8_trim_right`, use this function and `str_utf8_skip_whitespaces` in the server. Add tests for the three functions
2018-03-14 01:27:15 +00:00
TEST(Str, Utf8Isspace)
{
Add string and nameban tests with Unicode characters
2018-03-14 02:04:41 +00:00
EXPECT_TRUE(str_utf8_isspace(0x200b)); // Zero-width space
Fix some system.c insanity `str_utf8_isspace` now returns true if the passed code point renders as a space, instead of when not. Add `str_utf8_trim_right`, use this function and `str_utf8_skip_whitespaces` in the server. Add tests for the three functions
2018-03-14 01:27:15 +00:00
EXPECT_TRUE(str_utf8_isspace(' '));
EXPECT_FALSE(str_utf8_isspace('a'));
Add string and nameban tests with Unicode characters
2018-03-14 02:04:41 +00:00
// Control characters.
for(char c = 0; c < 0x20; c++)
{
EXPECT_TRUE(str_utf8_isspace(c));
}
Fix some system.c insanity `str_utf8_isspace` now returns true if the passed code point renders as a space, instead of when not. Add `str_utf8_trim_right`, use this function and `str_utf8_skip_whitespaces` in the server. Add tests for the three functions
2018-03-14 01:27:15 +00:00
}
TEST(Str, Utf8SkipWhitespaces)
{
EXPECT_STREQ(str_utf8_skip_whitespaces("abc"), "abc");
EXPECT_STREQ(str_utf8_skip_whitespaces("abc "), "abc ");
EXPECT_STREQ(str_utf8_skip_whitespaces(" abc"), "abc");
Add string and nameban tests with Unicode characters
2018-03-14 02:04:41 +00:00
EXPECT_STREQ(str_utf8_skip_whitespaces("\xe2\x80\x8b abc"), "abc");
Fix some system.c insanity `str_utf8_isspace` now returns true if the passed code point renders as a space, instead of when not. Add `str_utf8_trim_right`, use this function and `str_utf8_skip_whitespaces` in the server. Add tests for the three functions
2018-03-14 01:27:15 +00:00
}
TEST(Str, Utf8TrimRight)
{
Run clang-format Purely automatic change. In case of conflict with this change, apply the other change and rerun the formatting to restore it: $ python scripts/fix_style.py
2020-09-26 19:41:58 +00:00
char A1[] = "abc";
str_utf8_trim_right(A1);
EXPECT_STREQ(A1, "abc");
char A2[] = " abc";
str_utf8_trim_right(A2);
EXPECT_STREQ(A2, " abc");
char A3[] = "abc ";
str_utf8_trim_right(A3);
EXPECT_STREQ(A3, "abc");
char A4[] = "abc \xe2\x80\x8b";
str_utf8_trim_right(A4);
EXPECT_STREQ(A4, "abc");
Fix some system.c insanity `str_utf8_isspace` now returns true if the passed code point renders as a space, instead of when not. Add `str_utf8_trim_right`, use this function and `str_utf8_skip_whitespaces` in the server. Add tests for the three functions
2018-03-14 01:27:15 +00:00
}
Add `LATIN SMALL LETTER L` confusable This makes `LATIN SMALL LETTER L` confusable with `LATIN SMALL LETTER I` because `CYRILLIC SMALL LETTER PALOCHKA` "ӏ" (mapping to i) wasn't confusable with `LATIN SMALL LETTER L` "l" (mapping to l) before. Also add tests for `str_utf8_comp_confusable`.
2018-03-20 20:11:44 +00:00
TEST(Str, Utf8CompConfusables)
{
EXPECT_TRUE(str_utf8_comp_confusable("abc", "abc") == 0);
EXPECT_TRUE(str_utf8_comp_confusable("rn", "m") == 0);
EXPECT_TRUE(str_utf8_comp_confusable("l", "ӏ") == 0); // CYRILLIC SMALL LETTER PALOCHKA
Mark the inverted exclamation mark as confusable with i They look pretty much the same in our font, but for some reason, the inverted exclamation mark doesn't have confusables.
2021-07-27 00:43:04 +00:00
EXPECT_TRUE(str_utf8_comp_confusable("i", "¡") == 0); // INVERTED EXCLAMATION MARK
Add `LATIN SMALL LETTER L` confusable This makes `LATIN SMALL LETTER L` confusable with `LATIN SMALL LETTER I` because `CYRILLIC SMALL LETTER PALOCHKA` "ӏ" (mapping to i) wasn't confusable with `LATIN SMALL LETTER L` "l" (mapping to l) before. Also add tests for `str_utf8_comp_confusable`.
2018-03-20 20:11:44 +00:00
EXPECT_FALSE(str_utf8_comp_confusable("o", "x") == 0);
EXPECT_TRUE(str_utf8_comp_confusable("aceiou", "ąçęįǫų") == 0);
}
Add `str_startswith` and `str_endswith` Also add a couple of tests for both.
2018-07-25 08:23:07 +00:00
UTF8 nocase compare & use for chat TAB completion - As suggested by Arseniy Zarche - Also updated confusables to Unicode 12
2019-01-07 22:49:20 +00:00
TEST(Str, Utf8ToLower)
{
EXPECT_TRUE(str_utf8_tolower('A') == 'a');
EXPECT_TRUE(str_utf8_tolower('z') == 'z');
EXPECT_TRUE(str_utf8_tolower(192) == 224); // À -> à
EXPECT_TRUE(str_utf8_tolower(7882) == 7883); // Ị -> ị
EXPECT_TRUE(str_utf8_comp_nocase("ÖlÜ", "ölü") == 0);
EXPECT_TRUE(str_utf8_comp_nocase("ÜlÖ", "ölü") > 0); // ü > ö
EXPECT_TRUE(str_utf8_comp_nocase("ÖlÜ", "ölüa") < 0); // NULL < a
EXPECT_TRUE(str_utf8_comp_nocase("ölüa", "ÖlÜ") > 0); // a < NULL
Run clang-format Purely automatic change. In case of conflict with this change, apply the other change and rerun the formatting to restore it: $ python scripts/fix_style.py
2020-09-26 19:41:58 +00:00
#if(CHAR_MIN < 0)
Fix negative numbers in char On some architectures char can be unsigned, which makes g++ very unhappy. error: narrowing conversion of '-128' from 'int' to 'char' inside { }
2019-04-02 15:19:20 +00:00
const char a[2] = {CHAR_MIN, 0};
UTF8 nocase compare & use for chat TAB completion - As suggested by Arseniy Zarche - Also updated confusables to Unicode 12
2019-01-07 22:49:20 +00:00
const char b[2] = {0, 0};
EXPECT_TRUE(str_utf8_comp_nocase(a, b) > 0);
EXPECT_TRUE(str_utf8_comp_nocase(b, a) < 0);
Fix negative numbers in char On some architectures char can be unsigned, which makes g++ very unhappy. error: narrowing conversion of '-128' from 'int' to 'char' inside { }
2019-04-02 15:19:20 +00:00
#endif
UTF8 nocase compare & use for chat TAB completion - As suggested by Arseniy Zarche - Also updated confusables to Unicode 12
2019-01-07 22:49:20 +00:00
Fix tests
2019-02-10 18:13:55 +00:00
EXPECT_TRUE(str_utf8_comp_nocase_num("ÖlÜ", "ölüa", 5) == 0);
EXPECT_TRUE(str_utf8_comp_nocase_num("ÖlÜ", "ölüa", 6) != 0);
UTF8 nocase compare & use for chat TAB completion - As suggested by Arseniy Zarche - Also updated confusables to Unicode 12
2019-01-07 22:49:20 +00:00
EXPECT_TRUE(str_utf8_comp_nocase_num("a", "z", 0) == 0);
EXPECT_TRUE(str_utf8_comp_nocase_num("a", "z", 1) != 0);
const char str[] = "ÄÖÜ";
EXPECT_TRUE(str_utf8_find_nocase(str, "ä") == str);
Run clang-format Purely automatic change. In case of conflict with this change, apply the other change and rerun the formatting to restore it: $ python scripts/fix_style.py
2020-09-26 19:41:58 +00:00
EXPECT_TRUE(str_utf8_find_nocase(str, "ö") == str + 2);
EXPECT_TRUE(str_utf8_find_nocase(str, "ü") == str + 4);
UTF8 nocase compare & use for chat TAB completion - As suggested by Arseniy Zarche - Also updated confusables to Unicode 12
2019-01-07 22:49:20 +00:00
EXPECT_TRUE(str_utf8_find_nocase(str, "z") == NULL);
}
Add `str_startswith` and `str_endswith` Also add a couple of tests for both.
2018-07-25 08:23:07 +00:00
TEST(Str, Startswith)
{
EXPECT_TRUE(str_startswith("abcdef", "abc"));
EXPECT_FALSE(str_startswith("abc", "abcdef"));
EXPECT_TRUE(str_startswith("xyz", ""));
EXPECT_FALSE(str_startswith("", "xyz"));
EXPECT_FALSE(str_startswith("house", "home"));
EXPECT_FALSE(str_startswith("blackboard", "board"));
EXPECT_TRUE(str_startswith("поплавать", "по"));
EXPECT_FALSE(str_startswith("плавать", "по"));
Return a pointer from `str_endswith` as well
2018-07-26 12:04:44 +00:00
static const char ABCDEFG[] = "abcdefg";
Add `str_startswith` and `str_endswith` Also add a couple of tests for both.
2018-07-25 08:23:07 +00:00
static const char ABC[] = "abc";
Return a pointer from `str_endswith` as well
2018-07-26 12:04:44 +00:00
EXPECT_EQ(str_startswith(ABCDEFG, ABC) - ABCDEFG, str_length(ABC));
Add `str_startswith` and `str_endswith` Also add a couple of tests for both.
2018-07-25 08:23:07 +00:00
}
TEST(Str, Endswith)
{
EXPECT_TRUE(str_endswith("abcdef", "def"));
EXPECT_FALSE(str_endswith("def", "abcdef"));
EXPECT_TRUE(str_endswith("xyz", ""));
EXPECT_FALSE(str_endswith("", "xyz"));
EXPECT_FALSE(str_endswith("rhyme", "mine"));
EXPECT_FALSE(str_endswith("blackboard", "black"));
EXPECT_TRUE(str_endswith("люди", "юди"));
EXPECT_FALSE(str_endswith("люди", "любовь"));
Return a pointer from `str_endswith` as well
2018-07-26 12:04:44 +00:00
static const char ABCDEFG[] = "abcdefg";
static const char DEFG[] = "defg";
EXPECT_EQ(str_endswith(ABCDEFG, DEFG) - ABCDEFG,
str_length(ABCDEFG) - str_length(DEFG));
Add `str_startswith` and `str_endswith` Also add a couple of tests for both.
2018-07-25 08:23:07 +00:00
}
Also use sha256 for the mapbugs stuff
2018-08-19 10:12:11 +00:00
TEST(Str, HexDecode)
{
char aOut[5] = {'a', 'b', 'c', 'd', 0};
Run clang-format Purely automatic change. In case of conflict with this change, apply the other change and rerun the formatting to restore it: $ python scripts/fix_style.py
2020-09-26 19:41:58 +00:00
EXPECT_EQ(str_hex_decode(aOut, 0, ""), 0);
EXPECT_STREQ(aOut, "abcd");
EXPECT_EQ(str_hex_decode(aOut, 0, " "), 2);
EXPECT_STREQ(aOut, "abcd");
EXPECT_EQ(str_hex_decode(aOut, 1, "1"), 2);
EXPECT_STREQ(aOut + 1, "bcd");
EXPECT_EQ(str_hex_decode(aOut, 1, "41"), 0);
EXPECT_STREQ(aOut, "Abcd");
EXPECT_EQ(str_hex_decode(aOut, 1, "4x"), 1);
EXPECT_STREQ(aOut + 1, "bcd");
EXPECT_EQ(str_hex_decode(aOut, 1, "x1"), 1);
EXPECT_STREQ(aOut + 1, "bcd");
EXPECT_EQ(str_hex_decode(aOut, 1, "411"), 2);
EXPECT_STREQ(aOut + 1, "bcd");
EXPECT_EQ(str_hex_decode(aOut, 4, "41424344"), 0);
EXPECT_STREQ(aOut, "ABCD");
Also use sha256 for the mapbugs stuff
2018-08-19 10:12:11 +00:00
}
Add str_tokenize and str_in_list
2019-02-06 12:30:47 +00:00
Don't use strtok. Close #1468
2019-03-05 09:46:29 +00:00
TEST(Str, Tokenize)
{
char aTest[] = "GER,RUS,ZAF,BRA,CAN";
const char *aOut[] = {"GER", "RUS", "ZAF", "BRA", "CAN"};
char aBuf[4];
int n = 0;
Style
2019-03-11 11:54:31 +00:00
for(const char *tok = aTest; (tok = str_next_token(tok, ",", aBuf, sizeof(aBuf)));)
Don't use strtok. Close #1468
2019-03-05 09:46:29 +00:00
EXPECT_STREQ(aOut[n++], aBuf);
char aTest2[] = "";
Style
2019-03-11 11:54:31 +00:00
EXPECT_EQ(str_next_token(aTest2, ",", aBuf, sizeof(aBuf)), nullptr);
Work on compound binds
2019-04-28 13:32:14 +00:00
char aTest3[] = "+b";
str_next_token(aTest3, "+", aBuf, sizeof(aBuf));
EXPECT_STREQ(aBuf, "b");
Don't use strtok. Close #1468
2019-03-05 09:46:29 +00:00
}
Add str_tokenize and str_in_list
2019-02-06 12:30:47 +00:00
TEST(Str, InList)
{
char aTest[] = "GER,RUS,ZAF,BRA,CAN";
EXPECT_TRUE(str_in_list(aTest, ",", "GER"));
EXPECT_TRUE(str_in_list(aTest, ",", "RUS"));
EXPECT_TRUE(str_in_list(aTest, ",", "ZAF"));
EXPECT_TRUE(str_in_list(aTest, ",", "BRA"));
EXPECT_TRUE(str_in_list(aTest, ",", "CAN"));
EXPECT_FALSE(str_in_list(aTest, ",", "CHN"));
EXPECT_FALSE(str_in_list(aTest, ",", "R,R"));
Add a couple tests, fix #1457
2019-02-13 14:11:09 +00:00
EXPECT_FALSE(str_in_list("abc,xyz", ",", "abcdef"));
EXPECT_FALSE(str_in_list("", ",", ""));
EXPECT_FALSE(str_in_list("", ",", "xyz"));
Render news without STL functions (fixes #1693)
2019-04-29 20:55:12 +00:00
EXPECT_TRUE(str_in_list("FOO,,BAR", ",", ""));
Prevent NULL pointer in mem_copy (fixes #2753)
2020-09-06 14:29:20 +00:00
EXPECT_TRUE(str_in_list("abc,,def", ",", "def"));
Add str_tokenize and str_in_list
2019-02-06 12:30:47 +00:00
}
str_format: always return length of written string Quoting the man page of vsnprintf: RETURN VALUE Upon successful return, these functions return the number of characters printed (excluding the null byte used to end output to strings). The functions snprintf() and vsnprintf() do not write more than size bytes (including the terminating null byte ('\0')). If the output was truncated due to this limit, then the return value is the number of characters (excluding the terminating null byte) which would have been written to the final string if enough space had been available. Thus, a return value of size or more means that the output was truncated. (See also below under NOTES.) If an output error is encountered, a negative value is returned. [...] The glibc implementation of the functions snprintf() and vsnprintf() conforms to the C99 standard, that is, behaves as described above, since glibc version 2.1. Until glibc 2.0.6, they would return -1 when the output was truncated.
2019-03-20 18:09:23 +00:00
TEST(Str, StrFormat)
{
char aBuf[4];
EXPECT_EQ(str_format(aBuf, 4, "%d:", 9), 2);
EXPECT_STREQ(aBuf, "9:");
EXPECT_EQ(str_format(aBuf, 4, "%d: ", 9), 3);
EXPECT_STREQ(aBuf, "9: ");
EXPECT_EQ(str_format(aBuf, 4, "%d: ", 99), 3);
EXPECT_STREQ(aBuf, "99:");
}
Names can include quotes :/
2019-04-16 00:24:24 +00:00
str_num_copy -> str_truncate, as in Vanilla 0.7
2019-04-16 06:10:02 +00:00
TEST(Str, StrCopyNum)
Names can include quotes :/
2019-04-16 00:24:24 +00:00
{
Fix utf8 handling in str_truncate (fixes #2533) and rename to str_utf8_truncate since it's only used for utf8 strings
2020-08-02 11:45:20 +00:00
const char *foo = "Foobaré";
Names can include quotes :/
2019-04-16 00:24:24 +00:00
char aBuf[64];
Fix utf8 handling in str_truncate (fixes #2533) and rename to str_utf8_truncate since it's only used for utf8 strings
2020-08-02 11:45:20 +00:00
str_utf8_truncate(aBuf, 3, foo, 1);
Names can include quotes :/
2019-04-16 00:24:24 +00:00
EXPECT_STREQ(aBuf, "F");
Fix utf8 handling in str_truncate (fixes #2533) and rename to str_utf8_truncate since it's only used for utf8 strings
2020-08-02 11:45:20 +00:00
str_utf8_truncate(aBuf, 3, foo, 2);
Names can include quotes :/
2019-04-16 00:24:24 +00:00
EXPECT_STREQ(aBuf, "Fo");
Fix utf8 handling in str_truncate (fixes #2533) and rename to str_utf8_truncate since it's only used for utf8 strings
2020-08-02 11:45:20 +00:00
str_utf8_truncate(aBuf, 3, foo, 3);
Names can include quotes :/
2019-04-16 00:24:24 +00:00
EXPECT_STREQ(aBuf, "Fo");
Fix utf8 handling in str_truncate (fixes #2533) and rename to str_utf8_truncate since it's only used for utf8 strings
2020-08-02 11:45:20 +00:00
str_utf8_truncate(aBuf, sizeof(aBuf), foo, 6);
Names can include quotes :/
2019-04-16 00:24:24 +00:00
EXPECT_STREQ(aBuf, "Foobar");
Fix utf8 handling in str_truncate (fixes #2533) and rename to str_utf8_truncate since it's only used for utf8 strings
2020-08-02 11:45:20 +00:00
str_utf8_truncate(aBuf, sizeof(aBuf), foo, 7);
EXPECT_STREQ(aBuf, "Foobaré");
Add str_utf8_truncate test for size 0
2021-01-22 18:17:56 +00:00
str_utf8_truncate(aBuf, sizeof(aBuf), foo, 0);
EXPECT_STREQ(aBuf, "");
Fix utf8 handling in str_truncate (fixes #2533) and rename to str_utf8_truncate since it's only used for utf8 strings
2020-08-02 11:45:20 +00:00
char aBuf2[8];
str_utf8_truncate(aBuf2, sizeof(aBuf2), foo, 7);
EXPECT_STREQ(aBuf2, "Foobar");
char aBuf3[9];
str_utf8_truncate(aBuf3, sizeof(aBuf3), foo, 7);
EXPECT_STREQ(aBuf3, "Foobaré");
Names can include quotes :/
2019-04-16 00:24:24 +00:00
}
Add test cases
2020-09-06 22:57:21 +00:00
TEST(Str, StrCopyUtf8)
{
const char *foo = "DDNet最好了";
char aBuf[64];
str_utf8_copy(aBuf, foo, 7);
EXPECT_STREQ(aBuf, "DDNet");
str_utf8_copy(aBuf, foo, 8);
EXPECT_STREQ(aBuf, "DDNet");
str_utf8_copy(aBuf, foo, 9);
I can't count
2020-09-06 23:03:40 +00:00
EXPECT_STREQ(aBuf, "DDNet最");
Add test cases
2020-09-06 22:57:21 +00:00
str_utf8_copy(aBuf, foo, 10);
EXPECT_STREQ(aBuf, "DDNet最");
str_utf8_copy(aBuf, foo, 11);
EXPECT_STREQ(aBuf, "DDNet最");
str_utf8_copy(aBuf, foo, 12);
I can't count
2020-09-06 23:03:40 +00:00
EXPECT_STREQ(aBuf, "DDNet最好");
Add test cases
2020-09-06 22:57:21 +00:00
str_utf8_copy(aBuf, foo, 13);
EXPECT_STREQ(aBuf, "DDNet最好");
str_utf8_copy(aBuf, foo, 14);
EXPECT_STREQ(aBuf, "DDNet最好");
str_utf8_copy(aBuf, foo, 15);
I can't count
2020-09-06 23:03:40 +00:00
EXPECT_STREQ(aBuf, "DDNet最好了");
Add test cases
2020-09-06 22:57:21 +00:00
str_utf8_copy(aBuf, foo, 16);
EXPECT_STREQ(aBuf, "DDNet最好了");
}
Add str_time/str_time_float Handles centisecs < 0 Uses int64, otherwise we're limited to ~260 days
2020-10-18 20:44:02 +00:00
TEST(Str, StrTime)
{
char aBuf[32] = "foobar";
EXPECT_EQ(str_time(123456, TIME_DAYS, aBuf, 0), -1);
EXPECT_STREQ(aBuf, "foobar");
EXPECT_EQ(str_time(123456, TIME_MINS_CENTISECS + 1, aBuf, sizeof(aBuf)), -1);
EXPECT_STREQ(aBuf, "");
EXPECT_EQ(str_time(-123456, TIME_MINS_CENTISECS, aBuf, sizeof(aBuf)), 8);
EXPECT_STREQ(aBuf, "00:00.00");
EXPECT_EQ(str_time(INT64_MAX, TIME_DAYS, aBuf, sizeof(aBuf)), 23);
EXPECT_STREQ(aBuf, "1067519911673d 00:09:18");
EXPECT_EQ(str_time(123456, TIME_DAYS, aBuf, sizeof(aBuf)), 5);
EXPECT_STREQ(aBuf, "20:34");
EXPECT_EQ(str_time(1234567, TIME_DAYS, aBuf, sizeof(aBuf)), 8);
EXPECT_STREQ(aBuf, "03:25:45");
EXPECT_EQ(str_time(12345678, TIME_DAYS, aBuf, sizeof(aBuf)), 11);
EXPECT_STREQ(aBuf, "1d 10:17:36");
EXPECT_EQ(str_time(123456, TIME_HOURS, aBuf, sizeof(aBuf)), 5);
EXPECT_STREQ(aBuf, "20:34");
EXPECT_EQ(str_time(1234567, TIME_HOURS, aBuf, sizeof(aBuf)), 8);
EXPECT_STREQ(aBuf, "03:25:45");
EXPECT_EQ(str_time(12345678, TIME_HOURS, aBuf, sizeof(aBuf)), 8);
EXPECT_STREQ(aBuf, "34:17:36");
EXPECT_EQ(str_time(123456, TIME_MINS, aBuf, sizeof(aBuf)), 5);
EXPECT_STREQ(aBuf, "20:34");
EXPECT_EQ(str_time(1234567, TIME_MINS, aBuf, sizeof(aBuf)), 6);
EXPECT_STREQ(aBuf, "205:45");
EXPECT_EQ(str_time(12345678, TIME_MINS, aBuf, sizeof(aBuf)), 7);
EXPECT_STREQ(aBuf, "2057:36");
EXPECT_EQ(str_time(123456, TIME_HOURS_CENTISECS, aBuf, sizeof(aBuf)), 8);
EXPECT_STREQ(aBuf, "20:34.56");
EXPECT_EQ(str_time(1234567, TIME_HOURS_CENTISECS, aBuf, sizeof(aBuf)), 11);
EXPECT_STREQ(aBuf, "03:25:45.67");
EXPECT_EQ(str_time(12345678, TIME_HOURS_CENTISECS, aBuf, sizeof(aBuf)), 11);
EXPECT_STREQ(aBuf, "34:17:36.78");
EXPECT_EQ(str_time(123456, TIME_MINS_CENTISECS, aBuf, sizeof(aBuf)), 8);
EXPECT_STREQ(aBuf, "20:34.56");
EXPECT_EQ(str_time(1234567, TIME_MINS_CENTISECS, aBuf, sizeof(aBuf)), 9);
EXPECT_STREQ(aBuf, "205:45.67");
EXPECT_EQ(str_time(12345678, TIME_MINS_CENTISECS, aBuf, sizeof(aBuf)), 10);
EXPECT_STREQ(aBuf, "2057:36.78");
}
TEST(Str, StrTimeFloat)
{
char aBuf[64];
EXPECT_EQ(str_time_float(123456.78, TIME_DAYS, aBuf, sizeof(aBuf)), 11);
EXPECT_STREQ(aBuf, "1d 10:17:36");
Fix centisecs rounding in str_time_float
2021-01-08 10:21:37 +00:00
EXPECT_EQ(str_time_float(12.16, TIME_HOURS_CENTISECS, aBuf, sizeof(aBuf)), 8);
EXPECT_STREQ(aBuf, "00:12.16");
Add str_time/str_time_float Handles centisecs < 0 Uses int64, otherwise we're limited to ~260 days
2020-10-18 20:44:02 +00:00
}
Reference in a new issue Copy permalink