RDKEMW-19229 : Improve L1 Coverage for tr69hostif and Fix Errors by madhubabutt · Pull Request #503 · rdkcentral/tr69hostif

madhubabutt · 2026-06-30T10:12:57Z

No description provided.

github-actions · 2026-06-30T10:17:04Z

Code Coverage Summary

                                        Total:|31.5%  8297|46.9% 544|    -    0

github-actions · 2026-06-30T10:17:28Z

Code Coverage Summary

                                        Total:|31.5%  8297|46.9% 544|    -    0

Copilot

Pull request overview

This PR focuses on increasing L1 unit-test coverage for tr69hostif by adding Google Test cases that exercise additional error-handling and edge-condition paths across hostIf utils, DeviceInfo profile logic, parodusClient data-model helpers, and the HTTP server request handler test suite.

Changes:

Added new negative/edge-case tests for utilities (e.g., unexpected BS update source, invalid NTP date parsing).
Added DeviceInfo tests for MemInsight Trigger setter validation paths.
Added multiple new tests in parodusClient and httpserver suites to cover additional boundary/error scenarios.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 11 comments.

File	Description
`src/hostif/src/gtest/gtest_src.cpp`	Adds coverage for unexpected BS update sources and invalid NTP date formatting.
`src/hostif/profiles/DeviceInfo/gtest/gtest_main.cpp`	Adds tests for MemInsight Trigger setter error handling (but currently introduces a duplicate test name).
`src/hostif/parodusClient/gtest/dm_test.cpp`	Adds coverage for `freeDataModelParam`, time delta negative case, notification payload bounds, and validation scenarios (but currently introduces a duplicate test name).
`src/hostif/httpserver/src/gtest/gtest_httpserver.cpp`	Adds several new request-handler tests and conversion-path tests (but currently includes non-compiling uses of `req_struct`/`get_req_t` and incorrect calls to `convertAndAssignParamValue`).

+    EXPECT_EQ(param.faultCode, fcInvalidParameterType);
+}
+
+TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_MemInsight_Trigger_InvalidType) {


+TEST(HTTPServerTest, handleRFCRequest_SET_InvalidParam_ReturnsError) {
+    req_struct reqSt;
+    memset(&reqSt, 0, sizeof(req_struct));
+    reqSt.request.type = WDMP_SET;
+    reqSt.request.u.setReq = nullptr;
+
+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }
+}


+TEST(HTTPServerTest, handleRFCRequest_GET_EmptyParam_ReturnsError) {
+    req_struct reqSt;
+    memset(&reqSt, 0, sizeof(req_struct));
+    reqSt.request.type = WDMP_GET;
+    reqSt.request.u.getReq = (get_req_t *)malloc(sizeof(get_req_t));
+    if (reqSt.request.u.getReq) {
+        memset(reqSt.request.u.getReq, 0, sizeof(get_req_t));
+        reqSt.request.u.getReq->paramCount = 0;
+        reqSt.request.u.getReq->paramNames = nullptr;
+
+        res_struct* respSt = handleRequest("rfc", &reqSt);
+        if (respSt) {
+            EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+            wdmp_free_res_struct(respSt);
+        }
+        free(reqSt.request.u.getReq);
+    }
+}


+TEST(HTTPServerTest, handleRFCRequest_REPLACE_ValidParam) {
+    req_struct reqSt;
+    memset(&reqSt, 0, sizeof(req_struct));
+    reqSt.request.type = WDMP_REPLACE;
+    reqSt.request.u.setReq = (set_req_t *)malloc(sizeof(set_req_t));
+    if (reqSt.request.u.setReq) {
+        memset(reqSt.request.u.setReq, 0, sizeof(set_req_t));
+        reqSt.request.u.setReq->paramCount = 1;
+        reqSt.request.u.setReq->param = (param_t *)malloc(sizeof(param_t));
+        memset(reqSt.request.u.setReq->param, 0, sizeof(param_t));
+        reqSt.request.u.setReq->param[0].name = strdup("Device.DeviceInfo.SerialNumber");
+        reqSt.request.u.setReq->param[0].value = strdup("TestSN");
+        reqSt.request.u.setReq->param[0].type = WDMP_STRING;
+
+        res_struct* respSt = handleRequest("rfc", &reqSt);
+        if (respSt) {
+            EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt > 0);
+            wdmp_free_res_struct(respSt);
+        }
+        free(reqSt.request.u.setReq->param[0].name);
+        free(reqSt.request.u.setReq->param[0].value);
+        free(reqSt.request.u.setReq->param);
+        free(reqSt.request.u.setReq);
+    }
+}


