p71924506
/
kernel_liteos_a1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

!504 clock模块内核unittest用例调整 

Merge pull request !504 from phchang/updateclock
This commit is contained in:
openharmony_ci 2021-08-24 02:33:32 +00:00 committed by Gitee
parent 83bff88f7f 555e0681be
commit 45a128a4f0
13 changed files with 164 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
testsuites/unittest/time/clock/BUILD.gn
View File

@ -41,20 +41,18 @@ sources_entry = [
"time_clock_test.cpp",
]
sources_smoke = [
"smoke/clock_test_001.cpp",
"smoke/clock_test_002.cpp",
"smoke/clock_test_003.cpp",
"smoke/clock_test_004.cpp",
"smoke/clock_test_006.cpp",
"smoke/clock_test_007.cpp",
"smoke/clock_test_008.cpp",
"smoke/clock_test_009.cpp",
"smoke/clock_test_011.cpp",
"smoke/clock_test_012.cpp",
]
sources_smoke = [ "smoke/clock_test_smoke.cpp" ]
sources_full = [
"full/clock_test_001.cpp",
"full/clock_test_002.cpp",
"full/clock_test_003.cpp",
"full/clock_test_004.cpp",
"full/clock_test_005.cpp",
"full/clock_test_006.cpp",
"full/clock_test_007.cpp",
"full/clock_test_008.cpp",
"full/clock_test_009.cpp",
"full/clock_test_010.cpp",
]

22
testsuites/unittest/time/clock/smoke/clock_test_001.cpp → testsuites/unittest/time/clock/full/clock_test_001.cpp
View File

@ -45,36 +45,38 @@ static int ClockTest(void)
clockid_t clk = CLOCK_REALTIME;
struct timespec res, tp, oldtp;
int ret;
int passflag = 0;
/* get clock resolution */
ret = clock_getres(clk, &res);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(res.tv_sec, CLOCK_RES_SEC, res.tv_sec);
ICUNIT_ASSERT_EQUAL(res.tv_nsec, CLOCK_RES_NSEC, res.tv_nsec);
/* get current real time */
ret = clock_gettime(clk, &oldtp);
printf("The current real time: sec is %lld, nsec is %ld\n", oldtp.tv_sec, oldtp.tv_nsec);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
printf("sleep 2 seconds\n");
sleep(2); // 2, seconds.
tp.tv_sec = 5 * res.tv_sec; // 5, times the number of seconds.
tp.tv_nsec = 5 * res.tv_nsec; // 5, times the number of nseconds.
tp.tv_sec = oldtp.tv_sec + 2; // 2, use for testing clock setting
tp.tv_nsec = oldtp.tv_nsec;
/* set real time */
ret = clock_settime(clk, &tp);
#if TEST_ON_LINUX
/* on linux host we need root to set clock time */
ICUNIT_ASSERT_EQUAL(ret, -1, ret);
ICUNIT_ASSERT_EQUAL(errno, EPERM, errno);
#else
printf("Setting time: sec is %lld, nsec is %ld\n", tp.tv_sec, tp.tv_nsec);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
#endif
LogPrintln("get real time clock again\n");
printf("get real time clock again\n");
/* get current real time again */
ret = clock_gettime(clk, &tp);
printf("Obtaining the current time after setting: sec = %lld, nsec = %ld\n", tp.tv_sec, tp.tv_nsec);
passflag = (tp.tv_sec >= 2 + oldtp.tv_sec) && (tp.tv_sec <= 2 + oldtp.tv_sec + 1); // 2, use for testing clock setting
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(passflag, true, passflag);
return 0;
}

15
testsuites/unittest/time/clock/smoke/clock_test_011.cpp → testsuites/unittest/time/clock/full/clock_test_002.cpp
View File

