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

!741 Fix : 修复了测试用例返回值不匹配的问题 

Merge pull request !741 from yinjiaming/fix
This commit is contained in:
openharmony_ci 2022-07-11 11:19:21 +00:00 committed by Gitee
parent 8170152730 6f92337be2
commit 9d0460b546
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
12 changed files with 189 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
testsuites/include/iCunit.h
View File

@ -245,7 +245,7 @@ extern void ICunitSaveErr(iiUINT32 line, iiUINT32 retCode);
do { \
if ((param) != (value)) { \
ICunitSaveErr(__LINE__, (iiUINT32)retcode); \
return; \
return 1; \
} \
} while (0)

98
testsuites/sample/kernel/atomic/it_los_atomic_011.c
View File

@ -48,176 +48,176 @@ static VOID TaskF01(VOID)
INT64 read64Counter = 0;
INT64 atomic64Ret = 0;
ICUNIT_ASSERT_EQUAL(g_testCount, 0, g_testCount);
ICUNIT_ASSERT_EQUAL_VOID(g_testCount, 0, g_testCount);
atomicTestCounter = 0x88888888;
LOS_AtomicSet(&atomicTestCounter, 0x88888888);
atomicRet = LOS_AtomicAdd(&atomicTestCounter, 0x33333333);
ICUNIT_ASSERT_EQUAL(atomicRet, 0xbbbbbbbb, atomicRet);
ICUNIT_ASSERT_EQUAL_VOID(atomicRet, 0xbbbbbbbb, atomicRet);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0xbbbbbbbb, readCounter);
ICUNIT_ASSERT_EQUAL_VOID(readCounter, 0xbbbbbbbb, readCounter);
LOS_AtomicSet(&atomicTestCounter, 0xaaaaaaaa);
atomicRet = LOS_AtomicAdd(&atomicTestCounter, 0x77777777);
ICUNIT_ASSERT_EQUAL(atomicRet, 0x22222221, atomicRet);
ICUNIT_ASSERT_EQUAL_VOID(atomicRet, 0x22222221, atomicRet);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0x22222221, readCounter);
LOS_AtomicSet(&atomicTestCounter, 0xdddddddd);
atomicRet = LOS_AtomicSub(&atomicTestCounter, 0x99999999);
ICUNIT_ASSERT_EQUAL(atomicRet, 0x44444444, atomicRet);
ICUNIT_ASSERT_EQUAL_VOID(atomicRet, 0x44444444, atomicRet);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0x44444444, readCounter);
ICUNIT_ASSERT_EQUAL_VOID(readCounter, 0x44444444, readCounter);
LOS_AtomicSet(&atomicTestCounter, 0x88888888);
atomicRet = LOS_AtomicSub(&atomicTestCounter, 0xdddddddd);
ICUNIT_ASSERT_EQUAL(atomicRet, 0xaaaaaaab, atomicRet);
ICUNIT_ASSERT_EQUAL_VOID(atomicRet, 0xaaaaaaab, atomicRet);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0xaaaaaaab, readCounter);
ICUNIT_ASSERT_EQUAL_VOID(readCounter, 0xaaaaaaab, readCounter);
LOS_AtomicSet(&atomicTestCounter, 0x11111111);
LOS_AtomicInc(&atomicTestCounter);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0x11111112, readCounter);
ICUNIT_ASSERT_EQUAL_VOID(readCounter, 0x11111112, readCounter);
LOS_AtomicSet(&atomicTestCounter, 0xffffffff);
LOS_AtomicInc(&atomicTestCounter);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0x00000000, readCounter);
ICUNIT_ASSERT_EQUAL_VOID(readCounter, 0x00000000, readCounter);
LOS_AtomicSet(&atomicTestCounter, 0x88888888);
atomicRet = LOS_AtomicIncRet(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(atomicRet, 0x88888889, atomicRet);
ICUNIT_ASSERT_EQUAL_VOID(atomicRet, 0x88888889, atomicRet);
LOS_AtomicSet(&atomicTestCounter, 0xffffffff);
atomicRet = LOS_AtomicIncRet(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(atomicRet, 0x00000000, atomicRet);
ICUNIT_ASSERT_EQUAL_VOID(atomicRet, 0x00000000, atomicRet);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0x00000000, readCounter);
ICUNIT_ASSERT_EQUAL_VOID(readCounter, 0x00000000, readCounter);
LOS_AtomicSet(&atomicTestCounter, 0x66666666);
LOS_AtomicDec(&atomicTestCounter);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0x66666665, readCounter);
ICUNIT_ASSERT_EQUAL_VOID(readCounter, 0x66666665, readCounter);
LOS_AtomicSet(&atomicTestCounter, 0x00000000);
LOS_AtomicDec(&atomicTestCounter);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0xffffffff, readCounter);
ICUNIT_ASSERT_EQUAL_VOID(readCounter, 0xffffffff, readCounter);
LOS_AtomicSet(&atomicTestCounter, 0x88888888);
atomicRet = LOS_AtomicDecRet(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(atomicRet, 0x88888887, atomicRet);
ICUNIT_ASSERT_EQUAL_VOID(atomicRet, 0x88888887, atomicRet);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0x88888887, readCounter);
ICUNIT_ASSERT_EQUAL_VOID(readCounter, 0x88888887, readCounter);
LOS_AtomicSet(&atomicTestCounter, 0x00000000);
atomicRet = LOS_AtomicDecRet(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(atomicRet, 0xffffffff, atomicRet);
ICUNIT_ASSERT_EQUAL_VOID(atomicRet, 0xffffffff, atomicRet);
readCounter = LOS_AtomicRead(&atomicTestCounter);
ICUNIT_ASSERT_EQUAL(readCounter, 0xffffffff, readCounter);
ICUNIT_ASSERT_EQUAL_VOID(readCounter, 0xffffffff, readCounter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa88888888);
atomic64Ret = LOS_Atomic64Add(&atomic64TestCounter, 0x0000000033333333);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0x5aaaaaaabbbbbbbb, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0x5aaaaaaabbbbbbbb, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaaaaaabbbbbbbb, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaaaaaabbbbbbbb, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa88888888);
atomic64Ret = LOS_Atomic64Add(&atomic64TestCounter, 0x0000123456789abc);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0x5aaabcdedf012344, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0x5aaabcdedf012344, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaabcdedf012344, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaabcdedf012344, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0xaaaaaaaa88888888);
atomic64Ret = LOS_Atomic64Add(&atomic64TestCounter, 0x88888888aaaaaaaa);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0x3333333333333332, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0x3333333333333332, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x3333333333333332, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x3333333333333332, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa88888888);
atomic64Ret = LOS_Atomic64Sub(&atomic64TestCounter, 0x0000000033333333);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0x5aaaaaaa55555555, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0x5aaaaaaa55555555, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaaaaaa55555555, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaaaaaa55555555, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa88888888);
atomic64Ret = LOS_Atomic64Sub(&atomic64TestCounter, 0x00001234cba98765);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0x5aaa9875bcdf0123, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0x5aaa9875bcdf0123, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaa9875bcdf0123, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaa9875bcdf0123, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa88888888);
atomic64Ret = LOS_Atomic64Sub(&atomic64TestCounter, 0x60001234cba98765);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0xfaaa9875bcdf0123, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0xfaaa9875bcdf0123, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0xfaaa9875bcdf0123, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0xfaaa9875bcdf0123, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa88888888);
LOS_Atomic64Inc(&atomic64TestCounter);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaaaaaa88888889, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaaaaaa88888889, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaaffffffff);
LOS_Atomic64Inc(&atomic64TestCounter);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaaaaab00000000, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaaaaab00000000, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0xffffffffffffffff);
LOS_Atomic64Inc(&atomic64TestCounter);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x0000000000000000, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x0000000000000000, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa88888888);
atomic64Ret = LOS_Atomic64IncRet(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0x5aaaaaaa88888889, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0x5aaaaaaa88888889, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaaaaaa88888889, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaaaaaa88888889, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaaffffffff);
atomic64Ret = LOS_Atomic64IncRet(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0x5aaaaaab00000000, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0x5aaaaaab00000000, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaaaaab00000000, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaaaaab00000000, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0xffffffffffffffff);
atomic64Ret = LOS_Atomic64IncRet(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0x0000000000000000, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0x0000000000000000, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x0000000000000000, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x0000000000000000, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa88888888);
LOS_Atomic64Dec(&atomic64TestCounter);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaaaaaa88888887, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaaaaaa88888887, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa00000000);
LOS_Atomic64Dec(&atomic64TestCounter);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaaaaa9ffffffff, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaaaaa9ffffffff, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x0000000000000000);
LOS_Atomic64Dec(&atomic64TestCounter);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0xffffffffffffffff, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0xffffffffffffffff, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa88888888);
atomic64Ret = LOS_Atomic64DecRet(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0x5aaaaaaa88888887, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0x5aaaaaaa88888887, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaaaaaa88888887, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaaaaaa88888887, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x5aaaaaaa00000000);
atomic64Ret = LOS_Atomic64DecRet(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0x5aaaaaa9ffffffff, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0x5aaaaaa9ffffffff, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0x5aaaaaa9ffffffff, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0x5aaaaaa9ffffffff, read64Counter);
LOS_Atomic64Set(&atomic64TestCounter, 0x0000000000000000);
atomic64Ret = LOS_Atomic64DecRet(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(atomic64Ret, 0xffffffffffffffff, atomic64Ret);
ICUNIT_ASSERT_EQUAL_VOID(atomic64Ret, 0xffffffffffffffff, atomic64Ret);
read64Counter = LOS_Atomic64Read(&atomic64TestCounter);
ICUNIT_ASSERT_EQUAL(read64Counter, 0xffffffffffffffff, read64Counter);
ICUNIT_ASSERT_EQUAL_VOID(read64Counter, 0xffffffffffffffff, read64Counter);
++g_testCount;
}

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