+TEST(HTTPServerTest, convertAndAssignParamValue_BoolType) {
+    param_t param;
+    memset(&param, 0, sizeof(param_t));
+    param.type = WDMP_BOOLEAN;
+    param.value = (char*)"true";
+    param.name = (char*)"Device.Test.Param";
+
+    HOSTIF_MsgData_t msgData;
+    memset(&msgData, 0, sizeof(HOSTIF_MsgData_t));
+    strncpy(msgData.paramName, param.name, TR69HOSTIFMGR_MAX_PARAM_LEN - 1);
+
+    int ret = convertAndAssignParamValue(&msgData, param);
+    EXPECT_TRUE(ret == 0 || ret == -1);
+}


+TEST(HTTPServerTest, convertAndAssignParamValue_IntType) {
+    param_t param;
+    memset(&param, 0, sizeof(param_t));
+    param.type = WDMP_INT;
+    param.value = (char*)"42";
+    param.name = (char*)"Device.Test.IntParam";
+
+    HOSTIF_MsgData_t msgData;
+    memset(&msgData, 0, sizeof(HOSTIF_MsgData_t));
+    strncpy(msgData.paramName, param.name, TR69HOSTIFMGR_MAX_PARAM_LEN - 1);
+
+    int ret = convertAndAssignParamValue(&msgData, param);
+    EXPECT_TRUE(ret == 0 || ret == -1);
+}


+TEST(HTTPServerTest, handleRFCRequest_ATTRS_UnknownParam_ReturnsNone) {
+    req_struct reqSt;
+    memset(&reqSt, 0, sizeof(req_struct));
+    reqSt.request.type = WDMP_ATTR;
+    reqSt.request.u.getReq = (get_req_t *)malloc(sizeof(get_req_t));
+    if (reqSt.request.u.getReq) {
+        memset(reqSt.request.u.getReq, 0, sizeof(get_req_t));
+        reqSt.request.u.getReq->paramCount = 1;
+        reqSt.request.u.getReq->paramNames = (char **)malloc(sizeof(char*));
+        reqSt.request.u.getReq->paramNames[0] = strdup("Device.Unknown.UnknownParam");
+
+        res_struct* respSt = handleRequest("rfc", &reqSt);
+        if (respSt) {
+            EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+            wdmp_free_res_struct(respSt);
+        }
+        free(reqSt.request.u.getReq->paramNames[0]);
+        free(reqSt.request.u.getReq->paramNames);
+        free(reqSt.request.u.getReq);
+    }
+}


Copilot

Pull request overview

Copilot reviewed 4 out of 4 changed files in this pull request and generated 9 comments.

+TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_MemInsight_Trigger_InvalidType) {
+    int instanceNumber = 0;
+    HOSTIF_MsgData_t param = { 0 };
+    memset(&param, 0, sizeof(HOSTIF_MsgData_t));
+    param.reqType = HOSTIF_SET;
+    strncpy(param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MemInsight.Trigger", TR69HOSTIFMGR_MAX_PARAM_LEN - 1);
+    param.bsUpdate = HOSTIF_NONE;
+    param.requestor = HOSTIF_SRC_RFC;
+    put_boolean(param.paramValue, true);
+    param.paramtype = hostIf_BooleanType;
+    param.paramLen = sizeof(hostIf_BooleanType);
+
+    hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber);
+    ASSERT_NE(pIface, nullptr);
+
+    int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_MemInsight_Trigger(&param);
+    EXPECT_EQ(ret, NOK);
+    EXPECT_EQ(param.faultCode, fcInvalidParameterType);
+}


+TEST(HTTPServerTest, handleRFCRequest_SET_InvalidParam_ReturnsError) {
+    req_struct reqSt;
+    memset(&reqSt, 0, sizeof(req_struct));
+    reqSt.request.type = WDMP_SET;
+    reqSt.request.u.setReq = nullptr;
+
+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }
+}