@ -46,7 +46,7 @@ static int ThreadClock(const char *msg, clockid_t cid)
ret = clock_gettime(cid, &ts);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
printf("%4jd.%03ld\n", ts.tv_sec, ts.tv_nsec / 1000000); // 1000000, 1ms.
printf("%lld.%03ld s\n", ts.tv_sec, ts.tv_nsec / 1000000); // 1000000, 1ms.
return 0;
}
@ -57,11 +57,6 @@ static int ClockTest(void)
int ret;
struct timespec ts;
/* check param invalid */
ret = clock_gettime(-2050, &ts); // 2050, clock id.
ICUNIT_ASSERT_EQUAL(ret, -1, ret);
ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
ret = pthread_create(&thread, NULL, ThreadFuncTest, 0);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
@ -69,9 +64,7 @@ static int ClockTest(void)
sleep(1);
printf("Main thread consuming some CPU time...\n");
for (int j = 0; j < 4000000; j++) { // 4000000, The loop frequency.
getppid();
}
usleep(400000); // 400000 delay for test
/* get current pthread clockid */
ret = pthread_getcpuclockid(pthread_self(), &clockid);
@ -84,13 +77,13 @@ static int ClockTest(void)
ret = pthread_getcpuclockid(thread, &clockid);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ret = ThreadClock("Subthread CPU time: 1 ", clockid);
ret = ThreadClock("Subthread CPU time: ", clockid);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
return 0;
}
void ClockTest011(void)
void ClockTest002(void)
{
TEST_ADD_CASE(__FUNCTION__, ClockTest, TEST_POSIX, TEST_TIMES, TEST_LEVEL0, TEST_FUNCTION);
}

40
testsuites/unittest/time/clock/smoke/clock_test_012.cpp → testsuites/unittest/time/clock/full/clock_test_003.cpp
View File

@ -35,42 +35,46 @@ static int ClockTest(void)
clockid_t clockid;
struct timespec ts;
int ret;
pid_t pid = 0;
int passflag = 0;
/* check param invalid */
ret = clock_getcpuclockid(0, &clockid);
ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
ret = clock_getcpuclockid(65, &clockid); // 65, pthread id.
ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
/* get user process2 clockid */
ret = clock_getcpuclockid(2, &clockid);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
/* get clockid time */
ret = clock_gettime(clockid, &ts);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
/* get kernel process1 clockid */
/* get kernel process 1 clockid */
pid = 1;
ret = clock_getcpuclockid(1, &clockid);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(clockid, CLOCK_GET_CPU_CLOCKID(pid), clockid);
/* get clockid time */
ret = clock_gettime(clockid, &ts);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
printf("Obtaining the process running time: %lld second, %ld nanosecond\n", ts.tv_sec, ts.tv_nsec);
/* get user process 2 clockid */
pid = 2; // 2, test the process 2 (An existent pid)
ret = clock_getcpuclockid(2, &clockid);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(clockid, CLOCK_GET_CPU_CLOCKID(pid), clockid);
/* get clockid time */
ret = clock_gettime(clockid, &ts);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
printf("Obtaining the process running time: %lld second, %ld nanosecond\n", ts.tv_sec, ts.tv_nsec);
/* get current process clockid */
pid = getpid();
ret = clock_getcpuclockid(getpid(), &clockid);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(clockid, CLOCK_GET_CPU_CLOCKID(pid), clockid);
/* get clockid time */
ret = clock_gettime(clockid, &ts);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
printf("Obtaining the process running time: %lld second, %ld nanosecond\n", ts.tv_sec, ts.tv_nsec);
return 0;
}
void ClockTest012(void)
void ClockTest003(void)
{
TEST_ADD_CASE(__FUNCTION__, ClockTest, TEST_POSIX, TEST_TIMES, TEST_LEVEL0, TEST_FUNCTION);
}
}

18
testsuites/unittest/time/clock/smoke/clock_test_004.cpp → testsuites/unittest/time/clock/full/clock_test_004.cpp
View File