@ -439,7 +439,7 @@ static VOID *PthreadFunc07(void *argument)
g_testCount = 0;
ret = pthread_mutex_init(&g_pthread_mutex, NULL);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
ret = pthread_attr_init(&attr);
ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
@ -626,7 +626,7 @@ LITE_TEST_CASE(PthreadFuncTestSuite, TestPthread008, Function | MediumTest | Lev
static VOID *PthreadPrioFunc01(void *argument)
{
g_testCount++;
ICUNIT_ASSERT_EQUAL(g_testCount, (UINT32)argument, g_testCount);
ICUNIT_TRACK_EQUAL(g_testCount, (UINT32)argument, g_testCount);
return NULL;
}
@ -677,7 +677,7 @@ LITE_TEST_CASE(PthreadFuncTestSuite, TestPthread009, Function | MediumTest | Lev
static VOID PthreadOnceFunc01(void)
{
g_testCount++;
ICUNIT_ASSERT_EQUAL(g_testCount, 1, g_testCount);
ICUNIT_ASSERT_EQUAL_VOID(g_testCount, 1, g_testCount);
}
/**
@ -722,10 +722,11 @@ static VOID *PthreadCancelFunc01(void *argument)
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
while (1) {
g_testCount++;
ICUNIT_ASSERT_EQUAL(g_testCount, 1, g_testCount);
ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT);
LOS_TaskDelay(PTHREAD_TASK_DELAY);
}
EXIT:
return NULL;
}
@ -774,7 +775,7 @@ static VOID *PthreadTestcancelFunc01(void *argument)
ICUNIT_TRACK_EQUAL(ret, 0, ret);
ret = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
g_testCount = 1;
g_pthreadSem = 1;
@ -786,6 +787,7 @@ static VOID *PthreadTestcancelFunc01(void *argument)
pthread_testcancel();
g_testCount = -1;
EXIT:
return NULL;
}
@ -996,7 +998,7 @@ EXIT:
return LOS_OK;
};
static void *PosixTestThread(void *arg)
static void PosixTestCase(void)
{
ADD_TEST_CASE(TestPthread001);
ADD_TEST_CASE(TestPthread002);
@ -1015,9 +1017,14 @@ static void *PosixTestThread(void *arg)
ADD_TEST_CASE(TestPthread015);
ADD_TEST_CASE(TestPthread016);
ADD_TEST_CASE(TestPthread017);
return NULL;
return;
}
static void *PosixTestThread(void *arg)
{
PosixTestCase();
return NULL;
}
int PthreadFuncTestSuite(void)
{
pthread_attr_t attr;

1
testsuites/src/osTest.c
View File

@ -217,7 +217,6 @@ void TestCmsis2(void)
VOID TestTaskEntry()
{
UINT32 ret;
PRINTF("\t\n --- Test Start --- \n\n");
ICunitInit();

1
testsuites/unittest/posix/src/errno/strerror_test.c
View File

@ -85,6 +85,7 @@ LITE_TEST_CASE(PosixSysFuncTestSuite, testOsSysStrerror001, Function | MediumTes
TEST_ASSERT_EQUAL_STRING("No such file or directory", strerror(2));
LOG("strerror(10) = %s\n", strerror(10));
TEST_ASSERT_EQUAL_STRING("No child process", strerror(10));
return 0;
};

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

@ -101,6 +101,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsDirname001, Function | MediumTest | L
char *workDir = dirname((char *)path);
TEST_ASSERT_NOT_NULL(workDir);
TEST_ASSERT_EQUAL_STRING(".", workDir);
return 0;
}
/* *
@ -114,6 +115,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsDirname002, Function | MediumTest | L
char *workDir = dirname((char *)path);
TEST_ASSERT_NOT_NULL(workDir);
TEST_ASSERT_EQUAL_STRING(TEST_ROOT, workDir);
return 0;
}
/* *
@ -128,6 +130,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsDirname003, Function | MediumTest | L
char *workDir = dirname((char *)path);
TEST_ASSERT_NOT_NULL(workDir);
TEST_ASSERT_EQUAL_STRING(TEST_ROOT, workDir);
return 0;
}
/* *
@ -157,6 +160,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsDirname004, Function | MediumTest | L
workDir = dirname(".");
TEST_ASSERT_NOT_NULL(workDir);
TEST_ASSERT_EQUAL_STRING(".", workDir);
return 0;
}
/* *
@ -173,6 +177,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose001, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -189,6 +194,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose002, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -205,6 +211,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose003, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -221,6 +228,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose004, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -234,6 +242,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose005, Function | MediumTest
FILE *fp = NULL;
fp = fopen(TEST_FILE_PTAH_RIGHT, "c");
TEST_ASSERT_NULL(fp);
return 0;
}
/* *
@ -252,6 +261,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose006, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -270,6 +280,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose007, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -288,6 +299,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose008, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -306,6 +318,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose009, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -324,6 +337,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose010, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -338,6 +352,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose011, Function | MediumTest
fp = fopen(TEST_FILE_PTAH_RIGHT, NULL);
TEST_ASSERT_NULL(fp);
return 0;
}
/* *
@ -360,6 +375,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFdopen001, Function | MediumTest | Le
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -382,6 +398,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFdopen002, Function | MediumTest | Le
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -404,6 +421,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFdopen003, Function | MediumTest | Le
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -425,12 +443,13 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFdopen004, Function | MediumTest | Le
// in some fs, may return ok, so return null or not is pass.
if (NULL == fp) {
close (fd);
return;
return 0;
}
fp->fd = fd;
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -452,6 +471,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek001, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -476,6 +496,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek002, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -500,6 +521,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek003, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -524,6 +546,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek004, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -548,6 +571,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek005, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -572,6 +596,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek006, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -596,6 +621,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek007, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -620,6 +646,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek008, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -644,6 +671,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek009, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -672,6 +700,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek010, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -699,6 +728,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek011, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
@ -727,6 +757,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek012, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -754,6 +785,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek013, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -780,6 +812,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek014, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -806,6 +839,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek015, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -832,6 +866,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek016, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -854,6 +889,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs001, Function | MediumTest | Lev
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -876,6 +912,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs002, Function | MediumTest | Lev
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -898,6 +935,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs003, Function | MediumTest | Lev
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -927,6 +965,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs004, Function | MediumTest | Lev
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -955,6 +994,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs005, Function | MediumTest | Lev
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -981,6 +1021,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite001, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1007,6 +1048,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite002, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1033,6 +1075,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite003, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1059,6 +1102,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite004, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1085,6 +1129,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite005, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1126,6 +1171,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite006, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
@ -1164,6 +1210,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite007, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1205,6 +1252,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite008, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1239,6 +1287,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite009, Function | MediumTest
ret = fclose(fp);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1262,6 +1311,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsReaddir001, Function | MediumTest | L
ret = closedir(dirp);
TEST_ASSERT_EQUAL_INT(ret, 0);
ret = rmdir(DIRA);
return 0;
}
/* *
@ -1291,6 +1341,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsReaddir002, Function | MediumTest | L
TEST_ASSERT_TRUE(tellDir0 == tellDir1);
ret = rmdir(DIRA);
return 0;
}
/* *
@ -1307,6 +1358,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRemove001, Function | MediumTest | Le
fclose(fp);
ret = remove(TEST_FILE_PTAH_RIGHT);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1322,6 +1374,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRemove002, Function | MediumTest | Le
TEST_ASSERT_EQUAL_INT(ret, 0);
ret = remove(DIRA);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1344,6 +1397,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRmdir001, Function | MediumTest | Lev
ret = rmdir(DIRA);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1372,6 +1426,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRmdir002, Function | MediumTest | Lev
ret = rmdir(DIRA);
TEST_ASSERT_EQUAL_INT(ret, 0);
return 0;
}
/* *
@ -1392,6 +1447,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsUnlink001, Function | MediumTest | Le
ret = unlink(tmpFileName);
TEST_ASSERT_TRUE(ret != -1);
return 0;
}
/* *
@ -1414,6 +1470,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsStat001, Function | MediumTest | Leve
ret = stat(tmpFileName, &buf);
TEST_ASSERT_TRUE(ret != -1);
return 0;
}
/* *
@ -1443,6 +1500,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsStat002, Function | MediumTest | Leve
TEST_ASSERT_TRUE(ret != -1);
TEST_ASSERT_TRUE(buf.st_size == sizeof(writeBuf));
return 0;
}
/* *
@ -1471,6 +1529,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsStat003, Function | MediumTest | Leve
TEST_ASSERT_TRUE(ret != -1);
TEST_ASSERT_EQUAL_INT(buf.st_rdev, 0);
return 0;
}
/* *
@ -1511,6 +1570,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsWrite001, Function | MediumTest | Lev
TEST_ASSERT_TRUE((TEST_RW_SIZE + TEST_RW_SIZE) == (unsigned int)reLseek);
(void)close(fd);
return 0;
}
/* *
@ -1542,6 +1602,7 @@ LITE_TEST_CASE(PosixFsFuncTestSuite, testFsWrite002, Function | MediumTest | Lev
TEST_ASSERT_TRUE(ret != -1);
TEST_ASSERT_TRUE(statbuf.st_size == sizeof(writeBuf) * TEST_LOOPUP_TIME);
return 0;
}
RUN_TEST_SUITE(PosixFsFuncTestSuite);

14
testsuites/unittest/posix/src/mqueue/mqueue_func_test.c
View File

@ -159,7 +159,7 @@ EXIT1:
ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
EXIT:
ret = mq_unlink(qName);
ICUNIT_ASSERT_EQUAL_VOID(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
return 0;
}
@ -377,7 +377,7 @@ LITE_TEST_CASE(MqueueFuncTestSuite, TestMqSendEAGAIN, Function | MediumTest | Le
attr.mq_msgsize = MQ_MSG_SIZE;
attr.mq_maxmsg = 1;
queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
ICUNIT_ASSERT_NOT_EQUAL_VOID(queue, (mqd_t)-1, queue);
ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue);
ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, 0);
ICUNIT_TRACK_EQUAL(ret, 0, ret);
@ -410,7 +410,7 @@ LITE_TEST_CASE(MqueueFuncTestSuite, TestMqSendEBADFEMSGSIZE, Function | MediumTe
attr.mq_msgsize = 1;
attr.mq_maxmsg = MQ_MAX_MSG;
queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
ICUNIT_ASSERT_NOT_EQUAL_VOID(queue, (mqd_t)-1, queue);
ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue);
ret = mq_send(NULL, MQ_MSG, 1, MQ_MSG_PRIO);
ICUNIT_TRACK_EQUAL(ret, -1, ret);
@ -424,12 +424,12 @@ LITE_TEST_CASE(MqueueFuncTestSuite, TestMqSendEBADFEMSGSIZE, Function | MediumTe
ret = mq_close(queue);
ICUNIT_TRACK_EQUAL(ret, 0, ret);
ret = mq_unlink(qName);
ICUNIT_ASSERT_EQUAL_VOID(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
attr.mq_msgsize = MQ_MSG_SIZE;
attr.mq_maxmsg = MQ_MAX_MSG;
queue = mq_open(qName, O_CREAT | O_RDONLY | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
ICUNIT_ASSERT_NOT_EQUAL_VOID(queue, (mqd_t)-1, queue);
ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue);
ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO);
ICUNIT_TRACK_EQUAL(ret, -1, ret);
@ -467,7 +467,7 @@ LITE_TEST_CASE(MqueueFuncTestSuite, TestMqSendEINVAL, Function | MediumTest | Le
attr.mq_msgsize = MQ_MSG_SIZE;
attr.mq_maxmsg = MQ_MAX_MSG;
queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
ICUNIT_ASSERT_NOT_EQUAL_VOID(queue, (mqd_t)-1, queue);
ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue);
ret = mq_send(queue, MQ_MSG, 0, MQ_MSG_PRIO);
ICUNIT_TRACK_EQUAL(ret, -1, ret);
@ -499,7 +499,7 @@ LITE_TEST_CASE(MqueueFuncTestSuite, TestMqReceiveEAGAIN, Function | MediumTest |
attr.mq_msgsize = MQ_MSG_SIZE;
attr.mq_maxmsg = MQ_MAX_MSG;
queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
ICUNIT_ASSERT_NOT_EQUAL_VOID(queue, (mqd_t)-1, queue);
ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue);
ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO);
ICUNIT_TRACK_EQUAL(ret, 0, ret);

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

@ -70,7 +70,7 @@ static BOOL PosixRegexFuncTestSuiteTearDown(void)
return TRUE;
}
void TestRegex(int flag, const char *pattern, const char *buf, const int expectedStatus, const char *expectedRes)
int TestRegex(int flag, const char *pattern, const char *buf, const int expectedStatus, const char *expectedRes)
{
regmatch_t pmatch[1];
const size_t nmatch = 1;
@ -94,15 +94,17 @@ void TestRegex(int flag, const char *pattern, const char *buf, const int expecte
TEST_ASSERT_EQUAL_STRING(res, expectedRes);
}
regfree(&reg);
return 0;
}
void TestRegcomp(int flag, const char *pattern, const int expectedStatus)
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);
regfree(&reg);
return 0;
}
/* *
@ -117,6 +119,7 @@ LITE_TEST_CASE(PosixRegexFuncTestSuite, testRegexExtended001, Function | MediumT
TestRegex(REG_EXTENDED, "^addr=([^&]*)", "fawei123&sex=girl&age=18\r\naddr=bantian&hobby=movie", REG_NOMATCH,
NULL);
return 0;
}
/* *
@ -129,6 +132,7 @@ LITE_TEST_CASE(PosixRegexFuncTestSuite, testRegexIcase001, Function | MediumTest
TestRegex(REG_ICASE, "HARMONY[1-9]", "harmony20000925@abcdef.com", REG_OK, "harmony2");
TestRegex(REG_ICASE, "HARMONY([1-9])", "harmony20000925@abcdef.com", REG_NOMATCH, NULL);
return 0;
}
/* *
@ -143,6 +147,7 @@ LITE_TEST_CASE(PosixRegexFuncTestSuite, testRegexNewline001, Function | MediumTe
TestRegex(REG_EXTENDED | REG_NEWLINE, "^addr=([^&]*)", "fawei123&sex=girl&age=18&addr=bantian&hobby=movie",
REG_NOMATCH, NULL);
return 0;
}
/* *
@ -160,6 +165,7 @@ LITE_TEST_CASE(PosixRegexFuncTestSuite, testRegexNosub001, Function | MediumTest
int status = regexec(&reg, buf, (size_t)0, NULL, 0);
TEST_ASSERT_EQUAL_INT(status, 0);
regfree(&reg);
return 0;
}
/* *
@ -174,6 +180,7 @@ LITE_TEST_CASE(PosixRegexFuncTestSuite, testRegcomp001, Function | MediumTest |
TestRegcomp(REG_EXTENDED, "[abcdefg", REG_EBRACK);
TestRegcomp(REG_EXTENDED, "\\x{4e00-\\x{9fa5}", REG_EBRACE);
TestRegcomp(REG_EXTENDED, "*abcdefg", REG_BADRPT);
return 0;
}
RUN_TEST_SUITE(PosixRegexFuncTestSuite);

13
testsuites/unittest/posix/src/stdlib/strtol_test.c
View File

@ -82,6 +82,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol001, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(16, ret);
TEST_ASSERT_EQUAL_STRING(endPtr16, "");
return 0;
}
/* *
@ -101,6 +102,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol002, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(16, ret);
TEST_ASSERT_EQUAL_STRING(endPtr16, "");
return 0;
}
/* *
@ -120,6 +122,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol003, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(10, ret);
TEST_ASSERT_EQUAL_STRING(endPtr10, "");
return 0;
}
/* *
@ -139,6 +142,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol004, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(-10, ret);
TEST_ASSERT_EQUAL_STRING(endPtr10, "");
return 0;
}
/* *
@ -158,6 +162,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol005, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(10, ret);
TEST_ASSERT_EQUAL_STRING(endPtr10_3, "");
return 0;
}
/* *
@ -177,6 +182,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol006, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(8, ret);
TEST_ASSERT_EQUAL_STRING(endPtr8, "");
return 0;
}
/* *
@ -196,6 +202,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol007, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(8, ret);
TEST_ASSERT_EQUAL_STRING(endPtr8_2, "");
return 0;
}
/* *
@ -215,6 +222,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol008, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(8, ret);
TEST_ASSERT_EQUAL_STRING(endPtr8_3, "");
return 0;
}
/* *
@ -234,6 +242,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol009, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(2, ret);
TEST_ASSERT_EQUAL_STRING(endPtr2, "");
return 0;
}
/* *
@ -253,6 +262,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol010, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(12, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, " 0110 0XDEFE 0666 -1.6");
return 0;
}
/* *
@ -272,6 +282,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol011, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(0, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, "12 1.5");
return 0;
}
LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol012, Function | MediumTest | Level1)
@ -286,6 +297,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol012, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(2147483647, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, " -2147483648");
return 0;
}
/* *
@ -305,6 +317,7 @@ LITE_TEST_CASE(PosixStdlibStrtolTest, testStdlibStrtol013, Function | MediumTest
}
TEST_ASSERT_EQUAL_INT32(-2147483648, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, "");
return 0;
}
RUN_TEST_SUITE(PosixStdlibStrtolTest);

10
testsuites/unittest/posix/src/stdlib/strtoul_test.c
View File

@ -83,6 +83,7 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul001, Function | MediumTe
}
TEST_ASSERT_EQUAL_UINT32(12UL, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, " 0110 0XDEFE 0666 4294967295 4294967296 12.34");
return 0;
}
/* *
@ -102,6 +103,7 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul002, Function | MediumTe
}
TEST_ASSERT_EQUAL_UINT32(6UL, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, " 0XDEFE 0666 4294967295 4294967296 12.34");
return 0;
}
/* *
@ -121,6 +123,7 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul003, Function | MediumTe
}
TEST_ASSERT_EQUAL_UINT32(0XDEFEUL, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, " 0666 4294967295 4294967296 12.34");
return 0;
}
/* *
@ -140,6 +143,7 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul004, Function | MediumTe
}
TEST_ASSERT_EQUAL_UINT32(0666UL, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, " 4294967295 4294967296 12.34");
return 0;
}
/* *
@ -159,6 +163,7 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul005, Function | MediumTe
}
TEST_ASSERT_EQUAL_UINT32(4294967295UL, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, " 4294967296 12.34");
return 0;
}
/* *
@ -179,6 +184,7 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul006, Function | MediumTe
TEST_ASSERT_EQUAL_UINT32(ULONG_MAX, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, " 12.34");
return 0;
}
/* *
@ -198,6 +204,7 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul007, Function | MediumTe
}
TEST_ASSERT_EQUAL_UINT32(0UL, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, " 12.34");
return 0;
}
/* *
@ -217,6 +224,7 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul008, Function | MediumTe
}
TEST_ASSERT_EQUAL_UINT32(0UL, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, ".34");
return 0;
}
/**
@ -236,6 +244,7 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul009, Function | MediumTe
}
TEST_ASSERT_EQUAL_UINT32(0XDEFE, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, " 0666");
return 0;
}
/* *
@ -255,6 +264,7 @@ LITE_TEST_CASE(PosixStdlibStrtoulTest, testStdlibStrtoul010, Function | MediumTe
}
TEST_ASSERT_EQUAL_UINT32(0666, ret);
TEST_ASSERT_EQUAL_STRING(endPtr, "");
return 0;
}
RUN_TEST_SUITE(PosixStdlibStrtoulTest);

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

@ -84,6 +84,7 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull001, Function | Medium
}
TEST_ASSERT_TRUE(ret == 12ULL);
TEST_ASSERT_EQUAL_STRING(endPtr, " 0110 0XDEFE 0666 1.6");
return 0;
}
/* *
@ -103,6 +104,7 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull002, Function | Medium
}
TEST_ASSERT_TRUE(ret == 6ULL);
TEST_ASSERT_EQUAL_STRING(endPtr, " 0XDEFE 0666 1.6");
return 0;
}
/* *
@ -122,6 +124,7 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull003, Function | Medium
}
TEST_ASSERT_TRUE(ret == 0XDEFEULL);
TEST_ASSERT_EQUAL_STRING(endPtr, " 0666 1.6");
return 0;
}
/* *
@ -141,6 +144,7 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull004, Function | Medium
}
TEST_ASSERT_TRUE(ret == 0666ULL);
TEST_ASSERT_EQUAL_STRING(endPtr, " 1.6");
return 0;
}
/* *
@ -160,6 +164,7 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull005, Function | Medium
}
TEST_ASSERT_TRUE(ret == 0ULL);
TEST_ASSERT_EQUAL_STRING(endPtr, " 1.6");
return 0;
}
/* *
@ -179,6 +184,7 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull006, Function | Medium
}
TEST_ASSERT_TRUE(ret == 0ULL);
TEST_ASSERT_EQUAL_STRING(endPtr, ".6");
return 0;
}
/* *
@ -198,6 +204,7 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull007, Function | Medium
}
TEST_ASSERT_TRUE(ret == 18446744073709551615ULL);
TEST_ASSERT_EQUAL_STRING(endPtr, " 18446744073709551616");
return 0;
}
/* *
@ -219,6 +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_STRING(endPtr, "");
return 0;
}
/* *
@ -238,6 +246,7 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull009, Function | Medium
}
TEST_ASSERT_TRUE(ret == 0XDEFEULL);
TEST_ASSERT_EQUAL_STRING(endPtr, " 0666");
return 0;
}
/* *
@ -257,6 +266,7 @@ LITE_TEST_CASE(PosixStdlibStrtoullTest, testStdlibStrtoull010, Function | Medium
}
TEST_ASSERT_TRUE(ret == 0666ULL);
TEST_ASSERT_EQUAL_STRING(endPtr, "");
return 0;
}
RUN_TEST_SUITE(PosixStdlibStrtoullTest);

13
testsuites/unittest/posix/src/string/strstr_test.c
View File

@ -80,6 +80,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr001, Function | MediumTest
LOG("[DEMO] posix string test case 1:strstr(%s) %s fail.\n", srcS, destS);
}
TEST_ASSERT_EQUAL_STRING(ret, destS);
return 0;
}
/* *
@ -99,6 +100,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr002, Function | MediumTest
LOG("[DEMO] posix string test case 2:strstr(%s) %s fail.\n", srcS, destS);
}
TEST_ASSERT_EQUAL_STRING(ret, "this is string");
return 0;
}
/* *
@ -118,6 +120,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr003, Function | MediumTest
LOG("[DEMO] posix string test case 3:strstr(%s) %s fail.\n", srcT, dest);
}
TEST_ASSERT_EQUAL_STRING(ret, dest);
return 0;
}
/* *
@ -137,6 +140,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr004, Function | MediumTest
LOG("[DEMO] posix string test case 4(except):strstr(%s) %s fail.\n", src, dest);
}
TEST_ASSERT_NULL(ret);
return 0;
}
/* *
@ -156,6 +160,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr005, Function | MediumTest
LOG("[DEMO] posix string test case 5(except):strstr(%s) %s fail.\n", src, dest);
}
TEST_ASSERT_NULL(ret);
return 0;
}
/* *
@ -175,6 +180,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr006, Function | MediumTest
LOG("[DEMO] posix string test case 6:strstr(%s) %s fail.\n", srcOne, destS);
}
TEST_ASSERT_EQUAL_STRING(ret, "tring this is string");
return 0;
}
/* *
@ -194,6 +200,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr007, Function | MediumTest
LOG("[DEMO] posix string test case 7(except):strstr(%s) %s fail.\n", srcOne, destS);
}
TEST_ASSERT_NULL(ret);
return 0;
}
/* *
@ -213,6 +220,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr008, Function | MediumTest
LOG("[DEMO] posix string test case 8:strstr(%s) %s fail.\n", srcTwo, destS);
}
TEST_ASSERT_EQUAL_STRING(ret, "this is string");
return 0;
}
/* *
@ -232,6 +240,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr009, Function | MediumTest
LOG("[DEMO] posix string test case 9(except):strstr(%s) %s fail.\n", srcTwo2, destS);
}
TEST_ASSERT_NULL(ret);
return 0;
}
/* *
@ -251,6 +260,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr010, Function | MediumTest
LOG("[DEMO] posix string test case 10:strstr(%s) %s fail.\n", srcThree, destS);
}
TEST_ASSERT_EQUAL_STRING(ret, "this is string");
return 0;
}
/* *
@ -270,6 +280,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr011, Function | MediumTest
LOG("[DEMO] posix string test case 11(except):strstr(%s) %s fail.\n", srcThree, destS);
}
TEST_ASSERT_NULL(ret);
return 0;
}
/* *
@ -289,6 +300,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr012, Function | MediumTest
LOG("[DEMO] posix string test case 12:strstr(%s) %s fail.\n", srcFour, destS);
}
TEST_ASSERT_EQUAL_STRING(ret, "this is string");
return 0;
}
/* *
@ -308,6 +320,7 @@ LITE_TEST_CASE(PosixStringStrStrTest, testStringStrStr013, Function | MediumTest
LOG("[DEMO] posix string test case 13(except):strstr(%s) %s fail.\n", srcFour, destS);
}
TEST_ASSERT_NULL(ret);
return 0;
}
RUN_TEST_SUITE(PosixStringStrStrTest);