yystopf
/
openharmony_kernel_liteos_m
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

!903 fix: 修复测试用例断言宏使用不规范的问题 

Merge pull request !903 from Zhaotianyu/20221110test_fix_assert
This commit is contained in:
openharmony_ci 2022-11-14 09:41:12 +00:00 committed by Gitee
parent 6cb544b158 27ed27eb89
commit be1267fafa
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
10 changed files with 61 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
testsuites/sample/posix/pthread_func_test.c
View File

@ -679,7 +679,8 @@ LITE_TEST_CASE(PthreadFuncTestSuite, TestPthread009, Function | MediumTest | Lev
static VOID PthreadOnceFunc01(void)
{
g_testCount++;
ICUNIT_ASSERT_EQUAL_VOID(g_testCount, 1, g_testCount);
ICUNIT_TRACK_EQUAL(g_testCount, 1, g_testCount);
return;
}
/**

10
testsuites/unittest/posix/src/fs/posix_fs_func_test.c
View File

@ -523,7 +523,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek006, Function | MediumTest
TEST_ASSERT_NOT_NULL(fp);
ret = fseek(fp, -1L, SEEK_SET);
TEST_ASSERT_EQUAL_INT(ret, -1);
TEST_ASSERT_EQUAL_INT(-1, ret);
off = ftell(fp);
ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
@ -549,7 +549,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek007, Function | MediumTest
TEST_ASSERT_NOT_NULL(fp);
ret = fseek(fp, -1L, SEEK_CUR);
TEST_ASSERT_EQUAL_INT(ret, -1);
TEST_ASSERT_EQUAL_INT(-1, ret);
off = ftell(fp);
ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
@ -575,7 +575,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek008, Function | MediumTest
TEST_ASSERT_NOT_NULL(fp);
ret = fseek(fp, -1L, SEEK_END);
TEST_ASSERT_EQUAL_INT(ret, -1);
TEST_ASSERT_EQUAL_INT(-1, ret);
off = ftell(fp);
ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
@ -630,7 +630,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek010, Function | MediumTest
fp->fd = 500; /* 500 is a wrong fd */
ret = fseek(fp, TEST_SEEK_SIZE, SEEK_SET);
TEST_ASSERT_EQUAL_INT(ret, -1);
TEST_ASSERT_EQUAL_INT(-1, ret);
fp->fd = fd;
@ -924,7 +924,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs005, Function | MediumTest | Lev
}
ret = ftell(fp);
TEST_ASSERT_EQUAL_INT(ret, TEST_LOOPUP_TIME * strlen(chr1));
TEST_ASSERT_EQUAL_INT(TEST_LOOPUP_TIME * strlen(chr1), ret);
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(0, ret);

22
testsuites/unittest/posix/src/math/math_func_test.c
View File