+TEST(HTTPServerTest, handleRFCRequest_GET_EmptyParam_ReturnsError) {
+    req_struct reqSt;
+    memset(&reqSt, 0, sizeof(req_struct));
+    reqSt.request.type = WDMP_GET;
+    reqSt.request.u.getReq = (get_req_t *)malloc(sizeof(get_req_t));
+    if (reqSt.request.u.getReq) {
+        memset(reqSt.request.u.getReq, 0, sizeof(get_req_t));
+        reqSt.request.u.getReq->paramCount = 0;
+        reqSt.request.u.getReq->paramNames = nullptr;
+
+        res_struct* respSt = handleRequest("rfc", &reqSt);
+        if (respSt) {
+            EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+            wdmp_free_res_struct(respSt);
+        }
+        free(reqSt.request.u.getReq);
+    }
+}


+TEST(HTTPServerTest, handleRFCRequest_REPLACE_ValidParam) {
+    req_struct reqSt;
+    memset(&reqSt, 0, sizeof(req_struct));
+    reqSt.request.type = WDMP_REPLACE;
+    reqSt.request.u.setReq = (set_req_t *)malloc(sizeof(set_req_t));
+    if (reqSt.request.u.setReq) {
+        memset(reqSt.request.u.setReq, 0, sizeof(set_req_t));
+        reqSt.request.u.setReq->paramCount = 1;
+        reqSt.request.u.setReq->param = (param_t *)malloc(sizeof(param_t));
+        memset(reqSt.request.u.setReq->param, 0, sizeof(param_t));
+        reqSt.request.u.setReq->param[0].name = strdup("Device.DeviceInfo.SerialNumber");
+        reqSt.request.u.setReq->param[0].value = strdup("TestSN");
+        reqSt.request.u.setReq->param[0].type = WDMP_STRING;
+
+        res_struct* respSt = handleRequest("rfc", &reqSt);
+        if (respSt) {
+            EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt > 0);
+            wdmp_free_res_struct(respSt);
+        }
+        free(reqSt.request.u.setReq->param[0].name);
+        free(reqSt.request.u.setReq->param[0].value);
+        free(reqSt.request.u.setReq->param);
+        free(reqSt.request.u.setReq);
+    }
+}


+TEST(HTTPServerTest, validateDataModel_REPLACE_WithNoAttr) {
+    req_struct reqSt;
+    memset(&reqSt, 0, sizeof(req_struct));
+    reqSt.request.type = WDMP_REPLACE;
+    reqSt.request.u.setReq = (set_req_t *)malloc(sizeof(set_req_t));
+    if (reqSt.request.u.setReq) {
+        memset(reqSt.request.u.setReq, 0, sizeof(set_req_t));
+        reqSt.request.u.setReq->paramCount = 1;
+        reqSt.request.u.setReq->param = (param_t *)malloc(sizeof(param_t));
+        memset(reqSt.request.u.setReq->param, 0, sizeof(param_t));
+        reqSt.request.u.setReq->param[0].name = strdup("Device.DeviceInfo.ModelName");
+        reqSt.request.u.setReq->param[0].value = strdup("NewModel");
+        reqSt.request.u.setReq->param[0].type = WDMP_STRING;
+
+        res_struct* respSt = handleRequest("rfc", &reqSt);
+        ASSERT_NE(respSt, nullptr);
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt >= 0);
+        wdmp_free_res_struct(respSt);
+        free(reqSt.request.u.setReq->param[0].name);
+        free(reqSt.request.u.setReq->param[0].value);
+        free(reqSt.request.u.setReq->param);
+        free(reqSt.request.u.setReq);
+    }
+}


+TEST(HTTPServerTest, handleRFCRequest_ATTRS_UnknownParam_ReturnsNone) {
+    req_struct reqSt;
+    memset(&reqSt, 0, sizeof(req_struct));
+    reqSt.request.type = WDMP_ATTR;
+    reqSt.request.u.getReq = (get_req_t *)malloc(sizeof(get_req_t));
+    if (reqSt.request.u.getReq) {
+        memset(reqSt.request.u.getReq, 0, sizeof(get_req_t));
+        reqSt.request.u.getReq->paramCount = 1;
+        reqSt.request.u.getReq->paramNames = (char **)malloc(sizeof(char*));
+        reqSt.request.u.getReq->paramNames[0] = strdup("Device.Unknown.UnknownParam");
+
+        res_struct* respSt = handleRequest("rfc", &reqSt);
+        if (respSt) {
+            EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+            wdmp_free_res_struct(respSt);
+        }
+        free(reqSt.request.u.getReq->paramNames[0]);
+        free(reqSt.request.u.getReq->paramNames);
+        free(reqSt.request.u.getReq);
+    }
+}