@ -30,24 +30,22 @@
*/
#include "lt_clock_test.h"
static int CpuClockTest(void)
static int ClockTest(void)
{
int pid = 0;
int ret;
pthread_t thread;
clockid_t clockid;
int ret;
struct timespec ts;
/* CLOCK_PROCESS_CPUTIME_ID if pid == 0 */
ret = clock_getcpuclockid(pid, &clockid);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ret = clock_gettime(clockid, &ts);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
/* check param invalid */
ret = clock_gettime(-2050, &ts); // 2050, clock id.
ICUNIT_ASSERT_EQUAL(ret, -1, ret);
ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
return 0;
}
void ClockTest004(void)
{
TEST_ADD_CASE(__FUNCTION__, CpuClockTest, TEST_POSIX, TEST_TIMES, TEST_LEVEL0, TEST_FUNCTION);
TEST_ADD_CASE(__FUNCTION__, ClockTest, TEST_POSIX, TEST_TIMES, TEST_LEVEL0, TEST_FUNCTION);
}

22
testsuites/unittest/time/clock/smoke/clock_test_002.cpp → testsuites/unittest/time/clock/full/clock_test_005.cpp
View File

@ -30,19 +30,25 @@
*/
#include "lt_clock_test.h"
static int ClockMonotonicTest(void)
static int ClockTest(void)
{
clockid_t clk = CLOCK_MONOTONIC;
struct timespec res, ts;
clockid_t clockid;
struct timespec ts;
int ret;
pid_t pid = 0;
ret = clock_gettime(clk, &ts);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
/* check param invalid */
ret = clock_getcpuclockid(pid, &clockid);
ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
pid = 65; // 65, non existent process id.
ret = clock_getcpuclockid(pid, &clockid);
ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
return 0;
}
void ClockTest002(void)
void ClockTest005(void)
{
TEST_ADD_CASE(__FUNCTION__, ClockMonotonicTest, TEST_POSIX, TEST_TIMES, TEST_LEVEL0, TEST_FUNCTION);
}
TEST_ADD_CASE(__FUNCTION__, ClockTest, TEST_POSIX, TEST_TIMES, TEST_LEVEL0, TEST_FUNCTION);
}

16
testsuites/unittest/time/clock/smoke/clock_test_006.cpp → testsuites/unittest/time/clock/full/clock_test_006.cpp
View File

@ -45,31 +45,35 @@ static int ClockTest(void)
clockid_t clk = CLOCK_REALTIME_COARSE;
struct timespec res, tp, oldtp;
int ret;
int passflag = 0;
/* get clock resolution */
ret = clock_getres(clk, &res);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(res.tv_sec, CLOCK_COARSE_RES_SEC, res.tv_sec);
ICUNIT_ASSERT_EQUAL(res.tv_nsec, CLOCK_COARSE_RES_NSEC, res.tv_nsec);
/* get current real coarse time */
ret = clock_gettime(clk, &oldtp);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
printf("The current coarse real time: sec is %lld, nsec is %ld\n", oldtp.tv_sec, oldtp.tv_nsec);
LogPrintln("sleep 2 seconds\n");
sleep(2); // 2, seconds.
tp.tv_sec = 5 * res.tv_sec; // 5, times the number of seconds.
tp.tv_nsec = 5 * res.tv_nsec; // 5, times the number of nseconds.
tp.tv_sec = 5 * oldtp.tv_sec; // 5, times the number of seconds.
tp.tv_nsec = oldtp.tv_nsec; // 5, times the number of nseconds.
/* set real coarse time */
ret = clock_settime(clk, &tp);
ICUNIT_ASSERT_EQUAL(ret, -1, ret);
ICUNIT_ASSERT_EQUAL(errno, EOPNOTSUPP, errno);
LogPrintln("get coarse real time clock again\n");
printf("get coarse real time clock again\n");
/* get current real coarse time again */
ret = clock_gettime(clk, &tp);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
printf("The current coarse real time again: sec is %lld, nsec is %ld\n", tp.tv_sec, tp.tv_nsec);
passflag = (tp.tv_sec >= oldtp.tv_sec) && (tp.tv_sec <= oldtp.tv_sec + 1);
ICUNIT_ASSERT_EQUAL(passflag, 1, passflag);
return 0;
}

