From 14223733c36a5256fbce6d40801246af7d60a5d9 Mon Sep 17 00:00:00 2001 From: jinye Date: Wed, 4 Sep 2024 16:23:50 +0800 Subject: [PATCH 1/2] commit message --- pwrapic/gtest/RegisterOkCpuTest.cpp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/pwrapic/gtest/RegisterOkCpuTest.cpp b/pwrapic/gtest/RegisterOkCpuTest.cpp index 5030886..7891f41 100644 --- a/pwrapic/gtest/RegisterOkCpuTest.cpp +++ b/pwrapic/gtest/RegisterOkCpuTest.cpp @@ -496,4 +496,12 @@ TEST_F(RegisterOkCpuTest, PWR_CPU_SetFreq_Test_002) TEST_F(RegisterOkCpuTest, PWR_CPU_SetFreq_Test_003) { EXPECT_NE(PWR_SUCCESS, PWR_CPU_SetFreq(NULL, 0)); -} \ No newline at end of file +} + +/* + * if PWR_CPU_FreqGovAttr *govAttr is NULL pointer should return error + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_GetFreqGovAttr_001) +{ + EXPECT_NE(PWR_SUCCESS, PWR_CPU_GetFreqGovAttr(NULL)); +} -- Gitee From c78d6d738c6b13a2124d8ad7f8d2f67d60377d17 Mon Sep 17 00:00:00 2001 From: jinye Date: Mon, 9 Sep 2024 15:07:25 +0800 Subject: [PATCH 2/2] fix the bug of gtest path, add cpu gtest function --- pwrapic/gtest/Common.cpp | 4 +- pwrapic/gtest/RegisterOkCpuTest.cpp | 270 ++++++++++++++++++++++++++++ 2 files changed, 272 insertions(+), 2 deletions(-) diff --git a/pwrapic/gtest/Common.cpp b/pwrapic/gtest/Common.cpp index 6fc0c24..82f1b5d 100644 --- a/pwrapic/gtest/Common.cpp +++ b/pwrapic/gtest/Common.cpp @@ -31,7 +31,7 @@ int StartService(void) std::string pwrapisDir; // 10: length for "gtest_test", keep only the path of file gtestDir = gtestDir.substr(0, gtestDir.length() - 10); - pwrapisDir = gtestDir + "../pwrapis/pwrapis &"; + pwrapisDir = gtestDir + "../../../release/pwrapis/pwrapis &"; ret = system(pwrapisDir.c_str()); if (ret != 0) { printf("StartService failed ret:%d\n", ret); @@ -103,4 +103,4 @@ void EventCallback(const PWR_COM_EventInfo *eventInfo) printf("[Event] Get invalid event.\n"); break; } -} \ No newline at end of file +} diff --git a/pwrapic/gtest/RegisterOkCpuTest.cpp b/pwrapic/gtest/RegisterOkCpuTest.cpp index 7891f41..bd28eea 100644 --- a/pwrapic/gtest/RegisterOkCpuTest.cpp +++ b/pwrapic/gtest/RegisterOkCpuTest.cpp @@ -505,3 +505,273 @@ TEST_F(RegisterOkCpuTest, PWR_CPU_GetFreqGovAttr_001) { EXPECT_NE(PWR_SUCCESS, PWR_CPU_GetFreqGovAttr(NULL)); } + +/* + * set governor as ondemand and attr->key as sampling_rate should return correct + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_GetFreqGovAttr_002) +{ + // set governor as ondemand + char govOndemand[] = "ondemand"; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_SetFreqGovernor(govOndemand)); + char gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetFreqGovernor(gov, PWR_MAX_ELEMENT_NAME_LEN)); + EXPECT_STREQ(govOndemand, gov); + + int len = sizeof(PWR_CPU_FreqGovAttr); + PWR_CPU_FreqGovAttr *govAttr = (PWR_CPU_FreqGovAttr *)malloc(len); + EXPECT_TRUE(govAttr != NULL); + memset(govAttr, 0, len); + strncpy(govAttr->gov, "ondemand", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.key, "sampling_rate", PWR_MAX_ELEMENT_NAME_LEN); + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetFreqGovAttr(govAttr)); + free(govAttr); +} + +/* + * set governor as performance, then get attr of on demand should return error + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_GetFreqGovAttr_003) +{ + // set governor as performance + char govPerformance[] = "performance"; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_SetFreqGovernor(govPerformance)); + char gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetFreqGovernor(gov, PWR_MAX_ELEMENT_NAME_LEN)); + EXPECT_STREQ(govPerformance, gov); + + int len = sizeof(PWR_CPU_FreqGovAttr); + PWR_CPU_FreqGovAttr *govAttr = (PWR_CPU_FreqGovAttr *)malloc(len); + EXPECT_TRUE(govAttr != NULL); + memset(govAttr, 0, len); + strncpy(govAttr->gov, "ondemand", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.key, "sampling_rate", PWR_MAX_ELEMENT_NAME_LEN); + EXPECT_NE(PWR_SUCCESS, PWR_CPU_GetFreqGovAttr(govAttr)); + free(govAttr); +} + +/* + * if attr->key incorrect then should return error + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_GetFreqGovAttr_004) +{ + // set governor as ondemand + char govOndemand[] = "ondemand"; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_SetFreqGovernor(govOndemand)); + char gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetFreqGovernor(gov, PWR_MAX_ELEMENT_NAME_LEN)); + EXPECT_STREQ(govOndemand, gov); + + int len = sizeof(PWR_CPU_FreqGovAttr); + PWR_CPU_FreqGovAttr *govAttr = (PWR_CPU_FreqGovAttr *)malloc(len); + EXPECT_TRUE(govAttr != NULL); + memset(govAttr, 0, len); + strncpy(govAttr->gov, "ondemand", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.key, "fake", PWR_MAX_ELEMENT_NAME_LEN); + EXPECT_NE(PWR_SUCCESS, PWR_CPU_GetFreqGovAttr(govAttr)); + free(govAttr); +} + +/* + * if set govAttr->gov incorrect then should return error + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_GetFreqGovAttr_005) +{ + // set governor as ondemand + char govOndemand[] = "ondemand"; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_SetFreqGovernor(govOndemand)); + char gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetFreqGovernor(gov, PWR_MAX_ELEMENT_NAME_LEN)); + EXPECT_STREQ(govOndemand, gov); + + int len = sizeof(PWR_CPU_FreqGovAttr); + PWR_CPU_FreqGovAttr *govAttr = (PWR_CPU_FreqGovAttr *)malloc(len); + EXPECT_TRUE(govAttr != NULL); + memset(govAttr, 0, len); + strncpy(govAttr->gov, "fake", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.key, "sampling_rate", PWR_MAX_ELEMENT_NAME_LEN); + EXPECT_NE(PWR_SUCCESS, PWR_CPU_GetFreqGovAttr(govAttr)); + free(govAttr); +} + +TEST_F(RegisterOkCpuTest, PWR_CPU_SetFreqGovAttr_001) +{ + EXPECT_NE(PWR_SUCCESS, PWR_CPU_SetFreqGovAttr(NULL)); +} + +/* + * if set attr->value as 9000, then getgovattr should get attr->value as 9000 + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_SetFreqGovAttr_002) +{ + // set governor as ondemand + char govOndemand[] = "ondemand"; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_SetFreqGovernor(govOndemand)); + char gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetFreqGovernor(gov, PWR_MAX_ELEMENT_NAME_LEN)); + EXPECT_STREQ(govOndemand, gov); + + int len = sizeof(PWR_CPU_FreqGovAttr); + PWR_CPU_FreqGovAttr *govAttr = (PWR_CPU_FreqGovAttr *)malloc(len); + EXPECT_TRUE(govAttr != NULL); + memset(govAttr, 0, len); + strncpy(govAttr->gov, "ondemand", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.key, "sampling_rate", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.value, "9000", PWR_MAX_ELEMENT_NAME_LEN); + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_SetFreqGovAttr(govAttr)); + + PWR_CPU_FreqGovAttr *govAttrGet = (PWR_CPU_FreqGovAttr *)malloc(len); + EXPECT_TRUE(govAttrGet != NULL); + strncpy(govAttrGet->gov, "ondemand", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttrGet->attr.key, "sampling_rate", PWR_MAX_ELEMENT_NAME_LEN); + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetFreqGovAttr(govAttrGet)); + EXPECT_STREQ(govAttr->attr.value, govAttrGet->attr.value); + free(govAttr); + free(govAttrGet); +} + +/* + * if gov is not the same as cur gov should return error + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_SetFreqGovAttr_003) +{ + // set governor as performance + char govPerformance[] = "performance"; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_SetFreqGovernor(govPerformance)); + char gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetFreqGovernor(gov, PWR_MAX_ELEMENT_NAME_LEN)); + EXPECT_STREQ(govPerformance, gov); + + int len = sizeof(PWR_CPU_FreqGovAttr); + PWR_CPU_FreqGovAttr *govAttr = (PWR_CPU_FreqGovAttr *)malloc(len); + EXPECT_TRUE(govAttr != NULL); + memset(govAttr, 0, len); + strncpy(govAttr->gov, "ondemand", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.key, "sampling_rate", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.value, "9000", PWR_MAX_ELEMENT_NAME_LEN); + EXPECT_NE(PWR_SUCCESS, PWR_CPU_SetFreqGovAttr(govAttr)); + free(govAttr); +} + +/* + * if attr.key incorrect return error + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_SetFreqGovAttr_004) +{ + // set governor as ondemand + char govOndemand[] = "ondemand"; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_SetFreqGovernor(govOndemand)); + char gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetFreqGovernor(gov, PWR_MAX_ELEMENT_NAME_LEN)); + EXPECT_STREQ(govOndemand, gov); + + int len = sizeof(PWR_CPU_FreqGovAttr); + PWR_CPU_FreqGovAttr *govAttr = (PWR_CPU_FreqGovAttr *)malloc(len); + EXPECT_TRUE(govAttr != NULL); + memset(govAttr, 0, len); + strncpy(govAttr->gov, "ondemand", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.key, "fake", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.value, "9000", PWR_MAX_ELEMENT_NAME_LEN); + EXPECT_NE(PWR_SUCCESS, PWR_CPU_SetFreqGovAttr(govAttr)); + free(govAttr); +} + +/* + * if gov incorrect should return error + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_SetFreqGovAttr_005) +{ + // set governor as ondemand + char govOndemand[] = "ondemand"; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_SetFreqGovernor(govOndemand)); + char gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetFreqGovernor(gov, PWR_MAX_ELEMENT_NAME_LEN)); + EXPECT_STREQ(govOndemand, gov); + + int len = sizeof(PWR_CPU_FreqGovAttr); + PWR_CPU_FreqGovAttr *govAttr = (PWR_CPU_FreqGovAttr *)malloc(len); + EXPECT_TRUE(govAttr != NULL); + memset(govAttr, 0, len); + strncpy(govAttr->gov, "fake", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.key, "sampling_rate", PWR_MAX_ELEMENT_NAME_LEN); + strncpy(govAttr->attr.value, "9000", PWR_MAX_ELEMENT_NAME_LEN); + EXPECT_NE(PWR_SUCCESS, PWR_CPU_SetFreqGovAttr(govAttr)); + free(govAttr); +} + +/* + * info is null should return error + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_GetIdleInfo_001) +{ + EXPECT_NE(PWR_SUCCESS, PWR_CPU_GetIdleInfo(NULL)); +} + +/* + * if idleinfo is not null should return correct + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_GetIdleInfo_002) +{ + size_t size = sizeof(PWR_CPU_IdleInfo) + PWR_MAX_CPU_CSTATE_NUM * sizeof(PWR_CPU_Cstate); + PWR_CPU_IdleInfo *info = (PWR_CPU_IdleInfo *)malloc(size); + EXPECT_TRUE(info != NULL); + info->cstateNum = PWR_MAX_CPU_CSTATE_NUM; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetIdleInfo(NULL)); + free(info); +} + +/* + * if idlegov and size is correct then should return success + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_GetIdleGovernor_001) +{ + char gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + int size = PWR_MAX_ELEMENT_NAME_LEN; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetIdleGovernor(gov, size)); + printf("\t current idle gov: %s\n", gov); +} + +/* + * set idlegovernor should return success + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_SetIdleGovernor_001) +{ + char gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + int size = PWR_MAX_ELEMENT_NAME_LEN; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetIdleGovernor(gov, size)); + printf("\t current idle gov: %s\n", gov); + + gov[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + char govGet[PWR_MAX_ELEMENT_NAME_LEN] = {0}; + strncpy(gov, "teo", PWR_MAX_ELEMENT_NAME_LEN); + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_SetIdleGovernor(gov)); + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_GetIdleGovernor(govGet, size)); + EXPECT_STREQ(gov, govGet); +} + +#define LATENCY_INIT_NUM (-1) +/* + * check if it can return correctly + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_DmaGetLatency_001) +{ + int la = LATENCY_INIT_NUM; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_DmaGetLatency(&la)); + printf("PWR_CPU_DmaGetLatency Latency:%d\n", la); +} + +/* + * set la between 0 and PWR_MAX_CPU_DMA_LATENCY should return success + */ +TEST_F(RegisterOkCpuTest, PWR_CPU_DmaSetLatency_001) +{ + int la = LATENCY_INIT_NUM; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_DmaGetLatency(&la)); + printf("PWR_CPU_DmaGetLatency Latency:%d\n", la); + + la = PWR_MAX_CPU_DMA_LATENCY; + int getLatency = LATENCY_INIT_NUM; + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_DmaSetLatency(la)); + EXPECT_EQ(PWR_SUCCESS, PWR_CPU_DmaGetLatency(&getLatency)); + EXPECT_EQ(la, getLatency); +} -- Gitee