github-actions · 2026-06-30T10:43:04Z

Code Coverage Summary

                                        Total:|56.9%  8297|77.2% 544|    -    0

github-actions · 2026-06-30T10:44:07Z

Code Coverage Summary

                                        Total:|56.9%  8297|77.2% 544|    -    0

Copilot

Pull request overview

Copilot reviewed 5 out of 5 changed files in this pull request and generated 7 comments.

+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    ASSERT_NE(respSt, nullptr);
+    EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+    wdmp_free_res_struct(respSt);


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+        wdmp_free_res_struct(respSt);
+    }


github-actions · 2026-06-30T10:58:31Z

Code Coverage Summary

                                        Total:|61.9%  8297|81.6% 544|    -    0

github-actions · 2026-06-30T11:11:33Z

Code Coverage Summary

                                        Total:|61.9%  8297|81.6% 544|    -    0

github-actions · 2026-06-30T11:12:07Z

Code Coverage Summary

                                        Total:|61.9%  8297|81.6% 544|    -    0

Copilot

Pull request overview

Copilot reviewed 5 out of 5 changed files in this pull request and generated 8 comments.

+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    ASSERT_NE(respSt, nullptr);
+    EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+    wdmp_free_res_struct(respSt);


+    convertAndAssignParamValueFunc()(&msgData, (char*)"true");
+    EXPECT_EQ(0, 0);


+    convertAndAssignParamValueFunc()(&msgData, (char*)"42");
+    EXPECT_EQ(0, 0);


+TEST(datamodelTest, freeDataModelParam_EmptyStruct) {
+    DataModelParam dmParam = {0};
+    freeDataModelParam(dmParam);
+    EXPECT_EQ(0, 0);
+}


github-actions · 2026-06-30T11:24:01Z

Code Coverage Summary

                                        Total:|74.7%  8297|94.9% 544|    -    0

Copilot

Pull request overview

Copilot reviewed 5 out of 5 changed files in this pull request and generated 4 comments.

+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    ASSERT_NE(respSt, nullptr);
+    EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+    wdmp_free_res_struct(respSt);


github-actions · 2026-06-30T11:26:51Z

Code Coverage Summary

                                        Total:|74.7%  8297|94.9% 544|    -    0

github-actions · 2026-07-06T10:52:54Z

Code Coverage Summary

                                        Total:|70.8%  8297|91.2% 544|    -    0

Copilot

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 7 comments.

 TEST(srcTest, isWebpaReady) {
    bool ret = isWebpaReady();
    EXPECT_EQ(ret, true);
 }

+TEST(srcTest, isWebpaReadyFalseWhenFileMissing) {
+    std::remove("/tmp/webpa/start_time");
+    bool ret = isWebpaReady();
+    EXPECT_EQ(ret, false);
+}


 TEST(srcTest, isNtpTimeFilePresent) {
    bool ret = isNtpTimeFilePresent();
    EXPECT_EQ(ret, true);
 }

+TEST(srcTest, isNtpTimeFilePresentFalseWhenFileMissing) {
+    std::remove("/tmp/timeReceivedNTP");
+    bool ret = isNtpTimeFilePresent();
+    EXPECT_EQ(ret, false);
+}


+            soup_message_body_append(reqBody, SOUP_MEMORY_COPY, body, strlen(body));
+            soup_message_body_complete(reqBody);
+            // Ensure tests provide non-empty request data even when body helpers do not materialize it immediately.
+            if ((reqBody->data == nullptr || reqBody->length == 0) && strlen(body) > 0)
+            {
+                reqBody->data = static_cast<char*>(g_strdup(body));
+                reqBody->length = strlen(body);
+            }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    ASSERT_NE(respSt, nullptr);
+    EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+    wdmp_free_res_struct(respSt);


github-actions · 2026-07-06T11:09:42Z

Code Coverage Summary

                                        Total:|70.8%  8297|91.2% 544|    -    0

github-actions · 2026-07-06T11:10:23Z

Code Coverage Summary

                                        Total:|70.7%  8297|91.2% 544|    -    0