15
testsuites/unittest/time/clock/smoke/clock_test_007.cpp → testsuites/unittest/time/clock/full/clock_test_007.cpp
View File

@ -45,31 +45,34 @@ static int ClockTest(void)
clockid_t clk = CLOCK_MONOTONIC_COARSE;
struct timespec res, tp, oldtp;
int ret;
int passflag = 0;
/* get clock resolution */
ret = clock_getres(clk, &res);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(res.tv_sec, CLOCK_COARSE_RES_SEC, res.tv_sec);
ICUNIT_ASSERT_EQUAL(res.tv_nsec, CLOCK_COARSE_RES_NSEC, res.tv_nsec);
/* get current monotonic coarse time */
ret = clock_gettime(clk, &oldtp);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
LogPrintln("sleep 2 seconds\n");
sleep(2); // 2, seconds.
printf("The current monotonic coarse time: sec is %lld, nsec is %ld\n", oldtp.tv_sec, oldtp.tv_nsec);
tp.tv_sec = 5 * res.tv_sec; // 5, times the number of seconds.
tp.tv_nsec = 5 * res.tv_nsec; // 5, times the number of nseconds.
tp.tv_nsec = res.tv_nsec;
/* set monotonic coarse time */
ret = clock_settime(clk, &tp);
ICUNIT_ASSERT_EQUAL(ret, -1, ret);
ICUNIT_ASSERT_EQUAL(errno, EOPNOTSUPP, errno);
LogPrintln("get coarse monotonic time clock again\n");
printf("get coarse monotonic time clock again\n");
/* get current monotonic coarse time again */
ret = clock_gettime(clk, &tp);
passflag = (tp.tv_sec >= oldtp.tv_sec) && (tp.tv_sec <= oldtp.tv_sec + 1);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(passflag, 1, passflag);
printf("The current monotonic coarse time again: sec is %lld, nsec is %ld\n", tp.tv_sec, tp.tv_nsec);
return 0;
}

16
testsuites/unittest/time/clock/smoke/clock_test_008.cpp → testsuites/unittest/time/clock/full/clock_test_008.cpp
View File

@ -34,8 +34,8 @@
#include <time.h>
#include <sys/times.h>
#include <errno.h>
#include "lt_clock_test.h"
#include <osTest.h>
#include "lt_clock_test.h"
/* When clock time is changed, timers for a relative interval are unaffected,
* but timers for an absolute point in time are affected.
@ -45,20 +45,21 @@ static int ClockTest(void)
clockid_t clk = CLOCK_MONOTONIC;
struct timespec res, tp, oldtp;
int ret;
int passflag = 0;
/* get clock resolution */
ret = clock_getres(clk, &res);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(res.tv_sec, CLOCK_RES_SEC, res.tv_sec);
ICUNIT_ASSERT_EQUAL(res.tv_nsec, CLOCK_RES_NSEC, res.tv_nsec);
/* get current monotonic time */
ret = clock_gettime(clk, &oldtp);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
printf("The current monotonic time: sec is %lld, nsec is %ld\n", oldtp.tv_sec, oldtp.tv_nsec);
LogPrintln("sleep 2 seconds\n");
sleep(2); // 2, seconds.
tp.tv_sec = 5 * res.tv_sec; // 5, times the number of seconds.
tp.tv_nsec = 5 * res.tv_nsec; // 5, times the number of nseconds.
tp.tv_sec = 5 * oldtp.tv_sec; // 5, times the number of seconds.
tp.tv_nsec = oldtp.tv_nsec;
/* set real time */
ret = clock_settime(clk, &tp);
@ -69,7 +70,10 @@ static int ClockTest(void)
/* get current monotonic time again */
ret = clock_gettime(clk, &tp);
passflag = (tp.tv_sec >= oldtp.tv_sec) && (tp.tv_sec <= oldtp.tv_sec + 1);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(passflag, 1, passflag);
printf("The current monotonic time: sec is %lld, nsec is %ld\n", tp.tv_sec, tp.tv_nsec);
return 0;
}