@ -142,11 +142,11 @@ LITE_TEST_CASE(PosixMathFuncTestSuite, testMathLog001, Function | MediumTest | L
double testValues[] = { 0.5, 5.5, 1};
double expected[] = { -0.69314718055994528623, 1.70474809223842527217, 0.00000000000000000000};
double ret;
PRINT_EMG("GZHTESTLOG PRINT_EMG: %f, %f, %f", testValues[0], testValues[1], testValues[2]);
LOG("GZHTESTLOG LOG: %f, %f, %f", testValues[0], testValues[1], testValues[2]);
PRINT_EMG("GZHTESTLOG PRINT_EMG: %lf, %lf, %lf", testValues[0], testValues[1], testValues[2]);
LOG("GZHTESTLOG LOG: %lf, %lf, %lf", testValues[0], testValues[1], testValues[2]);
for (int i = 0; i < testCount; ++i) {
ret = log(testValues[i]);
LOG("\n [POSIXTEST][log]log(%f) = %f, expected is %f", testValues[i], ret, expected[i]);
LOG("\n [POSIXTEST][log]log(%lf) = %lf, expected is %lf", testValues[i], ret, expected[i]);
TEST_ASSERT_EQUAL_FLOAT(expected[i], ret);
TEST_ASSERT_TRUE(DoubleEquals(expected[i], ret));
}
@ -170,7 +170,7 @@ LITE_TEST_CASE(PosixMathFuncTestSuite, testMathLog002, Function | MediumTest | L
for (int i = 0; i < testCount; ++i) {
ret = log(testValues[i]);
LOG("\n [POSIXTEST][log]log(%f) = %f, expected is %f", testValues[i], ret, expected[i]);
LOG("\n [POSIXTEST][log]log(%lf) = %lf, expected is %lf", testValues[i], ret, expected[i]);
TEST_ASSERT_EQUAL_FLOAT(expected[i], ret);
}
return 0;
@ -189,7 +189,7 @@ LITE_TEST_CASE(PosixMathFuncTestSuite, testMathSqrt001, Function | MediumTest |
double ret;
for (int i = 0; i < testCount; ++i) {
ret = sqrt(testValues[i]);
LOG("\n [POSIXTEST][sqrt]sqrt(%f) = %f, expected is %f", testValues[i], ret, expected[i]);
LOG("\n [POSIXTEST][sqrt]sqrt(%lf) = %lf, expected is %lf", testValues[i], ret, expected[i]);
TEST_ASSERT_EQUAL_FLOAT(expected[i], ret);
TEST_ASSERT_TRUE(DoubleEquals(expected[i], ret));
}
@ -209,7 +209,7 @@ LITE_TEST_CASE(PosixMathFuncTestSuite, testMathSqrt002, Function | MediumTest |
double ret;
for (int i = 0; i < testCount; ++i) {
ret = sqrt(testValues[i]);
LOG("\n [POSIXTEST][sqrt]sqrt(%f) = %f, expected is %f", testValues[i], ret, expected[i]);
LOG("\n [POSIXTEST][sqrt]sqrt(%lf) = %lf, expected is %lf", testValues[i], ret, expected[i]);
TEST_ASSERT_EQUAL_FLOAT(expected[i], ret);
}
return 0;
@ -233,7 +233,7 @@ LITE_TEST_CASE(PosixMathFuncTestSuite, testMathPow001, Function | MediumTest | L
double ret;
for (int i = 0; i < testCount; ++i) {
ret = pow(testValues[i][TEST_VALUE_X], testValues[i][TEST_VALUE_Y]);
LOG("\n [POSIXTEST][pow]pow1(%f,%f) = %f, expected is %f", testValues[i][TEST_VALUE_X],
LOG("\n [POSIXTEST][pow]pow1(%lf,%lf) = %lf, expected is %lf", testValues[i][TEST_VALUE_X],
testValues[i][TEST_VALUE_Y], ret, testValues[i][TEST_EXPECTED]);
TEST_ASSERT_EQUAL_FLOAT(testValues[i][TEST_EXPECTED], ret);
TEST_ASSERT_TRUE(DoubleEquals(testValues[i][TEST_EXPECTED], ret));
@ -270,7 +270,7 @@ LITE_TEST_CASE(PosixMathFuncTestSuite, testMathPow002, Function | MediumTest | L
ret = pow(testValues[i][TEST_VALUE_X], testValues[i][TEST_VALUE_Y]);
TEST_ASSERT_EQUAL_FLOAT(testValues[i][TEST_EXPECTED], ret);
TEST_ASSERT_TRUE(DoubleEquals(testValues[i][TEST_EXPECTED], ret));
LOG("\n [POSIXTEST][pow]pow1(%f,%f) = %f, expected is %f", testValues[i][TEST_VALUE_X],
LOG("\n [POSIXTEST][pow]pow1(%lf,%lf) = %lf, expected is %lf", testValues[i][TEST_VALUE_X],
testValues[i][TEST_VALUE_Y], ret, testValues[i][TEST_EXPECTED]);
}
return 0;
@ -295,7 +295,7 @@ LITE_TEST_CASE(PosixMathFuncTestSuite, testMathPow003, Function | MediumTest | L
for (int i = 0; i < testCount; ++i) {
ret = pow(testValues[i][TEST_VALUE_X], testValues[i][TEST_VALUE_Y]);
TEST_ASSERT_EQUAL_FLOAT(testValues[i][TEST_EXPECTED], ret);
LOG("\n [POSIXTEST][pow]pow1(%f,%f) = %f, expected is %f", testValues[i][TEST_VALUE_X],
LOG("\n [POSIXTEST][pow]pow1(%lf,%lf) = %lf, expected is %lf", testValues[i][TEST_VALUE_X],
testValues[i][TEST_VALUE_Y], ret, testValues[i][TEST_EXPECTED]);
TEST_ASSERT_TRUE(DoubleEquals(testValues[i][TEST_EXPECTED], ret));
}
@ -316,7 +316,7 @@ LITE_TEST_CASE(PosixMathFuncTestSuite, testMathRound001, Function | MediumTest |
double ret;
for (int i = 0; i < testCount; ++i) {
ret = round(testValues[i]);
LOG("\n [POSIXTEST][round]round1(%f) = %f, expected is %f", testValues[i], ret, expected[i]);
LOG("\n [POSIXTEST][round]round1(%lf) = %lf, expected is %lf", testValues[i], ret, expected[i]);
TEST_ASSERT_EQUAL_FLOAT(expected[i], ret);
TEST_ASSERT_TRUE(DoubleEquals(expected[i], ret));
}
@ -336,7 +336,7 @@ LITE_TEST_CASE(PosixMathFuncTestSuite, testMathRound002, Function | MediumTest |
double ret;
for (int i = 0; i < testCount; ++i) {
ret = round(testValues[i]);
LOG("\n [POSIXTEST][round]round1(%f) = %f, expected is %f", testValues[i], ret, expected[i]);
LOG("\n [POSIXTEST][round]round1(%lf) = %lf, expected is %lf", testValues[i], ret, expected[i]);
TEST_ASSERT_EQUAL_FLOAT(expected[i], ret);
TEST_ASSERT_TRUE(DoubleEquals(expected[i], ret));
}

6
testsuites/unittest/posix/src/regex/regex_func_test.c
View File

@ -82,7 +82,7 @@ int TestRegex(int flag, const char *pattern, const char *buf, const int expected
int j = 0;
regcomp(&reg, pattern, flag);
int status = regexec(&reg, buf, nmatch, pmatch, 0);
TEST_ASSERT_EQUAL_INT(status, expectedStatus);
TEST_ASSERT_EQUAL_INT(expectedStatus, status);
if (status == REG_NOMATCH) {
LOG("no match");
} else if (status == 0) {
@ -105,7 +105,7 @@ int TestRegcomp(int flag, const char *pattern, const int expectedStatus)
regex_t reg;
int status = regcomp(&reg, pattern, flag);
LOG("pattern : %s ,real status : %d \n", pattern, status);
TEST_ASSERT_EQUAL_INT(status, expectedStatus);
TEST_ASSERT_EQUAL_INT(expectedStatus, status);
regfree(&reg);
return 0;
}
@ -166,7 +166,7 @@ LITE_TEST_CASE(PosixRegexFuncTestSuite, testRegexNosub001, Function | MediumTest
const char *pattern2 = "HARMONY[1-9]";
regcomp(&reg, pattern2, cflags);
int status = regexec(&reg, buf, (size_t)0, NULL, 0);
TEST_ASSERT_EQUAL_INT(status, 0);
TEST_ASSERT_EQUAL_INT(0, status);
regfree(&reg);
return 0;
}

10
testsuites/unittest/posix/src/semaphore/semaphore_func_test.c
View File

@ -183,7 +183,7 @@ LITE_TEST_CASE(PosixSemaphoreFuncTestSuite, testIpcSem_Timedwait003, Function |
ts.tv_nsec = 200000;
ret = sem_timedwait((sem_t *)&sem, &ts);
TEST_ASSERT_EQUAL_INT(-1, ret);
TEST_ASSERT_EQUAL_INT(errno, EINVAL);
TEST_ASSERT_EQUAL_INT(EINVAL, errno);
ret = sem_init((sem_t *)&sem, 0, 0);
TEST_ASSERT_EQUAL_INT(0, ret);
@ -192,17 +192,17 @@ LITE_TEST_CASE(PosixSemaphoreFuncTestSuite, testIpcSem_Timedwait003, Function |
ts.tv_nsec = -2;
ret = sem_timedwait((sem_t *)&sem, &ts);
TEST_ASSERT_EQUAL_INT(-1, ret);
TEST_ASSERT_EQUAL_INT(errno, EINVAL);
TEST_ASSERT_EQUAL_INT(EINVAL, errno);
ts.tv_sec = time(NULL);
ts.tv_nsec = NANO_S;
ret = sem_timedwait((sem_t *)&sem, &ts);
TEST_ASSERT_EQUAL_INT(-1, ret);
TEST_ASSERT_EQUAL_INT(errno, EINVAL);
TEST_ASSERT_EQUAL_INT(EINVAL, errno);
ret = sem_timedwait((sem_t *)&sem, NULL);
TEST_ASSERT_EQUAL_INT(-1, ret);
TEST_ASSERT_EQUAL_INT(errno, EINVAL);
TEST_ASSERT_EQUAL_INT(EINVAL, errno);
ret = sem_destroy((sem_t *)&sem);
TEST_ASSERT_EQUAL_INT(0, ret);
@ -211,7 +211,7 @@ LITE_TEST_CASE(PosixSemaphoreFuncTestSuite, testIpcSem_Timedwait003, Function |
ts.tv_nsec = 2000000;
ret = sem_timedwait(NULL, &ts);
TEST_ASSERT_EQUAL_INT(-1, ret);
TEST_ASSERT_EQUAL_INT(errno, EINVAL);
TEST_ASSERT_EQUAL_INT(EINVAL, errno);
return 0;
}

2
testsuites/unittest/posix/src/stdlib/strtoull_test.c
View File

@ -226,7 +226,7 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull008, Function | Medium
}
TEST_ASSERT_EQUAL_UINT64(ULLONG_MAX, ret);
TEST_ASSERT_EQUAL_INT(errno, ERANGE);
TEST_ASSERT_EQUAL_INT(ERANGE, errno);
TEST_ASSERT_EQUAL_STRING(endPtr, "");
return 0;
}

6
testsuites/unittest/posix/src/string/memory_func_test.c
View File

@ -160,10 +160,10 @@ LITE_TEST_CASE(PosixMemFuncTestSuite, testOsMemMemset001, Function | MediumTest
char ch = rand() % 26 + 'A';
retValue = memset(source, ch, sizeof(source) / sizeof(source[0]));
TEST_ASSERT_NOT_NULL(retValue);
TEST_ASSERT_EQUAL_PTR(retValue, source);
TEST_ASSERT_EQUAL_PTR(source, retValue);
for (int i = 0; i < (sizeof(source) / sizeof(source[0])); i++) {
TEST_ASSERT_EQUAL_INT((int)source[i], (int)ch);
TEST_ASSERT_EQUAL_INT((int)ch, (int)source[i]);
}
return 0;
};
@ -292,7 +292,7 @@ LITE_TEST_CASE(PosixMemFuncTestSuite, testOsMemRealloc001, Function | MediumTest
}
free(mem1);
TEST_ASSERT_EQUAL_INT(failure, 0);
TEST_ASSERT_EQUAL_INT(0, failure);
}
return 0;
};

20
testsuites/unittest/posix/src/string/string_func_test_01.c
View File

@ -74,7 +74,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrlen001, Function | MediumT
{
char src[] = "helloworld";
int ret = strlen(src);
TEST_ASSERT_EQUAL_INT(ret, 10);
TEST_ASSERT_EQUAL_INT(10, ret);
return 0;
}
@ -87,7 +87,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrlen002, Function | MediumT
{
char src[] = "hello world";
int ret = strlen(src);
TEST_ASSERT_EQUAL_INT(ret, 11);
TEST_ASSERT_EQUAL_INT(11, ret);
return 0;
}
@ -99,7 +99,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrlen002, Function | MediumT
LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrlen003, Function | MediumTest | Level1)
{
int ret = strlen("");
TEST_ASSERT_EQUAL_INT(ret, 0);
TEST_ASSERT_EQUAL_INT(0, ret);
return 0;
}
@ -112,7 +112,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrlen004, Function | MediumT
{
char src[] = "hello\0world";
int ret = strlen(src);
TEST_ASSERT_EQUAL_INT(ret, 5);
TEST_ASSERT_EQUAL_INT(5, ret);
return 0;
}
@ -125,7 +125,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrlen005, Function | MediumT
{
char src[] = "\0helloworld";
int ret = strlen(src);
TEST_ASSERT_EQUAL_INT(ret, 0);
TEST_ASSERT_EQUAL_INT(0, ret);
return 0;
}
@ -270,7 +270,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrrchr001, Function | Medium
{
char src[] = "hello world";
char *ret = strrchr(src, '!');
TEST_ASSERT_EQUAL_PTR(ret, NULL);
TEST_ASSERT_EQUAL_PTR(NULL, ret);
TEST_ASSERT_NULL(ret);
return 0;
}
@ -284,7 +284,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrrchr002, Function | Medium
{
char src[] = "hello world";
char *ret = strrchr(src, '\0');
TEST_ASSERT_EQUAL_PTR(ret, src + 11);
TEST_ASSERT_EQUAL_PTR(src + 11, ret);
TEST_ASSERT_NOT_NULL(ret);
return 0;
}
@ -298,7 +298,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrrchr003, Function | Medium
{
char src[] = "hello\0world";
char *ret = strrchr(src, '\0');
TEST_ASSERT_EQUAL_PTR(ret, src + 5);
TEST_ASSERT_EQUAL_PTR(src + 5, ret);
TEST_ASSERT_NOT_NULL(ret);
return 0;
}
@ -312,7 +312,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrrchr004, Function | Medium
{
char src[] = "hello world";
char *ret = strrchr(src, ' ');
TEST_ASSERT_EQUAL_PTR(ret, src + 5);
TEST_ASSERT_EQUAL_PTR(src + 5, ret);
TEST_ASSERT_NOT_NULL(ret);
return 0;
}
@ -326,7 +326,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStringStrrchr005, Function | Medium
{
char src[] = "hello\0world";
char *ret = strrchr(src, ' ');
TEST_ASSERT_EQUAL_PTR(ret, NULL);
TEST_ASSERT_EQUAL_PTR(NULL, ret);
TEST_ASSERT_NULL(ret);
return 0;
}

10
testsuites/unittest/posix/src/string/string_func_test_02.c
View File

@ -80,19 +80,19 @@ static BOOL PosixStringsFuncTestSuiteTearDown(void)
LITE_TEST_CASE(PosixStringsFuncTestSuite, testStrCaseCmp001, Function | MediumTest | Level1)
{
int ret = strcasecmp("", "");
TEST_ASSERT_EQUAL_INT(ret, EQUAL);
TEST_ASSERT_EQUAL_INT(EQUAL, ret);
ret = strcasecmp("abcdefg", "abcdefg");
TEST_ASSERT_EQUAL_INT(ret, EQUAL);
TEST_ASSERT_EQUAL_INT(EQUAL, ret);
ret = strcasecmp("abcdefg", "abcdEFg");
TEST_ASSERT_EQUAL_INT(ret, EQUAL);
TEST_ASSERT_EQUAL_INT(EQUAL, ret);
ret = strcasecmp("abcdefg", "abcdEF");
TEST_ASSERT_NOT_EQUAL(ret, EQUAL);
TEST_ASSERT_NOT_EQUAL(EQUAL, ret);
ret = strcasecmp("abcdef", "abcdEFg");
TEST_ASSERT_NOT_EQUAL(ret, EQUAL);
TEST_ASSERT_NOT_EQUAL(EQUAL, ret);
return 0;
};

32
testsuites/unittest/posix/src/string/string_func_test_03.c
View File

@ -78,14 +78,14 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStrstrcmp001, Function | MediumTest
char dest[] = {"Compiler exited with error"};
retValue = strcmp(source, dest);
TEST_ASSERT_EQUAL_INT(retValue, 0);
TEST_ASSERT_EQUAL_INT(0, retValue);
int ret = strcmp("abcdef", "ABCDEF");
TEST_ASSERT_LESS_THAN(ret, 0);
TEST_ASSERT_GREATER_THAN(0, ret);
ret = strcmp("123456", "654321");
TEST_ASSERT_GREATER_THAN(ret, 0);
TEST_ASSERT_EQUAL_INT(strcmp("~!@#$%^&*()_+", "~!@#$%^&*()_+"), 0);
TEST_ASSERT_LESS_THAN(0, ret);
TEST_ASSERT_EQUAL_INT(0, strcmp("~!@#$%^&*()_+", "~!@#$%^&*()_+"));
return 0;
};
@ -102,7 +102,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStrstrcmp002, Function | MediumTest
char dest[] = {"00000000000"};
retValue = strcmp(source, dest);
TEST_ASSERT_LESS_THAN(retValue, 0);
TEST_ASSERT_GREATER_THAN(0, retValue);
return 0;
};
@ -119,7 +119,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStrstrcmp003, Function | MediumTest
char dest[] = {"Compiler exited with error"};
retValue = strcmp(source, dest);
TEST_ASSERT_GREATER_THAN(retValue, 0);
TEST_ASSERT_LESS_THAN(0, retValue);
return 0;
};
@ -137,16 +137,16 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStrStrdup001, Function | MediumTest
dest = strdup(source);
TEST_ASSERT_NOT_NULL(dest);
printf("The Result Display :%s\r\n", dest);
TEST_ASSERT_EQUAL_CHAR_ARRAY(dest, source, sizeof(source) / sizeof(source[0]));
TEST_ASSERT_EQUAL_CHAR_ARRAY(source, dest, sizeof(source) / sizeof(source[0]));
char src[] = "hello world !";
char *ret = strdup(src);
TEST_ASSERT_EQUAL_CHAR_ARRAY(ret, src, sizeof(src) / sizeof(src[0]));
TEST_ASSERT_EQUAL_CHAR_ARRAY(src, ret, sizeof(src) / sizeof(src[0]));
free(ret);
char srcS[] = "This is String1";
ret = strdup(srcS);
TEST_ASSERT_EQUAL_CHAR_ARRAY(ret, "This is String1", sizeof(srcS) / sizeof(srcS[0]));
TEST_ASSERT_EQUAL_CHAR_ARRAY("This is String1", ret, sizeof(srcS) / sizeof(srcS[0]));
free(ret);
return 0;
};
@ -165,7 +165,7 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStrStrdup002, Function | MediumTest
dest = strdup(source);
TEST_ASSERT_NOT_NULL(dest);
printf("The Result Display :%s\r\n", dest);
TEST_ASSERT_EQUAL_CHAR_ARRAY(dest, source, sizeof(source) / sizeof(source[0]));
TEST_ASSERT_EQUAL_CHAR_ARRAY(source, dest, sizeof(source) / sizeof(source[0]));
return 0;
};
@ -222,12 +222,12 @@ LITE_TEST_CASE(PosixStringFuncTestSuite, testStrStrptime001, Function | MediumTe
struct tm tmData;
(void)memset_s(&tmData, sizeof(struct tm), 0, sizeof(struct tm));
char *ret = strptime("2020-10-29 21:24:00abc", "%Y-%m-%d %H:%M:%S", &tmData);
TEST_ASSERT_EQUAL_CHAR_ARRAY(ret, "abc", 3);
TEST_ASSERT_EQUAL_INT(tmData.tm_year, 120);
TEST_ASSERT_EQUAL_INT(tmData.tm_mon, 9);
TEST_ASSERT_EQUAL_INT(tmData.tm_mday, 29);
TEST_ASSERT_EQUAL_INT(tmData.tm_hour, 21);
TEST_ASSERT_EQUAL_INT(tmData.tm_min, 24);
TEST_ASSERT_EQUAL_CHAR_ARRAY("abc", ret, 3);
TEST_ASSERT_EQUAL_INT(120, tmData.tm_year);
TEST_ASSERT_EQUAL_INT(9, tmData.tm_mon);
TEST_ASSERT_EQUAL_INT(29, tmData.tm_mday);
TEST_ASSERT_EQUAL_INT(21, tmData.tm_hour);
TEST_ASSERT_EQUAL_INT(24, tmData.tm_min);
return 0;
}
#endif