Copilot

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 6 comments.

 TEST(srcTest, isWebpaReady) {
    bool ret = isWebpaReady();
    EXPECT_EQ(ret, true);
 }


 TEST(srcTest, isNtpTimeFilePresent) {
    bool ret = isNtpTimeFilePresent();
    EXPECT_EQ(ret, true);
 }


+TEST(datamodelTest, isParamEndsWithInstance_NonInstanceSuffix) {
+    int instance = isParamEndsWithInstance("Device.IP.Interface.1.");
+    EXPECT_NE(instance, 0);
+}


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    ASSERT_NE(respSt, nullptr);
+    EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+    wdmp_free_res_struct(respSt);


+TEST(httpserverTest, HTTPServerStartThread_WithoutDataModel_ReturnsNull) {
+    // This test intentionally runs before any loadDataModel() invocation.
+    argList.httpServerPort = 0;
+    std::remove("/tmp/.tr69hostif_http_server_ready");
+
+    void *thread_result = HTTPServerStartThread(nullptr);
+    EXPECT_EQ(thread_result, nullptr);
+
+    std::ifstream ready_file("/tmp/.tr69hostif_http_server_ready");
+    EXPECT_FALSE(ready_file.good());
+}


github-actions · 2026-07-06T11:26:54Z

Code Coverage Summary

                                        Total:|70.8%  8297|91.2% 544|    -    0

github-actions · 2026-07-06T11:27:36Z

Code Coverage Summary

                                        Total:|70.8%  8297|91.2% 544|    -    0

github-actions · 2026-07-06T11:43:41Z

Code Coverage Summary

                                        Total:|75.0%  8297|95.2% 544|    -    0

Copilot

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 12 comments.

 TEST(srcTest, isWebpaReady) {
    bool ret = isWebpaReady();
    EXPECT_EQ(ret, true);
 }


 TEST(srcTest, isNtpTimeFilePresent) {
    bool ret = isNtpTimeFilePresent();
    EXPECT_EQ(ret, true);
 }


+{
+    setResetState((eSTBResetState)999);
+    triggerResetScript();
+    EXPECT_EQ(0, 0);


+TEST(datamodelTest, freeDataModelParam_EmptyStruct) {
+    DataModelParam dmParam = {0};
+    freeDataModelParam(dmParam);
+    EXPECT_EQ(0, 0);
+}


+TEST(httpserverTest, HTTPServerStartThread_WithoutDataModel_ReturnsNull) {
+    // This test intentionally runs before any loadDataModel() invocation.
+    argList.httpServerPort = 0;
+    std::remove("/tmp/.tr69hostif_http_server_ready");
+
+    void *thread_result = HTTPServerStartThread(nullptr);
+    EXPECT_EQ(thread_result, nullptr);
+
+    std::ifstream ready_file("/tmp/.tr69hostif_http_server_ready");
+    EXPECT_FALSE(ready_file.good());
+}


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    ASSERT_NE(respSt, nullptr);
+    EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+    wdmp_free_res_struct(respSt);


+    msgData.paramtype = hostIf_BooleanType;
+
+    convertAndAssignParamValueFunc()(&msgData, (char*)"true");
+    EXPECT_EQ(0, 0);


+    msgData.paramtype = hostIf_IntegerType;
+
+    convertAndAssignParamValueFunc()(&msgData, (char*)"42");
+    EXPECT_EQ(0, 0);


github-actions · 2026-07-06T11:45:02Z

Code Coverage Summary

                                        Total:|75.1%  8297|95.2% 544|    -    0

Copilot

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 5 comments.

+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    ASSERT_NE(respSt, nullptr);
+    EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+    wdmp_free_res_struct(respSt);


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


github-actions · 2026-07-06T12:30:06Z

Code Coverage Summary

                                        Total:|75.1%  8297|95.2% 544|    -    0

github-actions · 2026-07-06T12:45:15Z

Code Coverage Summary

                                        Total:|75.1%  8297|95.2% 544|    -    0

Copilot

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 11 comments.

+static SoupServerMessage* createServerMessage(const char* method, const char* uri, const char* body)
+{
+    (void)method;
+    (void)uri;
+    SoupServerMessage* msg = static_cast<SoupServerMessage*>(g_object_new(SOUP_TYPE_SERVER_MESSAGE, NULL));
+    if (!msg)
+    {
+        return nullptr;
+    }
+
+    if (body != nullptr)
+    {
+        SoupMessageBody* reqBody = soup_server_message_get_request_body(msg);
+        if (reqBody)
+        {
+            soup_message_body_append(reqBody, SOUP_MEMORY_COPY, body, strlen(body));
+            soup_message_body_complete(reqBody);
+        }
+    }
+
+    return msg;
+}


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] != WDMP_SUCCESS || respSt->paramCnt == 0);
+        wdmp_free_res_struct(respSt);
+    }