14
testsuites/unittest/time/clock/smoke/clock_test_009.cpp → testsuites/unittest/time/clock/full/clock_test_009.cpp
View File

@ -45,31 +45,35 @@ static int ClockTest(void)
clockid_t clk = CLOCK_MONOTONIC_RAW;
struct timespec res, tp, oldtp;
int ret;
int passflag = 0;
/* get clock resolution */
ret = clock_getres(clk, &res);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(res.tv_sec, CLOCK_RES_SEC, res.tv_sec);
ICUNIT_ASSERT_EQUAL(res.tv_nsec, CLOCK_RES_NSEC, res.tv_nsec);
/* get current monotonic raw time */
ret = clock_gettime(clk, &oldtp);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
LogPrintln("sleep 2 seconds\n");
sleep(2); // 2, seconds.
printf("The current monotonic raw time: sec is %lld, nsec is %ld\n", oldtp.tv_sec, oldtp.tv_nsec);
tp.tv_sec = 5 * res.tv_sec; // 5, times the number of seconds.
tp.tv_nsec = 5 * res.tv_nsec; // 5, times the number of nseconds.
tp.tv_nsec = res.tv_nsec;
/* set monotonic raw time */
ret = clock_settime(clk, &tp);
ICUNIT_ASSERT_EQUAL(ret, -1, ret);
ICUNIT_ASSERT_EQUAL(errno, EOPNOTSUPP, errno);
LogPrintln("get monotonic raw time clock again\n");
printf("get monotonic raw time clock again\n");
/* get current monotonic raw time again */
ret = clock_gettime(clk, &tp);
passflag = (tp.tv_sec >= oldtp.tv_sec) && (tp.tv_sec <= oldtp.tv_sec + 1);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(passflag, 1, passflag);
printf("The current monotonic raw time again: sec is %lld, nsec is %ld\n", tp.tv_sec, tp.tv_nsec);
return 0;
}

9
testsuites/unittest/time/clock/lt_clock_test.h
View File

@ -37,6 +37,13 @@
#include <sys/times.h>
#include "osTest.h"
#define CLOCK_RES_SEC 0
#define CLOCK_RES_NSEC 1000
#define CLOCK_COARSE_RES_SEC 0
#define CLOCK_COARSE_RES_NSEC 1000000
#define CLOCK_GET_CPU_CLOCKID(pid) ((-pid - 1) * 8U + 2)
void ClockTestSmoke(void);
void ClockTest001(void);
void ClockTest002(void);
void ClockTest003(void);
@ -47,7 +54,5 @@ void ClockTest007(void);
void ClockTest008(void);
void ClockTest009(void);
void ClockTest010(void);
void ClockTest011(void);
void ClockTest012(void);
#endif /* TIME_CLOCK_LT_CLOCK_TEST_H_ */

48
testsuites/unittest/time/clock/smoke/clock_test_003.cpp → testsuites/unittest/time/clock/smoke/clock_test_smoke.cpp
View File

@ -28,38 +28,42 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <sys/times.h>
#include "lt_clock_test.h"
#include <osTest.h>
static int ClockCoarseTest(void)
static int ClockSmokeTest(void)
{
clockid_t clk = CLOCK_REALTIME_COARSE;
struct timespec res, realts, monots;
clockid_t clk = CLOCK_REALTIME;
struct timespec res = {0,0}, setts = {0,0}, oldtp = {0,0}, ts = {0,0};
int ret;
int passflag = 0;
ret = clock_gettime(clk, &realts);
/* get clock resolution */
ret = clock_getres(clk, &res);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(res.tv_sec, CLOCK_RES_SEC, res.tv_sec);
ICUNIT_ASSERT_EQUAL(res.tv_nsec, CLOCK_RES_NSEC, res.tv_nsec);
/* get clock realtime */
ret = clock_gettime(clk, &oldtp);
printf("the clock current time: %lld second, %ld nanosecond\n", oldtp.tv_sec, oldtp.tv_nsec);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
LogPrintln("sleep 2 seconds\n");
sleep(2); // 2, seconds.
LogPrintln("get real coarse time again\n");
ret = clock_gettime(clk, &realts);
/* set clock realtime */
setts.tv_sec = oldtp.tv_sec + 1;
setts.tv_nsec = oldtp.tv_nsec;
printf("the clock setting time: %lld second, %ld nanosecond\n", setts.tv_sec, setts.tv_nsec);
ret = clock_settime(CLOCK_REALTIME, &setts);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
clk = CLOCK_MONOTONIC_COARSE;
ret = clock_gettime(clk, &monots);
ret = clock_gettime(clk, &ts);
printf("obtaining the current time after setting: %lld second, %ld nanosecond\n", ts.tv_sec, ts.tv_nsec);
passflag = (ts.tv_sec >= setts.tv_sec) && (ts.tv_sec <= setts.tv_sec + 1); // 1, means obtaining time's errno is 1 second.
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_EQUAL(passflag, true, passflag);
return 0;
}
void ClockTest003(void)
void ClockTestSmoke(void)
{
TEST_ADD_CASE(__FUNCTION__, ClockCoarseTest, TEST_POSIX, TEST_TIMES, TEST_LEVEL0, TEST_FUNCTION);
}
TEST_ADD_CASE(__FUNCTION__, ClockSmokeTest, TEST_POSIX, TEST_TIMES, TEST_LEVEL0, TEST_FUNCTION);
}

49
testsuites/unittest/time/clock/time_clock_test.cpp
View File

@ -43,6 +43,19 @@ public:
};
#if defined(LOSCFG_USER_TEST_SMOKE)
/* *
* @tc.name: ClockTestSmoke
* @tc.desc: function for TimeClockTest
* @tc.type: FUNC
* @tc.require: AR000EEMQ9
*/
HWTEST_F(TimeClockTest, ClockTestSmoke, TestSize.Level0)
{
ClockTestSmoke();
}
#endif
#if defined(LOSCFG_USER_TEST_FULL)
/* *
* @tc.name: ClockTest001
* @tc.desc: function for TimeClockTest
@ -76,7 +89,6 @@ HWTEST_F(TimeClockTest, ClockTest003, TestSize.Level0)
ClockTest003();
}
#if TEST_ON_LINUX
/* *
* @tc.name: ClockTest004
* @tc.desc: function for TimeClockTest
@ -88,7 +100,16 @@ HWTEST_F(TimeClockTest, ClockTest004, TestSize.Level0)
ClockTest004(); // clock_getcpuclockid not supported on HMOS currently
}
#endif
/* *
* @tc.name: ClockTest005
* @tc.desc: function for TimeClockTest
* @tc.type: FUNC
* @tc.require: AR000EEMQ9
*/
HWTEST_F(TimeClockTest, ClockTest005, TestSize.Level0)
{
ClockTest005();
}
/* *
* @tc.name: ClockTest006
@ -133,9 +154,7 @@ HWTEST_F(TimeClockTest, ClockTest009, TestSize.Level0)
{
ClockTest009();
}
#endif
#if defined(LOSCFG_USER_TEST_FULL)
/* *
* @tc.name: ClockTest010
* @tc.desc: function for TimeClockTest
@ -147,27 +166,5 @@ HWTEST_F(TimeClockTest, ClockTest010, TestSize.Level0)
ClockTest010();
}
/* *
* @tc.name: ClockTest011
* @tc.desc: test pthread_getcpuclockid:get pthread time
* @tc.type: FUNC
* @tc.require: AR000E0QAB
*/
HWTEST_F(TimeClockTest, ClockTest011, TestSize.Level0)
{
ClockTest011();
}
/* *
* @tc.name: ClockTest012
* @tc.desc: test clock_getcpuclockid:get process time
* @tc.type: FUNC
* @tc.require: AR000E0QAB
*/
HWTEST_F(TimeClockTest, ClockTest012, TestSize.Level0)
{
ClockTest012();
}
#endif
} // namespace OHOS