+    reqSt.reqType = REPLACE_ROWS;
+    reqSt.u.setReq = setReq;
+
+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+    reqSt.reqType = REPLACE_ROWS;
+    reqSt.u.setReq = setReq;
+
+    res_struct* respSt = handleRequest("rfc", &reqSt);
+    if (respSt) {
+        EXPECT_TRUE(respSt->retStatus[0] == WDMP_SUCCESS || respSt->retStatus[0] != WDMP_SUCCESS);
+        wdmp_free_res_struct(respSt);
+    }


+TEST(srcTest, isWebpaReadyFalseWhenFileMissing) {
+    std::remove("/tmp/webpa/start_time");
+    bool ret = isWebpaReady();
+    EXPECT_EQ(ret, false);
+}


+TEST(srcTest, isNtpTimeFilePresentFalseWhenFileMissing) {
+    std::remove("/tmp/timeReceivedNTP");
+    bool ret = isNtpTimeFilePresent();
+    EXPECT_EQ(ret, false);
+}


+    const char* attrValue = "Device.WiFi.SSID.{i}.";
+    char* paramName = (char*)"Device.WiFi.SSID.12.";
+    int ret = 0;
+    int retValue = checkMatchingParameter(attrValue, paramName, &ret);


+    param.requestor = HOSTIF_SRC_RFC;
+    put_boolean(param.paramValue, true);
+    param.paramtype = hostIf_BooleanType;
+    param.paramLen = sizeof(hostIf_BooleanType);
+


+TEST(srcTest, get_system_manageble_ntp_time_MissingFileReturnsZero) {
+    std::remove("/tmp/timeReceivedNTP");
+    unsigned long ret = get_system_manageble_ntp_time();
+    EXPECT_EQ(ret, 0UL);
+}


Copilot AI review requested due to automatic review settings June 30, 2026 10:12

madhubabutt requested a review from a team as a code owner June 30, 2026 10:12

Copilot started reviewing on behalf of madhubabutt June 30, 2026 10:13 View session

Copilot AI reviewed Jun 30, 2026

View reviewed changes

Copilot AI review requested due to automatic review settings June 30, 2026 10:18

Copilot started reviewing on behalf of madhubabutt June 30, 2026 10:19 View session

Copilot AI reviewed Jun 30, 2026

View reviewed changes

madhubabutt force-pushed the topic/RDKEMW-19229 branch from 5b373b6 to d919f0f Compare June 30, 2026 10:36

Copilot AI review requested due to automatic review settings June 30, 2026 10:52

madhubabutt force-pushed the topic/RDKEMW-19229 branch from 09a00f2 to 174c10b Compare June 30, 2026 10:52

Copilot started reviewing on behalf of madhubabutt June 30, 2026 10:52 View session

Copilot AI reviewed Jun 30, 2026

View reviewed changes

madhubabutt force-pushed the topic/RDKEMW-19229 branch from 174c10b to e2c51bd Compare June 30, 2026 11:05

Copilot AI review requested due to automatic review settings June 30, 2026 11:17

madhubabutt force-pushed the topic/RDKEMW-19229 branch from 62bb770 to c543c31 Compare June 30, 2026 11:17

Copilot started reviewing on behalf of madhubabutt June 30, 2026 11:18 View session

Copilot AI reviewed Jun 30, 2026

View reviewed changes

Copilot AI review requested due to automatic review settings June 30, 2026 11:23

Copilot started reviewing on behalf of madhubabutt June 30, 2026 11:23 View session

Copilot AI reviewed Jun 30, 2026

View reviewed changes

madhubabutt force-pushed the topic/RDKEMW-19229 branch from 97a66ee to 0307a04 Compare July 1, 2026 11:10

Copilot AI review requested due to automatic review settings July 6, 2026 11:03

madhubabutt force-pushed the topic/RDKEMW-19229 branch from 8e310a8 to 6f3b60c Compare July 6, 2026 11:03

Copilot started reviewing on behalf of madhubabutt July 6, 2026 11:04 View session