From 03732462432c422dd79c192e8f89617700dc96ad Mon Sep 17 00:00:00 2001 From: madhubabutt <114217841+madhubabutt@users.noreply.github.com> Date: Fri, 26 Sep 2025 22:05:33 +0530 Subject: [PATCH] RDK-58962 [ tr69hostif ] : L1 Functional Coverage from 56% to 75-80% (#252) Co-authored-by: mtirum011 --- cov_build.sh | 4 +- run_ut.sh | 31 +- src/configure.ac | 1 + .../include/hostIf_rbus_Dml_Provider.h | 11 + src/hostif/handlers/src/gtest/Makefile.am | 39 + .../handlers/src/gtest/handlers_test.cpp | 1530 ++++++++++ .../handlers/src/hostIf_rbus_Dml_Provider.cpp | 7 + .../httpserver/include/XrdkCentralComRFCVar.h | 1 + src/hostif/httpserver/src/gtest/Makefile.am | 17 +- .../httpserver/src/gtest/gtest_httpserver.cpp | 333 ++ src/hostif/httpserver/src/http_server.cpp | 12 + src/hostif/httpserver/src/request_handler.cpp | 10 + src/hostif/include/IniFile.h | 8 + src/hostif/parodusClient/gtest/Makefile.am | 14 +- src/hostif/parodusClient/gtest/dm_test.cpp | 701 ++++- src/hostif/parodusClient/pal/libpd.cpp | 6 + .../parodusClient/pal/webpa_parameter.cpp | 22 +- src/hostif/parodusClient/waldb/waldb.h | 3 + .../profiles/DHCPv4/Device_DHCPv4_Client.h | 3 + src/hostif/profiles/DHCPv4/gtest/Makefile.am | 14 +- .../profiles/DHCPv4/gtest/gtest_dhcpv4.cpp | 113 +- src/hostif/profiles/Device/gtest/Makefile.am | 14 +- .../profiles/Device/gtest/gtest_device.cpp | 58 + .../profiles/DeviceInfo/Device_DeviceInfo.cpp | 35 +- .../profiles/DeviceInfo/Device_DeviceInfo.h | 12 + .../DeviceInfo/XrdkCentralComBSStore.h | 9 +- .../DeviceInfo/XrdkCentralComBSStoreJournal.h | 2 + .../profiles/DeviceInfo/XrdkCentralComRFC.cpp | 7 +- .../profiles/DeviceInfo/XrdkCentralComRFC.h | 1 + .../DeviceInfo/XrdkCentralComRFCStore.h | 14 + .../profiles/DeviceInfo/gtest/Makefile.am | 14 +- .../profiles/DeviceInfo/gtest/gtest_main.cpp | 2708 ++++++++++++++++- .../profiles/Ethernet/gtest/Makefile.am | 14 +- .../Ethernet/gtest/gtest_ethernet.cpp | 26 + src/hostif/profiles/Time/Device_Time.h | 4 + src/hostif/profiles/Time/gtest/Makefile.am | 15 +- src/hostif/profiles/Time/gtest/gtest_time.cpp | 30 + src/hostif/src/gtest/Makefile.am | 16 +- src/hostif/src/gtest/gtest_src.cpp | 222 +- src/hostif/src/hostIf_utils.cpp | 6 + src/integrationtest/conf/bootstrap.ini | 1 + src/unittest/stubs/remote_debugger.json | 68 + src/unittest/stubs/rfcdefaults.ini | 1 + 43 files changed, 5933 insertions(+), 224 deletions(-) create mode 100644 src/hostif/handlers/src/gtest/Makefile.am create mode 100644 src/hostif/handlers/src/gtest/handlers_test.cpp create mode 100644 src/unittest/stubs/remote_debugger.json diff --git a/cov_build.sh b/cov_build.sh index 9a833b727..a9e92048b 100644 --- a/cov_build.sh +++ b/cov_build.sh @@ -70,9 +70,9 @@ cd $WORKDIR sed -i '/PKG_CHECK_MODULES(\[PROCPS\], \[libproc >= 3.2.8\])/s/^/#/' ./configure.ac rm -f ./src/unittest/stubs/rdk_debug.h autoreconf -i -./configure --enable-libsoup3=yes --enable-IPv6=yes +./configure --enable-IPv6=yes -make AM_CXXFLAGS="-I$WORKDIR/src/unittest/stubs -I$WORKDIR/src/hostif/include -I/usr/include/cjson -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I$WORKDIR/src/hostif/handlers/include -I$WORKDIR/src/hostif/parodusClient/waldb -I$WORKDIR/src/hostif/profiles/DeviceInfo -I/usr/include/cjson -I$WORKDIR/src/hostif/profiles/Time -I$WORKDIR/src/hostif/profiles/Device -I/usr/include/libsoup-3.0 -I/usr/include/yajl -I$WORKDIR/src/hostif/profiles/STBService -I$WORKDIR/src/unittest/stubs/ds -I/usr/devicesettings/ds -I/usr/local/include -I$WORKDIR/src/hostif/profiles/IP -I$WORKDIR/src/hostif/profiles/Ethernet -I/usr/local/include/rbus -I$WORKDIR/src/hostif/parodusClient/pal -I/usr/rdk-halif-device_settings/include -I/usr/local/include/libparodus -I/usr/local/include -I/usr/rdkvhal-devicesettings-raspberrypi4 -I/usr/local/include/ -I/usr/include/yajl -I/usr/tinyxml2 -I/usr/devicesettings/ds -I/$WORKDIR/src/hostif/httpserver/include -I/usr/remote_debugger/src/ -DLIBSOUP3_ENABLE -DIPV6_SUPPORT" \ +make AM_CXXFLAGS="-I$WORKDIR/src/unittest/stubs -I$WORKDIR/src/hostif/include -I/usr/include/cjson -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I$WORKDIR/src/hostif/handlers/include -I$WORKDIR/src/hostif/parodusClient/waldb -I$WORKDIR/src/hostif/profiles/DeviceInfo -I/usr/include/cjson -I$WORKDIR/src/hostif/profiles/Time -I$WORKDIR/src/hostif/profiles/Device -I/usr/include/libsoup-3.0 -I/usr/include/yajl -I$WORKDIR/src/hostif/profiles/STBService -I$WORKDIR/src/unittest/stubs/ds -I/usr/devicesettings/ds -I/usr/local/include -I$WORKDIR/src/hostif/profiles/IP -I$WORKDIR/src/hostif/profiles/Ethernet -I/usr/local/include/rbus -I$WORKDIR/src/hostif/parodusClient/pal -I/usr/rdk-halif-device_settings/include -I/usr/local/include/libparodus -I/usr/local/include -I/usr/rdkvhal-devicesettings-raspberrypi4 -I/usr/local/include/ -I/usr/include/yajl -I/usr/tinyxml2 -I/usr/devicesettings/ds -I/$WORKDIR/src/hostif/httpserver/include -I/usr/remote_debugger/src/ -DIPV6_SUPPORT" \ AM_LDFLAGS="-L/usr/local/lib -lrbus -lsecure_wrapper -lcurl -lrfcapi -lrdkloggers -llibparodus -lglib-2.0 -lnanomsg -lIARMBus -lWPEFrameworkPowerController -lds -ldshalcli -ldshalsrv -lwrp-c -lwdmp-c -lprocps -ltrower-base64 -lcimplog -lsoup-3.0 -L/usr/lib/x86_64-linux-gnu -lyajl -L/usr/local/lib/x86_64-linux-gnu -ltinyxml2" CXXFLAGS="-fpermissive -DPARODUS_ENABLE -DUSE_REMOTE_DEBUGGER" make install diff --git a/run_ut.sh b/run_ut.sh index 880235a74..23a4b3e65 100644 --- a/run_ut.sh +++ b/run_ut.sh @@ -48,7 +48,6 @@ apt-get -y install libsoup-3.0-dev apt-get -y install libprocps-dev apt-get -y install libnanomsg-dev apt-get -y install iproute2 - sed '/<\/model>/d; /<\/dm:document>/d' ./src/hostif/parodusClient/waldb/data-model/data-model-tv.xml > ./src/hostif/parodusClient/waldb/data-model/data-model-merged.xml sed '/> ./src/hostif/parodusClient/waldb/data-model/data-model-merged.xml @@ -65,17 +64,26 @@ mkdir -p /tmp/webpa mkdir -p /opt/persistent/ mkdir -p /etc/rfcdefaults mkdir -p /etc/apparmor.d +mkdir -p /opt/secure/persistent/ +mkdir -p /etc/rrd/ cp ./src/unittest/stubs/tr181store.ini /opt/secure/RFC/tr181store.ini cp ./src/integrationtest/conf/bootstrap.ini /opt/secure/RFC/ cp ./src/integrationtest/conf/rfcVariable.ini /opt/secure/RFC/ cp partners_defaults.json /etc/partners_defaults.json cp ./src/unittest/stubs/partners_defaults_device.json /etc/partners_defaults_device.json cp ./src/unittest/stubs/fwdnldstatus.txt /opt/fwdnldstatus.txt +cp ./src/integrationtest/conf/mgrlist.conf /etc/mgrlist.conf +cp ./src/unittest/stubs/remote_debugger.json /etc/rrd/remote_debugger.json touch /tmp/timeReceivedNTP touch /tmp/webpa/start_time touch /opt/persistent/firstNtpTime - - +touch /etc/rfcdefaults/rfcdefaults.ini +touch /opt/XRE_container_enable /opt/dab-enable +touch /opt/.ntpEnabled +touch /var/tmp/rssh.pid +cat /version.txt +rm -rf /version.txt +echo "Method|" >> /opt/fwdnldstatus.txt export TOP_DIR=$WORKDIR cd ./src/ @@ -90,10 +98,20 @@ make clean echo "TOP_DIR = $TOP_DIR" +echo "**** Compiling handlers gtest ****" +cd $TOP_DIR/src/hostif/handlers/src/gtest +rm handlers_gtest +sed -i '/getCurrentTime/,/^ *}/d' ../../../src/hostIf_utils.cpp +make clean +make +./handlers_gtest +echo "********************" + + echo "**** Compiling data model gtest ****" cd $TOP_DIR/src/hostif/parodusClient/gtest rm dm_gtest -sed -i '/getCurrentTime/,/^ *}/d' ../../src/hostIf_utils.cpp +#sed -i '/getCurrentTime/,/^ *}/d' ../../src/hostIf_utils.cpp make ./dm_gtest echo "********************" @@ -101,7 +119,8 @@ echo "********************" echo "**** Compiling httpserver gtest ****" cd $TOP_DIR/src/hostif/httpserver/src/gtest rm httpserver_gtest -sed -i '$a void getCurrentTime(struct timespec *timer)\n{\n clock_gettime(CLOCK_REALTIME, timer);\n}' ../../../src/hostIf_utils.cpp +#sed -i '$a void getCurrentTime(struct timespec *timer)\n{\n clock_gettime(CLOCK_REALTIME, timer);\n}' ../../../src/hostIf_utils.cpp +#sed -i '/getCurrentTime/,/^ *}/d' ../../src/hostIf_utils.cpp make clean make ./httpserver_gtest @@ -110,6 +129,7 @@ echo "********************" echo "**** Compiling src gtest ****" cd $TOP_DIR/src/hostif/src/gtest rm src_gtest +sed -i '$a void getCurrentTime(struct timespec *timer)\n{\n clock_gettime(CLOCK_REALTIME, timer);\n}' ../hostIf_utils.cpp make clean make ./src_gtest @@ -145,6 +165,7 @@ echo "********************" echo "**** Compiling DeviceInfo gtest ****" cd $TOP_DIR/src/hostif/profiles/DeviceInfo/gtest +cp ../../../../unittest/stubs/rfc.properties /etc/rfc.properties rm devieInfo_gtest /opt/www/authService/partnerId3.dat make ./devieInfo_gtest diff --git a/src/configure.ac b/src/configure.ac index 4ad41b460..5a4d58d68 100644 --- a/src/configure.ac +++ b/src/configure.ac @@ -69,6 +69,7 @@ AC_SUBST(T2_EVENT_FLAG) hostif/profiles/Ethernet/gtest/Makefile hostif/profiles/Time/gtest/Makefile hostif/profiles/DeviceInfo/gtest/Makefile + hostif/handlers/src/gtest/Makefile ]) # Generate the configure script diff --git a/src/hostif/handlers/include/hostIf_rbus_Dml_Provider.h b/src/hostif/handlers/include/hostIf_rbus_Dml_Provider.h index 2cb9f5cf1..322e6766c 100644 --- a/src/hostif/handlers/include/hostIf_rbus_Dml_Provider.h +++ b/src/hostif/handlers/include/hostIf_rbus_Dml_Provider.h @@ -48,11 +48,22 @@ #ifndef HOSTIF_RBUS_DML_PROVIDER_H_ #define HOSTIF_RBUS_DML_PROVIDER_H_ +#ifdef GTEST_ENABLE +#include "rbus_value.h" +#include "rbus.h" +#endif + void init_rbus_dml_provider(); int setRbusStringParam(const char *paramName, char* paramValue); int getRbusStringParam(const char *paramName, char** paramValue); +#ifdef GTEST_ENABLE +rbusError_t TR_Dml_EventSubHandler(rbusHandle_t handle, rbusEventSubAction_t action, const char* eventName, rbusFilter_t filter, int32_t interval, bool* autoPublish); +rbusError_t TR_Dml_GetHandler(rbusHandle_t handle, rbusProperty_t inProperty, rbusGetHandlerOptions_t* opts); +rbusError_t TR_Dml_SetHandler(rbusHandle_t handle, rbusProperty_t inProperty, rbusSetHandlerOptions_t* opts); +#endif + #endif /* HOSTIF_RBUS_DML_PROVIDER_H_ */ /* End of HOSTIF_RBUS_DML_PROVIDER_H_ API doxygen group */ diff --git a/src/hostif/handlers/src/gtest/Makefile.am b/src/hostif/handlers/src/gtest/Makefile.am new file mode 100644 index 000000000..279fb4966 --- /dev/null +++ b/src/hostif/handlers/src/gtest/Makefile.am @@ -0,0 +1,39 @@ +################################################################################ +# Copyright 2024 Comcast Cable Communications Management, LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +################################################################################ + +AUTOMAKE_OPTIONS = subdir-objects + +# Define the program name and the source files +bin_PROGRAMS = handlers_gtest + +# Define the include directories + +COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DYOCTO_BUILD -DUSE_DEV_PROPERTIES_CONF -DUSE_REMOTE_DEBUGGER -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I$(TOP_DIR)/src/hostif/handlers/include -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/hostif/httpserver/include -I$(TOP_DIR)/src/hostif/handlers/src -I/usr/include/rbus -I/usr/local/include/rbus -Isrc/unittest/stubs/rbus/include/ -I$(TOP_DIR)/src/hostif/profiles/Time -I$(TOP_DIR)/src/hostif/profiles/Device -I$(TOP_DIR)/src/hostif/profiles/IP -I$(TOP_DIR)/src/hostif/profiles/STBService -I/usr/rdk-halif-device_settings/include/ -I/usr/rdkvhal-devicesettings-raspberrypi4/ -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I$(TOP_DIR)/src/hostif/profiles/Ethernet -I/usr/remote_debugger/src/ -I/usr/local/include/libparodus/ -I/usr/local/include/wrp-c/ -I$(TOP_DIR)/src/hostif/parodusClient/startParodus/ -I$(TOP_DIR)/src/hostif/profiles/DHCPv4 -I/usr/include/libsoup-3.0 + +# Define the libraries to link against +COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl -lglib-2.0 -llibparodus -lwrp-c -lnanomsg -lmsgpackc -ltrower-base64 -lcimplog -lsoup-3.0 + +# Define the compiler flags +COMMON_CXXFLAGS = -frtti $(GLIB_CFLAGS) -fprofile-arcs -ftest-coverage + +handlers_gtest_SOURCES = handlers_test.cpp $(TOP_DIR)/src/hostif/parodusClient/startParodus/startParodus.cpp $(TOP_DIR)/src/hostif/src/hostIf_utils.cpp $(TOP_DIR)/src/hostif/src/IniFile.cpp $(TOP_DIR)/src/unittest/stubs/secure_wrapper.c $(TOP_DIR)/src/hostif/profiles/DeviceInfo/XrdkCentralComRFCStore.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/XrdkCentralComRFC.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStore.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStoreJournal.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/Device_DeviceInfo.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_NotificationHandler.cpp $(TOP_DIR)/src/hostif/parodusClient/pal/webpa_notification.cpp $(TOP_DIR)/src/hostif/parodusClient/pal/webpa_attribute.cpp $(TOP_DIR)/src/hostif/parodusClient/pal/webpa_parameter.cpp $(TOP_DIR)/src/hostif/parodusClient/pal/libpd.cpp $(TOP_DIR)/src/hostif/parodusClient/pal/webpa_adapter.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_msgHandler.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_XrdkCentralT2_ReqHandler.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_IPClient_ReqHandler.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_DeviceClient_ReqHandler.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/Device_DeviceInfo_ProcessStatus_Process.cpp $(TOP_DIR)/src/hostif/profiles/Ethernet/Device_Ethernet_Interface.cpp $(TOP_DIR)/src/hostif/profiles/STBService/Components_DisplayDevice.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_EthernetClient_ReqHandler.cpp $(TOP_DIR)/src/hostif/profiles/Ethernet/Device_Ethernet_Interface_Stats.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_TimeClient_ReqHandler.cpp $(TOP_DIR)/src/hostif/profiles/IP/Device_IP.cpp $(TOP_DIR)/src/hostif/profiles/IP/Device_IP_Interface.cpp $(TOP_DIR)/src/hostif/profiles/Time/Device_Time.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_updateHandler.cpp $(TOP_DIR)/src/hostif/profiles/Device/x_rdk_profile.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_dsClient_ReqHandler.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_rbus_Dml_Provider.cpp $(TOP_DIR)/src/hostif/profiles/STBService/Capabilities.cpp $(TOP_DIR)/src/hostif/profiles/STBService/Components_SPDIF.cpp $(TOP_DIR)/src/hostif/profiles/STBService/Components_VideoDecoder.cpp $(TOP_DIR)/src/hostif/profiles/STBService/Components_AudioOutput.cpp $(TOP_DIR)/src/hostif/profiles/STBService/Components_HDMI.cpp $(TOP_DIR)/src/hostif/profiles/STBService/Components_VideoOutput.cpp $(TOP_DIR)/src/hostif/profiles/IP/Device_IP_Interface_Stats.cpp $(TOP_DIR)/src/hostif/profiles/IP/Device_IP_ActivePort.cpp $(TOP_DIR)/src/hostif/profiles/IP/Device_IP_Diagnostics_IPPing.cpp $(TOP_DIR)/src/hostif/profiles/IP/Device_IP_Interface_IPv4Address.cpp $(TOP_DIR)/src/hostif/handlers/src/x_rdk_req_handler.cpp $(TOP_DIR)/src/unittest/stubs/dm_stubs.cpp $(TOP_DIR)/src/hostif/parodusClient/waldb/waldb.cpp $(TOP_DIR)/src/unittest/stubs/wdmp-c.c $(TOP_DIR)/src/unittest/stubs/wdmp_internal.c $(TOP_DIR)/src/hostif/httpserver/src/http_server.cpp $(TOP_DIR)/src/hostif/httpserver/src/request_handler.cpp $(TOP_DIR)/src/hostif/httpserver/src/XrdkCentralComRFCVar.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/Device_DeviceInfo_Processor.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/Device_DeviceInfo_ProcessStatus.cpp $(TOP_DIR)/src/unittest/stubs/ds/libprocps.cpp $(TOP_DIR)/src/unittest/stubs/file_writer.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_DHCPv4Client_ReqHandler.cpp $(TOP_DIR)/src/hostif/profiles/DHCPv4/Device_DHCPv4_Client.cpp + +# Apply common properties to each program +handlers_gtest_CPPFLAGS = $(COMMON_CPPFLAGS) +handlers_gtest_LDADD = $(COMMON_LDADD) +handlers_gtest_CXXFLAGS = $(COMMON_CXXFLAGS) diff --git a/src/hostif/handlers/src/gtest/handlers_test.cpp b/src/hostif/handlers/src/gtest/handlers_test.cpp new file mode 100644 index 000000000..11faa7765 --- /dev/null +++ b/src/hostif/handlers/src/gtest/handlers_test.cpp @@ -0,0 +1,1530 @@ +/* + * Copyright 2024 Comcast Cable Communications Management, LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + */ +#include +#include +#include +#include "dm_stubs.h" +#include "startParodus.h" +#include "file_writer.h" +#include "webpa_notification.h" +#include "webpa_parameter.h" +#include "webpa_adapter.h" +#include "libpd.h" +#include "webpa_attribute.h" +#include "rbus_value.h" +#include "hostIf_tr69ReqHandler.h" +#include "hostIf_utils.h" +#include "wrp-c.h" +#include "x_rdk_req_handler.h" +#include "hostIf_rbus_Dml_Provider.h" +#include "rbus_value.h" +#include "rbus.h" +#include "hostIf_XrdkCentralT2_ReqHandler.h" +#include "hostIf_TimeClient_ReqHandler.h" +#include "hostIf_DeviceClient_ReqHandler.h" +#include "hostIf_EthernetClient_ReqHandler.h" +#include "hostIf_IPClient_ReqHandler.h" +#include "hostIf_DHCPv4Client_ReqHandler.h" + + +#include "waldb.h" +#include "wdmp-c.h" + +using namespace std; + + +#include +#include + + +#define GTEST_DEFAULT_RESULT_FILEPATH "/tmp/Gtest_Report/" +#define GTEST_DEFAULT_RESULT_FILENAME "datamodel_gtest_report.json" +#define GTEST_REPORT_FILEPATH_SIZE 128 + +extern GHashTable* paramMgrhash; + +std::mutex mtx_httpServerThreadDone; +std::condition_variable cv_httpServerThreadDone; +bool httpServerThreadDone = false; +GThread *HTTPServerThread = NULL; +char *HTTPServerName = (char *)"HTTPServerThread"; +GError *httpError = NULL; +GHashTable* paramMgrhash = NULL; +T_ARGLIST argList = {{'\0'}, 0}; + +extern int (*convertRbus2hostIfDataTypeFunc()) (rbusValueType_t type, HostIf_ParamType_t* pParamType); + + +TEST(handlersTest, handleGetMsg) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.X_RDK_WebPA_DNSText.URL", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + X_rdk_req_hdlr* reqHandler = static_cast(X_rdk_req_hdlr::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, handleSetMsg) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.X_RDK_WebPA_DNSText.URL", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + + strncpy(param.paramValue, "fabric.xmidt.comcast.net", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + X_rdk_req_hdlr* reqHandler = static_cast(X_rdk_req_hdlr::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, convertRbus2hostIfDataType) { + HostIf_ParamType_t paramType; + + EXPECT_EQ(convertRbus2hostIfDataTypeFunc()(RBUS_BOOLEAN, ¶mType), 0); + EXPECT_EQ(convertRbus2hostIfDataTypeFunc()(RBUS_INT8, ¶mType), 0); + EXPECT_EQ(convertRbus2hostIfDataTypeFunc()(RBUS_UINT8, ¶mType), 0); + EXPECT_EQ(convertRbus2hostIfDataTypeFunc()(RBUS_INT64, ¶mType), 0); + EXPECT_EQ(convertRbus2hostIfDataTypeFunc()(RBUS_STRING, ¶mType), 0); + EXPECT_EQ(convertRbus2hostIfDataTypeFunc()(RBUS_DATETIME, ¶mType), 0); +} + +TEST(handlersTest, TR_Dml_EventSubHandler) { + HostIf_ParamType_t paramType; + rbusHandle_t handle; + rbusEventSubAction_t action; + const char* eventName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.IssueType"; + rbusFilter_t filter; + int32_t interval = 60; + bool autoPublish = false; + + rbusError_t rc = TR_Dml_EventSubHandler(handle, action, eventName, filter, interval, &autoPublish); + EXPECT_EQ(rc, RBUS_ERROR_SUCCESS); +} + +TEST(handlersTest, TR_Dml_GetHandler) { + //MockRbusProperty mockProp = { "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.Enable" }; + //rbusProperty_t testProp = (rbusProperty_t)&mockProp; + rbusProperty_t testProp; + + rbusHandle_t handle; + rbusGetHandlerOptions_t opts = {}; + + rbusError_t rc = TR_Dml_GetHandler(handle, testProp, &opts); + EXPECT_EQ(rc, 2); +} + +TEST(handlersTest, setRbusStringParam) { + const char *paramName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.IssueType"; + char* paramValue = "testdata"; + + int rc = setRbusStringParam(paramName, paramValue); + EXPECT_EQ(rc, -1); +} + +TEST(handlersTest, getRbusStringParam) { + const char *paramName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.IssueType"; + char* paramValue = nullptr; + + int rc = getRbusStringParam(paramName, ¶mValue); + EXPECT_EQ(rc, -1); +} + +TEST(handlersTest, XrdkCentralT2handleSetMsg) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.X_RDKCENTRAL-COM_T2.ReportProfiles", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + + strncpy(param.paramValue, "testprofile", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + XRdkCentralT2* reqHandler = static_cast(XRdkCentralT2::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, XrdkCentralT2handleGetMsg) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.X_RDKCENTRAL-COM_T2.ReportProfiles", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + XRdkCentralT2* reqHandler = static_cast(XRdkCentralT2::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, TimeClientReqHandler_handleGetMsg_Enable) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.Time.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + TimeClientReqHandler* reqHandler = static_cast(TimeClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + + +TEST(handlersTest, TimeClientReqHandler_handleGetMsg_Status) { + write_on_file("/tmp/ntp_status", "ntp status"); + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.Time.Status", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + TimeClientReqHandler* reqHandler = static_cast(TimeClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + EXPECT_STREQ(param.paramValue, "ntp status"); + } +} + +TEST(handlersTest, TimeClientReqHandler_handleGetMsg_LocalTimeZone) { + write_on_file("/tmp/ntp_status", "ntp status"); + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.Time.LocalTimeZone", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + TimeClientReqHandler* reqHandler = static_cast(TimeClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, TimeClientReqHandler_handleGetMsg_CurrentLocalTime) { + write_on_file("/tmp/ntp_status", "ntp status"); + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.Time.CurrentLocalTime", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + TimeClientReqHandler* reqHandler = static_cast(TimeClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, TimeClientReqHandler_handleGetMsg_X_RDK_CurrentUTCTime) { + write_on_file("/tmp/ntp_status", "ntp status"); + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.Time.X_RDK_CurrentUTCTime", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + TimeClientReqHandler* reqHandler = static_cast(TimeClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, TimeClientReqHandler_handleSetMsg) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.Time.NTPServer5", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_SRC_RFC; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "override_time4.com", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + TimeClientReqHandler* reqHandler = static_cast(TimeClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + + +TEST(handlersTest, TimeClientReqHandler_handleGetAttributesMsg) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.Time.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + TimeClientReqHandler* reqHandler = static_cast(TimeClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetAttributesMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, TimeClientReqHandler_handleSetAttributesMsg) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.Time.NTPServer4", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "override_time3.com", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + TimeClientReqHandler* reqHandler = static_cast(TimeClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetAttributesMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleSetMsg) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Bootstrap.SsrUrl", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_SRC_RFC; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "https://ssr.ccp.xcal.tv", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleSetMsg_FirmwareDownloadStatus) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_FirmwareDownloadStatus", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "Download Started", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleSetMsg_FirmwareDownloadProtocol) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_FirmwareDownloadProtocol", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "http", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleSetMsg_FirmwareDownloadURL) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_FirmwareDownloadURL", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "https://xconf.xdp.eu-1.xcal.tv", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleSetMsg_PreferredGatewayType) { + write_on_file("/opt/prefered-gateway", "192.168.1.1"); + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_PreferredGatewayType", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleSetMsg_set_xOpsDMUploadLogsNow) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.Logging.xOpsDMUploadLogsNow", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "true", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleSetMsg_ForwardSSHEnable) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.ForwardSSH.Enable", 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); + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleSetMsg_DownloadStatus) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RDKDownloadManager.DownloadStatus", 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); + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleSetMsg_IPRemoteSupportEnable) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_IPRemoteSupport.Enable", 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); + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleSetMsg_PartnerId) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_Syndication.PartnerId", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "global", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleSetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Bootstrap.SsrUrl", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_SRC_RFC; + param.requestor = HOSTIF_SRC_RFC; + + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_PreferredGatewayType) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_PreferredGatewayType", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_Manufacturer) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.Manufacturer", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_ManufacturerOUI) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.ManufacturerOUI", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, -2); + } +} + + + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_ModelName) { + write_on_file("/tmp/.model", "SKY"); + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.ModelName", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + EXPECT_STREQ(param.paramValue, "SKY"); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_Description) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.Description", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_HardwareVersion) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.HardwareVersion", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, NOK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_SoftwareVersion) { + writeToTr181storeFile("VERSION", "99.99.15.07", "/version.txt", Plain); + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.SoftwareVersion", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } + std::remove("/version.txt"); +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_MigrationStatus) { + write_on_file("/opt/secure/persistent/MigrationStatus", "NEEDED"); + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.Migration.MigrationStatus", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + EXPECT_STREQ(param.paramValue, "NEEDED"); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_IUI_Version) { + write_on_file("/tmp/.iuiVersion", "4.4"); + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM.IUI.Version", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + EXPECT_STREQ(param.paramValue, "4.4"); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_UpTime) { + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.UpTime", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_FirstUseDate) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.FirstUseDate", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + } +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_FirmwareFilename) { + write_on_file("/tmp/currently_running_image_name", "ELTE11MWR_DEV_develop_20250808222826_NG"); + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_FirmwareFilename", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + EXPECT_EQ(ret, OK); + EXPECT_STREQ(param.paramValue, "ELTE11MWR_DEV_develop_20250808222826_NG"); + } + std::remove("/tmp/currently_running_image_name"); +} + +TEST(handlersTest, DeviceClientReqHandler_handleGetMsg_FirmwareDownloadStatus) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_FirmwareDownloadStatus", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + DeviceClientReqHandler* reqHandler = static_cast(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) + { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DeviceClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleSetAttributesMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleSetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(EthernetClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleSetAttributesMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(IPClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(IPClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleSetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DHCPv4ClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DHCPv4ClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DHCPv4ClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DHCPv4ClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DHCPv4ClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleSetAttributesMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue <(DHCPv4ClientReqHandler::getInstance()); + if(reqHandler) { + int ret = reqHandler->handleGetAttributesMsg(¶m); + cout << "msgData.paramValue = " << param.paramValue < +#include #include "rdk_debug.h" #include "waldb.h" @@ -50,13 +53,18 @@ XBSStore* m_bsStore; XBSStoreJournal* m_bsStoreJournal; XRFCVarStore* m_varStore; +extern GHashTable* paramMgrhash; + std::mutex mtx_httpServerThreadDone; std::condition_variable cv_httpServerThreadDone; bool httpServerThreadDone = false; GThread *HTTPServerThread = NULL; char *HTTPServerName = (char *)"HTTPServerThread"; GError *httpError = NULL; +GHashTable* paramMgrhash = NULL; T_ARGLIST argList = {{'\0'}, 0}; +static SoupServer *http_server = NULL; + #ifdef GTEST_ENABLE extern DATA_TYPE (*getWdmpDataTypeFunc())(char * ); @@ -65,6 +73,14 @@ bool (*validateParamValueFunc())(const string ¶mValue, HostIf_ParamType_t da WDMP_STATUS (*handleRFCRequestFunc())(REQ_TYPE reqType, param_t *param); WDMP_STATUS (*invokeHostIfAPIFunc())(REQ_TYPE reqType, param_t *param, HostIf_Source_Type_t bsUpdate, const char *pcCallerID); WDMP_STATUS (*validateAgainstDataModelFunc())(REQ_TYPE reqType, char* paramName, const char* paramValue, DATA_TYPE *dataType, char **defaultValue, HostIf_Source_Type_t *bsUpdate); +extern void (*HTTPRequestHandlerFunc()) ( + SoupServer *server, + SoupServerMessage *msg, + const char *path, + GHashTable *query, + void *user_data); +extern void (*convertAndAssignParamValueFunc()) (HOSTIF_MsgData_t *param, char *value); +extern char* (*getStringValueFunc()) (HostIf_ParamType_t paramType, char *value); #endif TEST(httpserverTest,initRFCVarFileName){ @@ -104,6 +120,7 @@ TEST(httpserverTest, getWdmpDataType) { EXPECT_EQ(getWdmpDataTypeFunc()("int"), WDMP_INT); EXPECT_EQ(getWdmpDataTypeFunc()("unsignedLong"), WDMP_ULONG); EXPECT_EQ(getWdmpDataTypeFunc()("dataTime"), WDMP_DATETIME); + EXPECT_EQ(getWdmpDataTypeFunc()("float"), WDMP_NONE); } TEST(httpserverTest, getHostIfParamType) { @@ -131,6 +148,18 @@ TEST(httpserverTest, validateParamValue) { const string uiparamValue = "12"; dataType = hostIf_UnsignedIntType; EXPECT_EQ(validateParamValueFunc()(uiparamValue, dataType), true); + + const string paramValue = "flase"; + dataType = hostIf_BooleanType; + EXPECT_EQ(validateParamValueFunc()(paramValue, dataType), false); + + const string invalidIntValue = "123abc"; + dataType = hostIf_IntegerType; + EXPECT_EQ(validateParamValueFunc()(invalidIntValue, dataType), false); + + const string invalidLongValue = "123dab"; + dataType = hostIf_UnsignedLongType; + EXPECT_EQ(validateParamValueFunc()(invalidLongValue, dataType), false); } TEST(httpserverTest, handleRFCRequest_GET) { @@ -159,6 +188,19 @@ TEST(httpserverTest, handleRFCRequest_SET) { free(param.value); } +TEST(httpserverTest, InvalidReqtype) { + param_t param; + memset(¶m,0,sizeof(param_t)); + param.name = strdup(XRFC_VAR_STORE_RELOADCACHE); + param.value = strdup("true"); + + REQ_TYPE reqType = DELETE_ROW; + WDMP_STATUS status = handleRFCRequestFunc()(reqType, ¶m); + EXPECT_EQ(status, WDMP_SUCCESS); + free(param.name); + free(param.value); +} + TEST(httpserverTest, handleRFCInvalidRequest) { param_t param; memset(¶m,0,sizeof(param_t)); @@ -172,7 +214,28 @@ TEST(httpserverTest, handleRFCInvalidRequest) { free(param.value); } +TEST(httpserverTest, invokeHostIfAPI_SET_FAILURE) { + param_t param; + memset(¶m,0,sizeof(param_t)); + param.name = strdup("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MOCASSH.Enable"); + param.value = strdup("true"); + + const char *pcCallerID = "rfc"; + + HOSTIF_MsgData_t msgData = { 0 }; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.bsUpdate = HOSTIF_NONE; + + REQ_TYPE reqType = SET; + WDMP_STATUS status = invokeHostIfAPIFunc()(reqType, ¶m, msgData.bsUpdate, pcCallerID); + EXPECT_EQ(status, 37); +} + + TEST(httpserverTest, invokeHostIfAPI) { + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); + param_t param; memset(¶m,0,sizeof(param_t)); param.name = strdup("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Airplay.Enable"); @@ -189,6 +252,45 @@ TEST(httpserverTest, invokeHostIfAPI) { } +TEST(httpserverTest, invokeHostIfAPI_SET) { + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); + + param_t param; + memset(¶m,0,sizeof(param_t)); + param.name = strdup("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Bootstrap.SsrUrl"); + param.value = strdup("https://ssr.ccp.xcal.tv"); + + const char *pcCallerID = "rfc"; + + HOSTIF_MsgData_t msgData = { 0 }; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.bsUpdate = HOSTIF_NONE; + + REQ_TYPE reqType = SET; + WDMP_STATUS status = invokeHostIfAPIFunc()(reqType, ¶m, msgData.bsUpdate, pcCallerID); + EXPECT_EQ(status, WDMP_SUCCESS); +} + +TEST(httpserverTest, invokeHostIfAPI_InvalidReq) { + param_t param; + memset(¶m,0,sizeof(param_t)); + param.name = strdup("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Bootstrap.XconfUrl"); + const char *pcCallerID = "webpa"; + + HOSTIF_MsgData_t msgData = { 0 }; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.bsUpdate = HOSTIF_NONE; + + strncpy(msgData.paramValue, "https://ssr.ccp.xcal.tv", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.paramtype = hostIf_StringType; + msgData.paramLen = strlen(msgData.paramValue); + + REQ_TYPE reqType = REPLACE_ROWS; + WDMP_STATUS status = invokeHostIfAPIFunc()(reqType, ¶m, msgData.bsUpdate, pcCallerID); + EXPECT_EQ(status, WDMP_ERR_INTERNAL_ERROR); +} + TEST(httpserverTest, validateAgainstDataModel_GET) { /* Load the data model xml file*/ @@ -278,6 +380,35 @@ TEST(httpserverTest, validateAgainstDataModel_SET_ReadOnly) { EXPECT_EQ(status, WDMP_ERR_NOT_WRITABLE); } +TEST(httpserverTest, validateAgainstDataModel_INVALID_PARAMETER_NAME) { + + /* Load the data model xml file*/ + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + + HOSTIF_MsgData_t msgData = { 0 }; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.bsUpdate = HOSTIF_NONE; + + char paramName [] = "Device.DeviceInfoTest.FriendlyName"; + const char* paramValue = "reverseSsh"; + DATA_TYPE dataType = WDMP_BOOLEAN; + + REQ_TYPE reqType = SET; + char defaultValue[66]; + char* defaultValuePtr = defaultValue; + WDMP_STATUS status = validateAgainstDataModelFunc()(SET, paramName, paramValue, &dataType, &defaultValuePtr, &msgData.bsUpdate); + EXPECT_EQ(status, WDMP_ERR_INVALID_PARAMETER_NAME); +} + TEST(httpserverTest, handleRequest_GET) { /* Load the data model xml file*/ @@ -336,6 +467,112 @@ TEST(httpserverTest, handlewildRequest_GET) { } +TEST(httpserverTest, handlewildRequestINVALIDPARAM_GET) { + + /* Load the data model xml file*/ + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + + const char* pcCallerID = "rfc"; + get_req_t *getReq = (get_req_t *)malloc(sizeof(get_req_t)); + getReq->paramCnt = 1; + getReq->paramNames[0] = strdup("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.SystemServices.FriendlyName"); + req_struct reqSt; + reqSt.reqType = GET; // Replace with actual enum value if it's defined + reqSt.u.getReq = getReq; + + + res_struct* respSt = handleRequest(pcCallerID, &reqSt); + EXPECT_EQ(respSt->retStatus[0], 22); +} + +/* TEST(httpserverTest, paramCount_GET) { + + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + + const char* pcCallerID = "rfc"; + get_req_t *getReq = (get_req_t *)malloc(sizeof(get_req_t)); + getReq->paramCnt = 0; + // getReq->paramNames[0] = strdup("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.SystemServices.FriendlyName"); + req_struct reqSt; + reqSt.reqType = GET; // Replace with actual enum value if it's defined + reqSt.u.getReq = getReq; + + + res_struct* respSt = handleRequest(pcCallerID, &reqSt); + EXPECT_EQ(respSt->retStatus[0], NULL); +} + + +TEST(httpserverTest, paramCount_SET) { + + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + + const char* pcCallerID = "rfc"; + get_req_t *getReq = (get_req_t *)malloc(sizeof(get_req_t)); + getReq->paramCnt = 0; + // getReq->paramNames[0] = strdup("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.SystemServices.FriendlyName"); + req_struct reqSt; + reqSt.reqType = SET; // Replace with actual enum value if it's defined + reqSt.u.getReq = getReq; + + + res_struct* respSt = handleRequest(pcCallerID, &reqSt); + EXPECT_EQ(respSt->retStatus[0], NULL); +} +*/ + +/* TEST(httpserverTest, paramCount_InvalidParamName) { + + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + + const char* pcCallerID = "rfc"; + get_req_t *getReq = (get_req_t *)malloc(sizeof(get_req_t)); + getReq->paramCnt = 1; + getReq->paramNames[0] = strdup("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Airplay.Enable.Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Airplay.Enable.Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Airplay.Enable.Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Airplay.Enable.Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Airplay.Enable"); + req_struct reqSt; + reqSt.reqType = SET; // Replace with actual enum value if it's defined + reqSt.u.getReq = getReq; + + + res_struct* respSt = handleRequest(pcCallerID, &reqSt); + EXPECT_EQ(respSt->retStatus[0], WDMP_ERR_INVALID_PARAMETER_NAME); +} */ + TEST(httpserverTest, handleRequest_SET) { /* Load the data model xml file*/ DB_STATUS dbStatus = loadDataModel(); @@ -379,6 +616,102 @@ TEST(httpserverTest, handleRequest_SET) { } +TEST(httpserverTest, convertAndAssignParamValue_BooleanType) { + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MOCASSH.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); + + convertAndAssignParamValueFunc()(¶m, "true"); + EXPECT_EQ(0, 0); +} + +TEST(httpserverTest, convertAndAssignParamValue_StringType) { + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.IssueType", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + convertAndAssignParamValueFunc()(¶m, "Testtype"); + EXPECT_EQ(0, 0); +} + +TEST(httpserverTest, convertAndAssignParamValue_IntegerType) { + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.TopSpeed", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + + param.paramtype = hostIf_IntegerType; + param.paramLen = sizeof(hostIf_IntegerType); + + convertAndAssignParamValueFunc()(¶m, "1180000"); + EXPECT_EQ(0, 0); +} + +TEST(httpserverTest, convertAndAssignParamValue_UnsignedLongType) { + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.Ethernet.Interface.1.Stats.BytesReceived", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + + param.paramtype = hostIf_UnsignedLongType; + param.paramLen = sizeof(hostIf_UnsignedLongType); + + convertAndAssignParamValueFunc()(¶m, "123456789"); + EXPECT_EQ(0, 0); +} + +TEST(httpserverTest, getStringValue) { + EXPECT_STREQ(getStringValueFunc()(hostIf_StringType, "global"), "global"); + EXPECT_STREQ(getStringValueFunc()(hostIf_IntegerType, "100"), "3158065"); + EXPECT_STREQ(getStringValueFunc()(hostIf_BooleanType, "true"), "false"); + EXPECT_STREQ(getStringValueFunc()(hostIf_BooleanType, "false"), "false"); + EXPECT_STREQ(getStringValueFunc()(hostIf_UnsignedLongType, "123456789"), "4050765991979987505"); +} + +TEST(httpserverTest, Invalid_RFC_filename) { + m_varStore = XRFCVarStore::getInstance(); + m_varStore->m_filename = "/opt/secure/RFC1/rfctest_Variable.ini"; + std::ofstream file("/opt/secure/RFC1/rfctest_Variable.ini"); + file.close(); + if(m_varStore) + { + bool ret = m_varStore->loadRFCVarIntoCache(); + EXPECT_EQ(ret, false); + } +} + +TEST(httpserverTest, HTTPRequestHandler_GET) { + + // Create a SoupMessage for POST + SoupServer *server = soup_server_new(nullptr, nullptr); + SoupMessage *msg = soup_message_new("POST", "http://localhost/api/status"); + const char *json_body = "{\"action\":\"ping\"}"; + GBytes *body_bytes = g_bytes_new_static(json_body, strlen(json_body)); + soup_message_set_request_body_from_bytes(msg, "application/json", body_bytes); + SoupMessageHeaders *headers = soup_message_get_request_headers(msg); + soup_message_headers_append(headers, "CallerID", "unittest"); + + HTTPRequestHandlerFunc()(server, reinterpret_cast(msg), "/api/status", nullptr, nullptr); + EXPECT_EQ(0, 0); +} + + GTEST_API_ int main(int argc, char *argv[]){ char testresults_fullfilepath[GTEST_REPORT_FILEPATH_SIZE]; char buffer[GTEST_REPORT_FILEPATH_SIZE]; diff --git a/src/hostif/httpserver/src/http_server.cpp b/src/hostif/httpserver/src/http_server.cpp index cfd53d163..d7ae0c1e1 100644 --- a/src/hostif/httpserver/src/http_server.cpp +++ b/src/hostif/httpserver/src/http_server.cpp @@ -289,3 +289,15 @@ void HttpServerStop() RDK_LOG(RDK_LOG_TRACE1, LOG_TR69HOSTIF,"SERVER: Stopped server successfully.\n"); } } + +#ifdef GTEST_ENABLE +void (*HTTPRequestHandlerFunc()) ( + SoupServer *server, + SoupServerMessage *msg, + const char *path, + GHashTable *query, + void *user_data) +{ + return &HTTPRequestHandler; +} +#endif diff --git a/src/hostif/httpserver/src/request_handler.cpp b/src/hostif/httpserver/src/request_handler.cpp index 43e3e9543..a324f5f23 100644 --- a/src/hostif/httpserver/src/request_handler.cpp +++ b/src/hostif/httpserver/src/request_handler.cpp @@ -770,4 +770,14 @@ defaultValue, HostIf_Source_Type_t *bsUpdate) { return &validateAgainstDataModel; } + +void (*convertAndAssignParamValueFunc()) (HOSTIF_MsgData_t *param, char *value) +{ + return &convertAndAssignParamValue; +} + +char* (*getStringValueFunc()) (HostIf_ParamType_t paramType, char *value) +{ + return &getStringValue; +} #endif diff --git a/src/hostif/include/IniFile.h b/src/hostif/include/IniFile.h index 013a7cecc..1bff86c3c 100644 --- a/src/hostif/include/IniFile.h +++ b/src/hostif/include/IniFile.h @@ -23,6 +23,10 @@ #include #include +#if defined(GTEST_ENABLE) +#include +#endif + class IniFile { public: @@ -36,6 +40,10 @@ class IniFile private: std::string m_filename; std::map m_dict; + +#if defined(GTEST_ENABLE) + FRIEND_TEST(srcTest, flush); +#endif }; #endif /* INIFILE_H_ */ diff --git a/src/hostif/parodusClient/gtest/Makefile.am b/src/hostif/parodusClient/gtest/Makefile.am index b24578528..ba4a499bc 100644 --- a/src/hostif/parodusClient/gtest/Makefile.am +++ b/src/hostif/parodusClient/gtest/Makefile.am @@ -22,20 +22,10 @@ AUTOMAKE_OPTIONS = subdir-objects bin_PROGRAMS = dm_gtest # Define the include directories -COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DUSE_DEV_PROPERTIES_CONF -DUSE_REMOTE_DEBUGGER -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I$(TOP_DIR)/src/hostif/handlers/include -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/hostif/httpserver/include -I$(TOP_DIR)/src/hostif/handlers/src -I/usr/include/rbus -I/usr/local/include/rbus -Isrc/unittest/stubs/rbus/include/ -I$(TOP_DIR)/src/hostif/profiles/Time -I$(TOP_DIR)/src/hostif/profiles/Device -I$(TOP_DIR)/src/hostif/profiles/IP -I$(TOP_DIR)/src/hostif/profiles/STBService -I/usr/rdk-halif-device_settings/include/ -I/usr/rdkvhal-devicesettings-raspberrypi4/ -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I$(TOP_DIR)/src/hostif/profiles/Ethernet -I/usr/remote_debugger/src/ -I/usr/local/include/libparodus/ -I/usr/local/include/wrp-c/ -I$(TOP_DIR)/src/hostif/parodusClient/startParodus/ - -if LIBSOUP3_ENABLE -COMMON_CPPFLAGS += -I/usr/include/libsoup-3.0 -DLIBSOUP3_ENABLE -else -COMMON_CPPFLAGS += -I/usr/include/libsoup-2.4 -endif +COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DUSE_DEV_PROPERTIES_CONF -DUSE_REMOTE_DEBUGGER -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I$(TOP_DIR)/src/hostif/handlers/include -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/hostif/httpserver/include -I$(TOP_DIR)/src/hostif/handlers/src -I/usr/include/rbus -I/usr/local/include/rbus -Isrc/unittest/stubs/rbus/include/ -I$(TOP_DIR)/src/hostif/profiles/Time -I$(TOP_DIR)/src/hostif/profiles/Device -I$(TOP_DIR)/src/hostif/profiles/IP -I$(TOP_DIR)/src/hostif/profiles/STBService -I/usr/rdk-halif-device_settings/include/ -I/usr/rdkvhal-devicesettings-raspberrypi4/ -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -I$(TOP_DIR)/src/hostif/profiles/Ethernet -I/usr/remote_debugger/src/ -I/usr/local/include/libparodus/ -I/usr/local/include/wrp-c/ -I$(TOP_DIR)/src/hostif/parodusClient/startParodus/ -I/usr/include/libsoup-3.0 # Define the libraries to link against -COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl -lglib-2.0 -llibparodus -lwrp-c -lnanomsg -lmsgpackc -ltrower-base64 -lcimplog - -if LIBSOUP3_ENABLE -COMMON_LDADD += -lsoup-3.0 -endif +COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl -lglib-2.0 -llibparodus -lwrp-c -lnanomsg -lmsgpackc -ltrower-base64 -lcimplog -lsoup-3.0 # Define the compiler flags COMMON_CXXFLAGS = -frtti $(GLIB_CFLAGS) -fprofile-arcs -ftest-coverage diff --git a/src/hostif/parodusClient/gtest/dm_test.cpp b/src/hostif/parodusClient/gtest/dm_test.cpp index ade9dc19c..83f6dba14 100644 --- a/src/hostif/parodusClient/gtest/dm_test.cpp +++ b/src/hostif/parodusClient/gtest/dm_test.cpp @@ -19,6 +19,7 @@ #include #include #include +#include #include "dm_stubs.h" #include "startParodus.h" #include "file_writer.h" @@ -31,6 +32,9 @@ #include "hostIf_tr69ReqHandler.h" #include "hostIf_utils.h" #include "wrp-c.h" +#include "hostIf_msgHandler.h" +#include "Device_DeviceInfo_ProcessStatus_Process.h" +#include "cJSON.h" #include "waldb.h" #include "wdmp-c.h" @@ -56,12 +60,19 @@ GError *httpError = NULL; GHashTable* paramMgrhash = NULL; T_ARGLIST argList = {{'\0'}, 0}; +typedef struct { + char name[512]; + char value[512]; + int statusCode; + char message[512]; +} ParsedResult; + #ifdef GTEST_ENABLE extern void (*macToLowerFunc())(char macValue[],char macConverted[]); extern WDMP_STATUS (*GetParamInfoFunc()) (const char *pParameterName, param_t ***parametervalPtrPtr, int *paramCountPtr,int paramIndex); extern rbusValueType_t (*getRbusDataTypefromWebPAFunc())(WAL_DATA_TYPE type); extern DATA_TYPE (*mapRbusDataTypeToWebPAFunc())(rbusValueType_t type); -WDMP_STATUS (*get_ParamValues_tr69hostIfFunc()) (HOSTIF_MsgData_t *ptrParam); +WDMP_STATUS (*get_ParamValues_tr69hostIfFunc()) (HOSTIF_MsgData_t *ptrParam, DataModelParam *dmParam); WAL_STATUS (*set_ParamValues_tr69hostIfFunc()) (HOSTIF_MsgData_t *ptrParam); WAL_STATUS (*convertFaultCodeToWalStatusFunc())(faultCode_t faultCode); extern void (*converttohostIfTypeFunc())(char *ParamDataType,HostIf_ParamType_t* pParamType); @@ -74,8 +85,53 @@ extern WAL_STATUS (*getParamAttributesFunc()) (const char *pParameterName, AttrV extern WAL_STATUS (*setParamAttributesFunc()) (const char *pParameterName, const AttrVal *attArr); extern void (*setRebootReasonFunc()) (param_t param, WEBPA_SET_TYPE setType); extern long (*timeValDiffFunc()) (struct timespec *starttime, struct timespec *finishtime); +extern WDMP_STATUS (*rbusGetParamInfoFunc()) (const char *pParameterName, param_t ***parametervalPtrPtr, int *paramCountPtr, int index); +extern WAL_STATUS (*rbusSetParamInfoFunc()) (ParamVal paramVal, char * transactionID); +extern WAL_STATUS (*SetParamInfoFunc()) (ParamVal paramVal, char * transactionID); +void (*parodus_receive_waitFunc()) (); #endif +int parse_json(char *json_str, ParsedResult *result) { + cJSON *root = cJSON_Parse(json_str); + if (!root) return 0; // parse error + + cJSON *statusCode = cJSON_GetObjectItem(root, "statusCode"); + if (cJSON_IsNumber(statusCode)) { + result->statusCode = statusCode->valueint; + } else { + cJSON_Delete(root); + return 0; + } + + cJSON *parameters = cJSON_GetObjectItem(root, "parameters"); + if (cJSON_IsArray(parameters)) { + cJSON *param = cJSON_GetArrayItem(parameters, 0); + if (param) { + cJSON *name = cJSON_GetObjectItem(param, "name"); + cJSON *value = cJSON_GetObjectItem(param, "value"); + cJSON *message = cJSON_GetObjectItem(param, "message"); + + if (cJSON_IsString(name)) { + strncpy(result->name, name->valuestring, sizeof(result->name) - 1); + result->name[sizeof(result->name) - 1] = '\0'; + } + + if (cJSON_IsString(value)) { + strncpy(result->value, value->valuestring, sizeof(result->value) - 1); + result->value[sizeof(result->value) - 1] = '\0'; + } + + if (cJSON_IsString(message)) { + strncpy(result->message, message->valuestring, sizeof(result->message) - 1); + result->message[sizeof(result->message) - 1] = '\0'; + } + } + } + + cJSON_Delete(root); + return 1; // success +} + TEST(datamodelTest, ParameterExistPositive2) { /* Load the data model xml file*/ @@ -248,6 +304,28 @@ TEST(datamodelTest, getChildParamNamesFromDataModel) { EXPECT_EQ(status, DB_SUCCESS); } +TEST(datamodelTest, getChildParamNamesFromDataModel_InvalidParam) { + + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + + char *ParamList = NULL; + char *ParamDataTypeList = NULL; + + char *paramName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.FriendlyName"; + int paramCount = 1; + DB_STATUS status = getChildParamNamesFromDataModel(getDataModelHandle(), paramName, &ParamList, &ParamDataTypeList, ¶mCount); + EXPECT_EQ(status, 2); +} + TEST(datamodelTest, checkDataModelStatus) { DB_STATUS status = checkDataModelStatus(); EXPECT_EQ(status, DB_SUCCESS); @@ -267,12 +345,32 @@ TEST(startParodusTest, get_HWMAcAddress) { EXPECT_EQ(macAddr, "D452EEDEC6FA"); } +TEST(startParodusTest, get_PartnerId_Empty) { + write_on_file("/opt/www/authService/partnerId3.dat", ""); + std::string partnerId = get_PartnerId(); + EXPECT_EQ(partnerId, "*,"); +} + TEST(startParodusTest, get_PartnerId) { write_on_file("/opt/www/authService/partnerId3.dat", "sky"); std::string partnerId = get_PartnerId(); EXPECT_EQ(partnerId, "*,sky"); } +TEST(startParodusTest, get_PartnerId_Unknown) { + std::remove("/opt/www/authService/partnerId3.dat"); + write_on_file("/opt/www/authService/partnerId3.dat", "unknown"); + std::string partnerId = get_PartnerId(); + EXPECT_EQ(partnerId, "unknown"); + std::remove("/opt/www/authService/partnerId3.dat"); +} + +TEST(startParodusTest, get_RebootReason_Empty) { + write_on_file("/opt/secure/reboot/previousreboot.info", ""); + std::string reboot_reason = get_RebootReason(); + EXPECT_EQ(reboot_reason, ""); +} + TEST(startParodusTest, get_RebootReason) { std::string jsonData = "{\"reason\": \"PowerOnReset\", \"timestamp\": 1688914800}"; write_on_file("/opt/secure/reboot/previousreboot.info", jsonData); @@ -294,6 +392,14 @@ TEST(palTest, macToLower) { EXPECT_STREQ(macConverted, "a84a6388e9b5"); } +TEST(palTest, getnotifyparamList_Empty) { + setNotifyConfigurationFile("/tmp/empty.conf"); + char **notifyParamList = NULL; + int ptrnotifyListSize = 3; + int ret = getnotifyparamList(¬ifyParamList, &ptrnotifyListSize); + EXPECT_EQ(ret, -1); +} + TEST(palTest, getnotifyparamList) { const char* json_data = R"({"Notify":["Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Canary.wakeUpStart","Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Canary.wakeUpEnd"]})"; write_on_file("/tmp/notify.conf", json_data); @@ -304,11 +410,46 @@ TEST(palTest, getnotifyparamList) { EXPECT_EQ(ret, 0); } -TEST(palTest, getNotifySource) { +/* TEST(palTest, getParamAttributes_Canary) { + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); + + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + + const char *paramName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Canary.wakeUpStart"; + AttrVal **attributes = NULL; + int totalParams = 1; + + WAL_STATUS status = getParamAttributesFunc()(paramName, &attributes, &totalParams); + EXPECT_EQ(status, WAL_SUCCESS); +} */ + +TEST(palTest, getNotifySource_Empty) { + char* notificationSource = getNotifySource(); + EXPECT_EQ(0, 0); +} + +TEST(palTest, getNotifySource) { + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); char* notificationSource = getNotifySource(); EXPECT_EQ(0, 0); } +TEST(palTest, setNotifyConfigurationFile) { + setNotifyConfigurationFile(NULL); + EXPECT_EQ(0, 0); +} + TEST(palTest, getRbusDataTypefromWebPA) { EXPECT_EQ(getRbusDataTypefromWebPAFunc()(WAL_STRING), RBUS_STRING); EXPECT_EQ(getRbusDataTypefromWebPAFunc()(WAL_INT), RBUS_INT32); @@ -321,6 +462,7 @@ TEST(palTest, getRbusDataTypefromWebPA) { EXPECT_EQ(getRbusDataTypefromWebPAFunc()(WAL_FLOAT), RBUS_SINGLE); EXPECT_EQ(getRbusDataTypefromWebPAFunc()(WAL_DOUBLE), RBUS_DOUBLE); EXPECT_EQ(getRbusDataTypefromWebPAFunc()(WAL_BYTE), RBUS_BYTE); + EXPECT_EQ(getRbusDataTypefromWebPAFunc()(WAL_NONE), RBUS_STRING); } TEST(palTest, mapRbusDataTypeToWebPA) { @@ -349,7 +491,11 @@ TEST(palTest, get_ParamValues_tr69hostIf) { param.paramtype = hostIf_IntegerType; param.paramLen = sizeof(hostIf_IntegerType); - WDMP_STATUS status = get_ParamValues_tr69hostIfFunc()(¶m); + DataModelParam dmParam = {0}; + const char* dbParamName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.TopSpeed"; + int match = getParamInfoFromDataModel(getDataModelHandle(), dbParamName, &dmParam); + + WDMP_STATUS status = get_ParamValues_tr69hostIfFunc()(¶m, &dmParam); EXPECT_EQ(0, 0); } @@ -361,7 +507,7 @@ TEST(palTest, set_ParamValues_tr69hostIf) { param.bsUpdate = HOSTIF_NONE; param.requestor = HOSTIF_SRC_RFC; - put_boolean(param.paramValue, 13800); + put_int(param.paramValue, 13800); param.paramtype = hostIf_IntegerType; param.paramLen = sizeof(hostIf_IntegerType); @@ -402,10 +548,58 @@ TEST(palTest, converttohostIfType) { converttohostIfTypeFunc()("hexBinary", &pParamType); EXPECT_EQ(pParamType, hostIf_StringType); + + converttohostIfTypeFunc()("float", &pParamType); + EXPECT_EQ(pParamType, hostIf_StringType); } TEST(palTest, GetParamInfo) { + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + const char *pParameterName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MOCASSH.Enable"; + param_t** parameterval = (param_t**) calloc(1, sizeof(param_t*)); + EXPECT_NE(parameterval, nullptr); + int paramCountPtr = 0; + int index = 0; + WDMP_STATUS status = GetParamInfoFunc()(pParameterName, ¶meterval, ¶mCountPtr, index); + EXPECT_EQ(0, 0); +} + +TEST(palTest, GetParamInfo_UnsignedInt) { + + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + const char *pParameterName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.collectd.PortNumber"; + param_t** parameterval = (param_t**) calloc(1, sizeof(param_t*)); + EXPECT_NE(parameterval, nullptr); + int paramCountPtr = 0; + int index = 0; + WDMP_STATUS status = GetParamInfoFunc()(pParameterName, ¶meterval, ¶mCountPtr, index); + EXPECT_EQ(0, 0); +} + +TEST(palTest, GetParamInfo_String) { + + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); + DB_STATUS dbStatus = loadDataModel(); if(dbStatus != DB_SUCCESS) { @@ -425,6 +619,85 @@ TEST(palTest, GetParamInfo) { EXPECT_EQ(0, 0); } +TEST(palTest, SetParamInfoFunc_Bool) { + + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); + + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + ParamVal param; + param.name = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.IncrementalCDL.Enable"; + param.value = "false"; + param.type = WAL_BOOLEAN; + + char transactionID[] = "txn12344"; + + WAL_STATUS status = SetParamInfoFunc() (param, transactionID); + EXPECT_EQ(status, WAL_SUCCESS); +} + + +TEST(palTest, SetParamInfoFunc_Int) { + + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); + + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + ParamVal param; + param.name = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.LowSpeed"; + param.value = "14800"; + param.type = WAL_INT; + + char transactionID[] = "txn12344"; + + WAL_STATUS status = SetParamInfoFunc() (param, transactionID); + EXPECT_EQ(status, WAL_SUCCESS); +} + +TEST(palTest, SetParamInfoFunc_String) { + + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); + + DB_STATUS dbStatus = loadDataModel(); + if(dbStatus != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(dbStatus, DB_SUCCESS); + ParamVal param; + param.name = "Device.X_RDKCENTRAL-COM_T2.ReportProfiles"; + param.value = "TestProfiles"; + param.type = WAL_STRING; + + char transactionID[] = "txn12344"; + + WAL_STATUS status = SetParamInfoFunc() (param, transactionID); + EXPECT_EQ(status, WAL_SUCCESS); +} + TEST(palTest, GetWildParamInfo) { const char *pParameterName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit."; param_t **parametervalPtrPtr = (param_t**) calloc(3, sizeof(param_t*)); @@ -444,6 +717,46 @@ TEST(palTest, GetWildParamInfo) { parametervalPtrPtr = NULL; } +TEST(palTest, GetWildParamInfo_String) { + const char *pParameterName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger."; + param_t **parametervalPtrPtr = (param_t**) calloc(4, sizeof(param_t*)); + int paramCountPtr = 4; + int index = 0; + WDMP_STATUS status = GetParamInfoFunc()(pParameterName, ¶metervalPtrPtr, ¶mCountPtr, index); + EXPECT_EQ(status, WDMP_SUCCESS); + + for (int i = 0; i < 4; i++) { + if (parametervalPtrPtr[i]) { + // If parametervalPtrPtr[i] points to dynamically allocated memory, free it + free(parametervalPtrPtr[i]); + parametervalPtrPtr[i] = NULL; + } + } + free(parametervalPtrPtr); + parametervalPtrPtr = NULL; +} + + +TEST(palTest, get_parodus_url_EmptyConfigFileSetsDefaults) { + // Write empty config file + std::ofstream ofs("/etc/webpa_cfg.json"); + ofs.close(); + char parodus_url[64] = {'\0'}; + char client_url[64] = {'\0'}; + get_parodus_urlFunc()(parodus_url, client_url); + EXPECT_NE(parodus_url, ""); + EXPECT_NE(client_url, ""); +} + +TEST(palPdTest, get_parodus_url_MissingConfigFileSetsDefaults) { + unlink("/etc/webpa_cfg.json"); + char parodus_url[64] = {'\0'}; + char client_url[64] = {'\0'}; + get_parodus_urlFunc()(parodus_url, client_url); + EXPECT_NE(parodus_url, ""); + EXPECT_NE(client_url, ""); +} + TEST(palTest, get_parodus_url) { char parodus_url[256] = {0}; char client_url[256] = {0}; @@ -454,6 +767,16 @@ TEST(palTest, get_parodus_url) { EXPECT_STREQ(client_url, "tcp://127.0.0.1:6666"); } +/*TEST(LibPdTest, sendNotification_ValidPayloadSends) { + // This requires a mock/fake for libparodus_send, wrp_free_struct, etc. + // For now, ensure function does not crash with valid input + char payload[] = "{\"command\":\"GET\",\"names\":[\"Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.TopSpeed\"]}"; + char source[] = "source"; + char dest[] = "dest"; + sendNotification(payload, source, dest); + EXPECT_EQ(0, 0); +} */ + TEST(palTest, validate_parameter_wildcard) { param_t *params = (param_t *) malloc(sizeof(param_t) * 1); @@ -498,11 +821,9 @@ TEST(palTest, validate_parameter_NOT_Support) { free(params); } -TEST(palTest, processRequest_GET) { - // Initialize paramMgrhash if not already done - /*if (paramMgrhash == NULL) { - paramMgrhash = g_hash_table_new_full(g_str_hash, g_str_equal, free, free); - } */ +TEST(palTest, processRequest_GET) { + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); //Load the data model xml file DB_STATUS status = loadDataModel(); @@ -531,17 +852,50 @@ TEST(palTest, processRequest_GET) { processRequest((char*)wrp_msg->u.req.payload, (char*)wrp_msg->u.req.transaction_uuid, ((char **)(&(res_wrp_msg->u.req.payload)))); std::cout << "Response payload: " << (char*)res_wrp_msg->u.req.payload << std::endl; char *json_response = (char*)res_wrp_msg->u.req.payload; - EXPECT_EQ(0, 0); + + ParsedResult result = {0}; + if (parse_json(json_response, &result)) + { + EXPECT_EQ(result.statusCode, 200); + EXPECT_STREQ(result.message, "Success"); + EXPECT_STREQ(result.name, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.TopSpeed"); + EXPECT_STREQ(result.value, "1280000"); + } } +TEST(palTest, processRequest_GETWildCard) { + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); -TEST(palTest, processRequest_SET) { - // Initialize paramMgrhash if not already done - /* if (paramMgrhash == NULL) { - paramMgrhash = g_hash_table_new_full(g_str_hash, g_str_equal, free, free); - } */ + //Load the data model xml file + DB_STATUS status = loadDataModel(); + if(status != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(status, DB_SUCCESS); + wrp_msg_t *wrp_msg; + wrp_msg_t *res_wrp_msg; - // Load the data model xml file + wrp_msg = (wrp_msg_t *)malloc(sizeof(wrp_msg_t)); + res_wrp_msg = (wrp_msg_t *)malloc(sizeof(wrp_msg_t)); + memset(res_wrp_msg, 0, sizeof(wrp_msg_t)); + wrp_msg->msg_type = WRP_MSG_TYPE__REQ; + const char *payload = "{\"command\":\"GET_ATTRIBUTES\",\"attributes\":\"notify\",\"names\":[\"Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.\"]}"; + wrp_msg->u.req.payload = (void*)payload; + wrp_msg->u.req.payload_size = strlen((char*)wrp_msg->u.req.payload); + processRequest((char*)wrp_msg->u.req.payload, (char*)wrp_msg->u.req.transaction_uuid, ((char **)(&(res_wrp_msg->u.req.payload)))); + std::cout << "Response payload: " << (char*)res_wrp_msg->u.req.payload << std::endl; + char *json_response = (char*)res_wrp_msg->u.req.payload; + EXPECT_EQ(0, 0); +} + +TEST(palTest, processRequest_SET) { + // Load the data model xml file DB_STATUS status = loadDataModel(); if(status != DB_SUCCESS) { @@ -568,10 +922,38 @@ TEST(palTest, processRequest_SET) { processRequest((char*)wrp_msg->u.req.payload, (char*)wrp_msg->u.req.transaction_uuid, ((char **)(&(res_wrp_msg->u.req.payload)))); std::cout << "Response payload: " << (char*)res_wrp_msg->u.req.payload << std::endl; char *json_response = (char*)res_wrp_msg->u.req.payload; + + ParsedResult result = {0}; + if (parse_json(json_response, &result)) + { + EXPECT_EQ(result.statusCode, 200); + EXPECT_STREQ(result.message, "Success"); + EXPECT_STREQ(result.name, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.LogUpload.LogServerUrl"); + } +} + +TEST(srcTest, getCurrentTime) { + struct timespec ts; + getCurrentTime(&ts); + EXPECT_GT(ts.tv_sec, 0); + + EXPECT_GE(ts.tv_nsec, 0); + EXPECT_LT(ts.tv_nsec, 1000000000L); +} + +TEST(srcTest, setInitialNotifyConfigFile) { + std::remove("/tmp/notify.conf"); + const char* json_data = R"({"Notify":["Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.Enable","Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.TopSpeed"]})"; + write_on_file("/tmp/notify.conf", json_data); + char **notifyParamList = NULL; + int ptrnotifyListSize = 2; + setInitialNotifyConfigFile("/tmp/notify.conf"); + int ret = getnotifyparamList(¬ifyParamList, &ptrnotifyListSize); + setInitialNotify(); EXPECT_EQ(0, 0); } -TEST(palTest, get_AttribValues_tr69hostIf) { +/* TEST(palTest, get_AttribValues_tr69hostIf) { HOSTIF_MsgData_t param = { 0 }; memset(¶m,0,sizeof(HOSTIF_MsgData_t)); param.reqType = HOSTIF_GET; @@ -581,9 +963,12 @@ TEST(palTest, get_AttribValues_tr69hostIf) { WAL_STATUS status = get_AttribValues_tr69hostIfFunc()(¶m); EXPECT_EQ(status, WAL_ERR_INVALID_PARAM); -} +} */ TEST(palTest, set_AttribValues_tr69hostIf) { + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); + HOSTIF_MsgData_t param = { 0 }; memset(¶m,0,sizeof(HOSTIF_MsgData_t)); param.reqType = HOSTIF_SET; @@ -596,7 +981,7 @@ TEST(palTest, set_AttribValues_tr69hostIf) { param.paramLen = sizeof(hostIf_BooleanType); WAL_STATUS status = set_AttribValues_tr69hostIfFunc()(¶m); - EXPECT_EQ(status, 4); + EXPECT_EQ(status, WAL_SUCCESS); } TEST(palTest, getParamAttributes) { @@ -618,8 +1003,83 @@ TEST(palTest, setParamAttributes) { EXPECT_EQ(status, WAL_SUCCESS); } +TEST(palTest, setParamAttributes_notifyList) { + std::remove("/tmp/notify.conf"); + const char* json_data = R"({"Notify":["Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.Enable","Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.TopSpeed"]})"; + write_on_file("/tmp/notify.conf", json_data); + char **notifyParamList = NULL; + int ptrnotifyListSize = 3; + setNotifyConfigurationFile("/tmp/notify.conf"); + int ret = getnotifyparamList(¬ifyParamList, &ptrnotifyListSize); + const char *paramName = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.TopSpeed"; + AttrVal attr; + + attr.name = strdup("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.TopSpeed"); + attr.value = strdup("168000"); + + WAL_STATUS status = setParamAttributesFunc()(paramName, &attr); + EXPECT_EQ(status, WAL_SUCCESS); +} + +TEST(palTest, getAttributes) { + const char *paramNames[] = { + "Device.DeviceInfo.ModelName", + "Device.DeviceInfo.SerialNumber" + }; + unsigned int paramCount = sizeof(paramNames) / sizeof(paramNames[0]); + + money_trace_spans span = {0}; // Optional, or nullptr + + AttrVal **attrArray = nullptr; + int attrCount = 0; + WAL_STATUS status = WAL_FAILURE; + + getAttributes(paramNames, paramCount, &span, &attrArray, &attrCount, &status); + + EXPECT_EQ(status, 14); +} + +TEST(palTest, setAttributes) { + std::remove("/tmp/notify.conf"); + const char* json_data = R"({"Notify":["Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MOCASSH.Enable"]})"; + write_on_file("/tmp/notify.conf", json_data); + char **notifyParamList = NULL; + int ptrnotifyListSize = 1; + setNotifyConfigurationFile("/tmp/notify.conf"); + int ret = getnotifyparamList(¬ifyParamList, &ptrnotifyListSize); + + ParamVal params[1]; + params[0].name = strdup("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MOCASSH.Enable"); + params[0].value = strdup("true"); + params[0].type = WAL_BOOLEAN; + + unsigned int paramCount = 1; + money_trace_spans traceSpan = {0}; + AttrVal val1 = { (char *)"Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MOCASSH.Enable", (char *)"true", WAL_BOOLEAN }; + const AttrVal *attrList[1] = { &val1 }; + WDMP_STATUS* statuses = new WDMP_STATUS[1]; + + setAttributes(params, paramCount, &traceSpan, attrList, &statuses); + EXPECT_EQ(0, 0); +} + +/* TEST(webpaAdapterTest, setRebootReason) { + + strcpy(argList.confFile, "/etc/mgrlist.conf"); + bool ret = hostIf_initalize_ConfigManger(); + + //Load the data model xml file + DB_STATUS status = loadDataModel(); + if(status != DB_SUCCESS) + { + std::cout << "Error in Data Model Initialization" << std::endl; + } + else + { + std::cout << "Successfully initialize Data Model." << std::endl; + } + EXPECT_EQ(status, DB_SUCCESS); -TEST(webpaAdapterTest, setRebootReason) { // Prepare a param_t with the reboot parameter and value param_t param; param.name = strdup("Device.X_CISCO_COM_DeviceControl.RebootDevice"); @@ -635,8 +1095,20 @@ TEST(webpaAdapterTest, setRebootReason) { // L1: No assertion needed, just ensure no crash EXPECT_EQ(0, 0); +} */ + + +TEST(palTest, parodus_receive_waitFunc) { + parodus_receive_waitFunc(); + sleep(30); + stop_parodus_recv_wait(); + EXPECT_EQ(0, 0); } +TEST(palTest, stop_parodus_recv_wait) { + stop_parodus_recv_wait(); + EXPECT_EQ(0, 0); +} TEST(palTest, notificationCallBack) { notificationCallBack(); @@ -648,6 +1120,15 @@ TEST(palTest, setInitialNotify) { EXPECT_EQ(0, 0); } +TEST(palTest, libpd_set_notifyConfigFile) { + std::remove("/tmp/notify.conf"); const char* json_data = R"({"Notify":["Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.Enable","Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.TopSpeed"]})"; + write_on_file("/tmp/notify.conf", json_data); + char **notifyParamList = NULL; + int ptrnotifyListSize = 2; + libpd_set_notifyConfigFile("/tmp/notify.conf"); + EXPECT_EQ(0, 0); +} + TEST(palTest, registerNotifyCallback) { registerNotifyCallback(); EXPECT_EQ(0, 0); @@ -668,6 +1149,186 @@ TEST(palTest, timeValDiff) { EXPECT_EQ(msec, 1700); } +TEST(palTest, replaceWithInstanceNumber) { + char paramName[50] = "Device.DeviceInfo.XXXX.{i}"; + int instanceNumber = 3; + replaceWithInstanceNumber(paramName, instanceNumber); + EXPECT_STREQ(paramName, "Device.DeviceInfo.XXXX.{i}"); +} + +TEST(palTest, appendNextObject) { + char currentParam[100] = "Device.WiFi.{i}.SSID."; + const char* pAttparam = "Device.WiFi.{i}.SSID.Enable"; + appendNextObject(currentParam, pAttparam); + + EXPECT_STREQ(currentParam, "Device.WiFi.{i}.SSID.Enable"); +} + +TEST(palTest, test_get_complete_param_list) { + test_get_complete_param_list(); + EXPECT_EQ(0, 0); +} + +TEST(palTest, converttoWalType) { + WAL_DATA_TYPE walType = WAL_STRING; + + converttoWalTypeFunc()(hostIf_IntegerType, &walType); + EXPECT_EQ(walType, WAL_INT); + + converttoWalTypeFunc()(hostIf_UnsignedIntType, &walType); + EXPECT_EQ(walType, WAL_UINT); + + converttoWalTypeFunc()(hostIf_BooleanType, &walType); + EXPECT_EQ(walType, WAL_BOOLEAN); + + converttoWalTypeFunc()(hostIf_UnsignedLongType, &walType); + EXPECT_EQ(walType, WAL_ULONG); + + converttoWalTypeFunc()(hostIf_DateTimeType, &walType); + EXPECT_EQ(walType, WAL_DATETIME); +} + +TEST(palTest, rbusSetParamInfo) { + ParamVal param; + param.name = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.FWUpdate.Enable"; + param.value = "true"; + param.type = WAL_BOOLEAN; + + char transactionID[] = "txn12345"; + + WAL_STATUS status = rbusSetParamInfoFunc() (param, transactionID); + EXPECT_EQ(status, WAL_SUCCESS); +} + +TEST(palTest, getnotifyparamList_NULL) { + char **dummyList = NULL; + int result = getnotifyparamList(&dummyList, NULL); + EXPECT_EQ(result, -1); + + int dummySize = 0; + int ret = getnotifyparamList(NULL, &dummySize); + EXPECT_EQ(ret, -1); +} + +TEST(ProcessStatus, DeviceInfo_ProcessStatus_Process_PID) { + HOSTIF_MsgData_t param; + bool bChanged; + int instanceNumber = 0; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.ProcessStatus.Process.1.PID", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceProcess *hostIf_DeviceProcess = hostIf_DeviceProcess::getInstance(instanceNumber); + if(hostIf_DeviceProcess) + { + bChanged = false; + int ret = hostIf_DeviceProcess->get_Device_DeviceInfo_ProcessStatus_Process_PID(¶m, &bChanged); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, -1); + } +} + +TEST(ProcessStatus, DeviceInfo_ProcessStatus_Process_Command) { + HOSTIF_MsgData_t param; + bool bChanged; + int instanceNumber = 0; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.ProcessStatus.Process.1.Command", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceProcess *hostIf_DeviceProcess = hostIf_DeviceProcess::getInstance(instanceNumber); + if(hostIf_DeviceProcess) + { + bChanged = false; + int ret = hostIf_DeviceProcess->get_Device_DeviceInfo_ProcessStatus_Process_PID(¶m, &bChanged); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, -1); + } +} + +TEST(ProcessStatus, DeviceInfo_ProcessStatus_Process_Size) { + HOSTIF_MsgData_t param; + bool bChanged; + int instanceNumber = 0; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.ProcessStatus.Process.1.Size", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceProcess *hostIf_DeviceProcess = hostIf_DeviceProcess::getInstance(instanceNumber); + if(hostIf_DeviceProcess) + { + bChanged = false; + int ret = hostIf_DeviceProcess->get_Device_DeviceInfo_ProcessStatus_Process_PID(¶m, &bChanged); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, -1); + } +} + +TEST(ProcessStatus, DeviceInfo_ProcessStatus_Process_Priority) { + HOSTIF_MsgData_t param; + bool bChanged; + int instanceNumber = 0; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.ProcessStatus.Process.1.Priority", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceProcess *hostIf_DeviceProcess = hostIf_DeviceProcess::getInstance(instanceNumber); + if(hostIf_DeviceProcess) + { + bChanged = false; + int ret = hostIf_DeviceProcess->get_Device_DeviceInfo_ProcessStatus_Process_PID(¶m, &bChanged); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, -1); + } +} + +TEST(ProcessStatus, DeviceInfo_ProcessStatus_Process_CPUTime) { + HOSTIF_MsgData_t param; + bool bChanged; + int instanceNumber = 0; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.ProcessStatus.Process.1.CPUTime", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceProcess *hostIf_DeviceProcess = hostIf_DeviceProcess::getInstance(instanceNumber); + if(hostIf_DeviceProcess) + { + bChanged = false; + int ret = hostIf_DeviceProcess->get_Device_DeviceInfo_ProcessStatus_Process_PID(¶m, &bChanged); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, -1); + } +} + +TEST(ProcessStatus, DeviceInfo_ProcessStatus_Process_State) { + HOSTIF_MsgData_t param; + bool bChanged; + int instanceNumber = 0; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.ProcessStatus.Process.1.State", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceProcess *hostIf_DeviceProcess = hostIf_DeviceProcess::getInstance(instanceNumber); + if(hostIf_DeviceProcess) + { + bChanged = false; + int ret = hostIf_DeviceProcess->get_Device_DeviceInfo_ProcessStatus_Process_PID(¶m, &bChanged); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, -1); + } +} GTEST_API_ int main(int argc, char *argv[]){ char testresults_fullfilepath[GTEST_REPORT_FILEPATH_SIZE]; diff --git a/src/hostif/parodusClient/pal/libpd.cpp b/src/hostif/parodusClient/pal/libpd.cpp index 7e258f252..d21935651 100644 --- a/src/hostif/parodusClient/pal/libpd.cpp +++ b/src/hostif/parodusClient/pal/libpd.cpp @@ -461,4 +461,10 @@ long (*timeValDiffFunc()) (struct timespec *starttime, struct timespec *finishti { return &timeValDiff; } + +void (*parodus_receive_waitFunc()) () +{ + return &parodus_receive_wait; +} + #endif diff --git a/src/hostif/parodusClient/pal/webpa_parameter.cpp b/src/hostif/parodusClient/pal/webpa_parameter.cpp index 0cf204bc9..9ef5b0987 100644 --- a/src/hostif/parodusClient/pal/webpa_parameter.cpp +++ b/src/hostif/parodusClient/pal/webpa_parameter.cpp @@ -660,7 +660,7 @@ static WDMP_STATUS get_ParamValues_tr69hostIf(HOSTIF_MsgData_t *ptrParam, DataMo status = hostIf_GetMsgHandler(ptrParam); if(status != 0) { - if (dmParam->defaultValue) + if (dmParam != NULL && dmParam->defaultValue) { strncpy(ptrParam->paramValue, dmParam->defaultValue, MAX_PARAM_LENGTH - 1); ptrParam->paramValue[MAX_PARAM_LENGTH - 1] = '\0'; @@ -811,7 +811,8 @@ DATA_TYPE (*mapRbusDataTypeToWebPAFunc()) (rbusValueType_t type) { return &mapRbusDataTypeToWebPA; } -WDMP_STATUS (*get_ParamValues_tr69hostIfFunc()) (HOSTIF_MsgData_t *ptrParam) + +WDMP_STATUS (*get_ParamValues_tr69hostIfFunc()) (HOSTIF_MsgData_t *ptrParam, DataModelParam *dmParam) { return &get_ParamValues_tr69hostIf; } @@ -833,6 +834,21 @@ void (*converttohostIfTypeFunc())(char *ParamDataType,HostIf_ParamType_t* pParam void (*converttoWalTypeFunc())(HostIf_ParamType_t paramType,WAL_DATA_TYPE* pwalType) { - &converttoWalType; + return &converttoWalType; +} + +WDMP_STATUS (*rbusGetParamInfoFunc()) (const char *pParameterName, param_t ***parametervalPtrPtr, int *paramCountPtr, int index) +{ + return &rbusGetParamInfo; +} + +WAL_STATUS (*rbusSetParamInfoFunc()) (ParamVal paramVal, char * transactionID) +{ + return &rbusSetParamInfo; +} + +WAL_STATUS (*SetParamInfoFunc()) (ParamVal paramVal, char * transactionID) +{ + return &SetParamInfo; } #endif diff --git a/src/hostif/parodusClient/waldb/waldb.h b/src/hostif/parodusClient/waldb/waldb.h index bc729434c..94cd823ac 100644 --- a/src/hostif/parodusClient/waldb/waldb.h +++ b/src/hostif/parodusClient/waldb/waldb.h @@ -90,6 +90,9 @@ int isParamEndsWithInstance(const char* paramName); int getNumberOfDigitsInInstanceNumber(const char* paramName,int position); int getNumberofInstances(const char* paramName); int checkMatchingParameter(const char* attrValue, char* paramName, int* ret); +void replaceWithInstanceNumber(char *paramName, int instanceNumber); +void appendNextObject(char* currentParam, const char* pAttparam); +void test_get_complete_param_list(); #endif #ifdef __cplusplus diff --git a/src/hostif/profiles/DHCPv4/Device_DHCPv4_Client.h b/src/hostif/profiles/DHCPv4/Device_DHCPv4_Client.h index 566fce180..4edf4d995 100644 --- a/src/hostif/profiles/DHCPv4/Device_DHCPv4_Client.h +++ b/src/hostif/profiles/DHCPv4/Device_DHCPv4_Client.h @@ -181,6 +181,9 @@ class hostIf_DHCPv4Client { #if defined(GTEST_ENABLE) FRIEND_TEST(dhcpv4Test, isValidIPAddr); + FRIEND_TEST(dhcpv4Test, InvalidIPAddr); + FRIEND_TEST(dhcpv4Test, InvalidIP); + FRIEND_TEST(dhcpv4Test, InvalidIPAddr_alpha); FRIEND_TEST(dhcpv4Test, getInterfaceName); FRIEND_TEST(dhcpv4Test, isIfnameInroutetoDNSServer); #endif diff --git a/src/hostif/profiles/DHCPv4/gtest/Makefile.am b/src/hostif/profiles/DHCPv4/gtest/Makefile.am index c0b47692c..d0d878001 100644 --- a/src/hostif/profiles/DHCPv4/gtest/Makefile.am +++ b/src/hostif/profiles/DHCPv4/gtest/Makefile.am @@ -21,20 +21,10 @@ AUTOMAKE_OPTIONS = subdir-objects bin_PROGRAMS = dhcpv4_gtest # Define the include directories -COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DYOCTO_BUILD -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/handlers/include -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/profiles/IP -I$(TOP_DIR)/src/hostif/profiles/DHCPv4 -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I/usr/include/rbus -I/usr/local/include/rbus $(GLIB_CFLAGS) $(G_THREAD_CFLAGS) - -if LIBSOUP3_ENABLE -COMMON_CPPFLAGS += -I/usr/include/libsoup-3.0 -DLIBSOUP3_ENABLE -else -COMMON_CPPFLAGS += -I/usr/include/libsoup-2.4 -endif +COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DYOCTO_BUILD -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/handlers/include -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/profiles/IP -I$(TOP_DIR)/src/hostif/profiles/DHCPv4 -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I/usr/include/rbus -I/usr/local/include/rbus $(GLIB_CFLAGS) $(G_THREAD_CFLAGS) -I/usr/include/libsoup-3.0 # Define the libraries to link against -COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl - -if LIBSOUP3_ENABLE -COMMON_LDADD += -lsoup-3.0 -endif +COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl -lsoup-3.0 # Define the compiler flags COMMON_CXXFLAGS = -frtti $(GLIB_CFLAGS) $(SOUP_LIBS) -fprofile-arcs -ftest-coverage diff --git a/src/hostif/profiles/DHCPv4/gtest/gtest_dhcpv4.cpp b/src/hostif/profiles/DHCPv4/gtest/gtest_dhcpv4.cpp index 85138893b..07677f5b8 100644 --- a/src/hostif/profiles/DHCPv4/gtest/gtest_dhcpv4.cpp +++ b/src/hostif/profiles/DHCPv4/gtest/gtest_dhcpv4.cpp @@ -36,9 +36,10 @@ using namespace std; +#define IFNAMSIZ 16 TEST(dhcpv4Test, isValidIPAddr) { - int instanceNumber = 0; + int instanceNumber = 1; char* addr = (char*)"192.168.1.1"; hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); if(dhcpClient) @@ -48,19 +49,53 @@ TEST(dhcpv4Test, isValidIPAddr) { } } +TEST(dhcpv4Test, InvalidIPAddr) { + int instanceNumber = 1; + char* addr = (char*)"192.168.1.1.1"; + hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); + if(dhcpClient) + { + bool result = dhcpClient->isValidIPAddr(addr); + EXPECT_EQ(result, false); + } +} + +TEST(dhcpv4Test, InvalidIP) { + int instanceNumber = 1; + char* addr = (char*)"192.168.256.1"; + hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); + if(dhcpClient) + { + bool result = dhcpClient->isValidIPAddr(addr); + EXPECT_EQ(result, false); + } +} + +TEST(dhcpv4Test, InvalidIPAddr_alpha) { + int instanceNumber = 1; + char* addr = (char*)"192.168.a.1"; + hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); + if(dhcpClient) + { + bool result = dhcpClient->isValidIPAddr(addr); + EXPECT_EQ(result, false); + } +} + TEST(dhcpv4Test, getInterfaceName) { - int instanceNumber = 0; - char *ifname = (char*)"eth0"; + int instanceNumber = 1; + char ifname[IFNAMSIZ]={'\0'}; hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); if(dhcpClient) { int result = dhcpClient->getInterfaceName(ifname); - EXPECT_EQ(result, -1); + EXPECT_EQ(result, OK); } } -TEST(dhcpv4Test, isIfnameInroutetoDNSServer) { - int instanceNumber = 0; + +/* TEST(dhcpv4Test, isIfnameInroutetoDNSServer) { + int instanceNumber = 1; char* dnsServer = (char*)"8.8.8.8"; char* ifname = (char*)"eth0"; hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); @@ -69,21 +104,83 @@ TEST(dhcpv4Test, isIfnameInroutetoDNSServer) { bool result = dhcpClient->isIfnameInroutetoDNSServer(dnsServer, ifname); EXPECT_EQ(result, true); } -} +} */ TEST(dhcpv4Test, get_Device_DHCPv4_ClientNumberOfEntries) { - int instanceNumber = 0; + int instanceNumber = 1; HOSTIF_MsgData_t param = { 0 }; memset(¶m,0,sizeof(HOSTIF_MsgData_t)); hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); if(dhcpClient) { int result = dhcpClient->get_Device_DHCPv4_ClientNumberOfEntries(¶m); + cout << "param.paramValue = " << param.paramValue << endl; EXPECT_EQ(result, OK); EXPECT_EQ(param.paramtype, hostIf_UnsignedIntType); } } +TEST(dhcpv4Test, get_Device_DHCPv4_Client_IPRouters) { + int instanceNumber = 1; + bool bChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); + if(dhcpClient) + { + bChanged = false; + int result = dhcpClient->get_Device_DHCPv4_Client_IPRouters(¶m, &bChanged); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(result, OK); + EXPECT_EQ(param.paramtype, hostIf_StringType); + } +} + +TEST(dhcpv4Test, get_Device_DHCPv4_Client_DnsServer) { + int instanceNumber = 1; + bool bChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); + if(dhcpClient) + { + bChanged = false; + int result = dhcpClient->get_Device_DHCPv4_Client_DnsServer(¶m, &bChanged); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(result, OK); + EXPECT_EQ(param.paramtype, hostIf_StringType); + } +} + +TEST(dhcpv4Test, get_Device_DHCPv4_Client_InterfaceReference) { + int instanceNumber = 1; + bool bChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); + if(dhcpClient) + { + bChanged = false; + int result = dhcpClient->get_Device_DHCPv4_Client_InterfaceReference(¶m, &bChanged); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(result, OK); + EXPECT_EQ(param.paramtype, hostIf_StringType); + } +} + +TEST(dhcpv4Test, Lock_ReleaseLock) { + int instanceNumber = 1; + hostIf_DHCPv4Client *dhcpClient= hostIf_DHCPv4Client::getInstance(instanceNumber); + if(dhcpClient) + { + dhcpClient->getLock(); + dhcpClient->releaseLock(); + EXPECT_EQ(0, 0); + } + dhcpClient->closeInstance(dhcpClient); + dhcpClient->closeAllInstances(); +} + GTEST_API_ int main(int argc, char *argv[]){ char testresults_fullfilepath[GTEST_REPORT_FILEPATH_SIZE]; char buffer[GTEST_REPORT_FILEPATH_SIZE]; diff --git a/src/hostif/profiles/Device/gtest/Makefile.am b/src/hostif/profiles/Device/gtest/Makefile.am index f81e27d44..44b882747 100644 --- a/src/hostif/profiles/Device/gtest/Makefile.am +++ b/src/hostif/profiles/Device/gtest/Makefile.am @@ -21,20 +21,10 @@ AUTOMAKE_OPTIONS = subdir-objects bin_PROGRAMS = device_gtest # Define the include directories -COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DPARODUS -DUNIT_TEST -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/handlers/include -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/profiles/IP -I$(TOP_DIR)/src/hostif/profiles/Device -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I/usr/include/rbus -I/usr/local/include/rbus $(GLIB_CFLAGS) $(G_THREAD_CFLAGS) - -if LIBSOUP3_ENABLE -COMMON_CPPFLAGS += -I/usr/include/libsoup-3.0 -DLIBSOUP3_ENABLE -else -COMMON_CPPFLAGS += -I/usr/include/libsoup-2.4 -endif +COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DPARODUS -DUNIT_TEST -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/handlers/include -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/profiles/IP -I$(TOP_DIR)/src/hostif/profiles/Device -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I/usr/include/rbus -I/usr/local/include/rbus $(GLIB_CFLAGS) $(G_THREAD_CFLAGS) -I/usr/include/libsoup-3.0 # Define the libraries to link against -COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl - -if LIBSOUP3_ENABLE -COMMON_LDADD += -lsoup-3.0 -endif +COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl -lsoup-3.0 # Define the compiler flags COMMON_CXXFLAGS = -frtti $(GLIB_CFLAGS) $(SOUP_LIBS) -fprofile-arcs -ftest-coverage diff --git a/src/hostif/profiles/Device/gtest/gtest_device.cpp b/src/hostif/profiles/Device/gtest/gtest_device.cpp index 4d1bc0a7b..f4995fef8 100644 --- a/src/hostif/profiles/Device/gtest/gtest_device.cpp +++ b/src/hostif/profiles/Device/gtest/gtest_device.cpp @@ -160,6 +160,64 @@ TEST(DeviceTest, set_WebPA_DNSText_URL) { } } +TEST(DeviceTest, handleGetMsg_WebPA_Server_URL) { + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.X_RDK_WebPA_Server.URL", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + X_rdk_profile* profile = X_rdk_profile::getInstance(); + if(profile) + { + int ret = profile->handleGetMsg(¶m); + std::string value = getStringValue(¶m); + EXPECT_EQ(ret, OK); + EXPECT_EQ(value, ""); + } +} + +TEST(DeviceTest, handleSetMsg_InvalidParam) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.FriendlyName.URL", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + + X_rdk_profile* profile = X_rdk_profile::getInstance(); + if(profile) + { + int ret = profile->handleSetMsg(¶m); + EXPECT_EQ(ret, NOK); + EXPECT_EQ(param.faultCode, fcInvalidParameterName); + } +} + +TEST(DeviceTest, handleGetMsg_InvalidParam) { + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.FriendlyName.URL", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_WEBPA; + param.paramtype = hostIf_StringType; + param.paramLen = sizeof(hostIf_StringType); + + X_rdk_profile* profile = X_rdk_profile::getInstance(); + if(profile) + { + int ret = profile->handleGetMsg(¶m); + EXPECT_EQ(ret, NOK); + EXPECT_EQ(param.faultCode, fcInvalidParameterName); + } + profile->closeInstance(); +} + GTEST_API_ int main(int argc, char *argv[]){ char testresults_fullfilepath[GTEST_REPORT_FILEPATH_SIZE]; char buffer[GTEST_REPORT_FILEPATH_SIZE]; diff --git a/src/hostif/profiles/DeviceInfo/Device_DeviceInfo.cpp b/src/hostif/profiles/DeviceInfo/Device_DeviceInfo.cpp index 4dacf35c1..186d79224 100644 --- a/src/hostif/profiles/DeviceInfo/Device_DeviceInfo.cpp +++ b/src/hostif/profiles/DeviceInfo/Device_DeviceInfo.cpp @@ -1742,31 +1742,25 @@ int hostIf_DeviceInfo::get_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareFilename(H } if(line.length()) { - char * cstr = new char [line.length()+1]; - rc=strcpy_s (cstr,(line.length()+1), line.c_str()); - if(rc!=EOK) + std::string::size_type pos = line.find(':'); + if (pos == std::string::npos) { - ERR_CHK(rc); + return NOK; } - char * pch = NULL; - pch = strstr (cstr,":"); - pch++; - - while(isspace(*pch)) { - pch++; - } - delete[] cstr; - - if(bCalledX_COMCAST_COM_FirmwareFilename && pChanged && strncmp(pch,backupX_COMCAST_COM_FirmwareFilename,_BUF_LEN_64 )) + std::string value = line.substr(pos + 1); + value.erase(0, value.find_first_not_of(" \t")); + + if(bCalledX_COMCAST_COM_FirmwareFilename && pChanged && strncmp(value.c_str(),backupX_COMCAST_COM_FirmwareFilename,_BUF_LEN_64 )) { *pChanged = true; } bCalledX_COMCAST_COM_FirmwareFilename = true; - strncpy(backupX_COMCAST_COM_FirmwareFilename,pch,sizeof(backupX_COMCAST_COM_FirmwareFilename) -1); //CID:136569 - Buffer size + strncpy(backupX_COMCAST_COM_FirmwareFilename,value.c_str(),sizeof(backupX_COMCAST_COM_FirmwareFilename) -1); //CID:136569 - Buffer size backupX_COMCAST_COM_FirmwareFilename[sizeof(backupX_COMCAST_COM_FirmwareFilename) -1] = '\0'; - strncpy(stMsgData->paramValue,pch,_BUF_LEN_64 ); - strncpy((char *) stMsgData->paramValue, pch, stMsgData->paramLen +1 ); + strncpy((char *) stMsgData->paramValue, value.c_str(), sizeof(stMsgData->paramValue)-1); + stMsgData->paramValue[sizeof(stMsgData->paramValue)-1] = '\0'; + stMsgData->paramLen = value.length(); } } @@ -5866,6 +5860,13 @@ int hostIf_DeviceInfo::set_xRDKDownloadManager_DownloadStatus(HOSTIF_MsgData_t * return ret; } #endif + +#ifdef GTEST_ENABLE +bool (*ValidateInput_ArgumentsFunc()) (char *input, FILE *tmp_fptr) +{ + return &ValidateInput_Arguments; +} +#endif /* End of doxygen group */ /** * @} diff --git a/src/hostif/profiles/DeviceInfo/Device_DeviceInfo.h b/src/hostif/profiles/DeviceInfo/Device_DeviceInfo.h index 6fd2b7294..8f8e9ee26 100644 --- a/src/hostif/profiles/DeviceInfo/Device_DeviceInfo.h +++ b/src/hostif/profiles/DeviceInfo/Device_DeviceInfo.h @@ -318,6 +318,8 @@ class hostIf_DeviceInfo { FRIEND_TEST(deviceTest, NewNtpEnable); FRIEND_TEST(deviceTest, set_xRDKCentralComRFCLoudnessEquivalenceEnable); FRIEND_TEST(deviceTest, set_xRDKCentralComXREContainerRFCEnable); + FRIEND_TEST(deviceTest, set_xRDKCentralComXREContainerRFCDisable); + FRIEND_TEST(deviceTest, set_xRDKCentralComXREContainerRFCInvalidtype); FRIEND_TEST(deviceTest, set_xOpsRPCRebootPendingNotification); FRIEND_TEST(deviceTest, set_xRDKCentralComApparmorBlocklist); FRIEND_TEST(deviceTest, set_xOpsRPCFwDwldCompletedNotification); @@ -332,6 +334,7 @@ class hostIf_DeviceInfo { FRIEND_TEST(deviceTest, get_xOpsRPCFwDwldCompletedNotification); FRIEND_TEST(deviceTest, set_xOpsRPCRebootPendingNotification); FRIEND_TEST(deviceTest, set_xRDKCentralComNewNtpEnable); + FRIEND_TEST(deviceTest, NewNtpEnable_Disable); FRIEND_TEST(deviceTest, findLocalPortAvailable); FRIEND_TEST(deviceTest, get_xOpsRPCRebootPendingNotification); FRIEND_TEST(deviceTest, get_xOpsRPCFwDwldStartedNotification); @@ -340,6 +343,15 @@ class hostIf_DeviceInfo { FRIEND_TEST(deviceTest, set_xRDKCentralComRFCLoudnessEquivalenceEnable); FRIEND_TEST(deviceTest, set_xOpsDeviceMgmtRPCRebootNow); FRIEND_TEST(deviceTest, set_xRDKCentralComDABRFCEnable); + FRIEND_TEST(deviceTest, set_xRDKCentralComDABRFCDisable); + FRIEND_TEST(deviceTest, set_xRDKCentralComDABRFCInvalidtype); + FRIEND_TEST(deviceTest, get_xOpsRPCDevManageableNotification); + FRIEND_TEST(deviceTest, set_xRDKCentralComRFCRoamTrigger); + FRIEND_TEST(deviceTest, set_xRDKCentralComRFCLoudnessEquivalenceEnable_InvalidType); + FRIEND_TEST(deviceTest, set_xRDKCentralComRFCAutoRebootEnable_Invalidtype); + FRIEND_TEST(deviceTest, set_xRDKCentralComXREContainerRFCEnable_FileRemoved); + FRIEND_TEST(deviceTest, NewNtpEnable_Disable_FileRemoved); + FRIEND_TEST(deviceTest, get_xRDKCentralComRFCAccountId); #endif public: diff --git a/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStore.h b/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStore.h index 5b18fd5da..918cafa21 100755 --- a/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStore.h +++ b/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStore.h @@ -84,8 +84,13 @@ class XBSStore FRIEND_TEST(bsStoreTest, getRawValue); FRIEND_TEST(bsStoreTest, setRawValue); FRIEND_TEST(bsStoreTest, initBSPropertiesFileName); - FRIEND_TEST(bsClearTest, resetCacheAndStore); - FRIEND_TEST(bsClearTest, clearRfcValues); + FRIEND_TEST(StoreClearTest, resetCacheAndStore); + FRIEND_TEST(StoreClearTest, clearRfcValues); + FRIEND_TEST(bsStoreTest, getPartnerDeviceConfig); + FRIEND_TEST(bsStoreTest, getPartnerDeviceConfig_generic); + FRIEND_TEST(bsStoreTest, getPartnerDeviceConfig_FileRemoved); + FRIEND_TEST(bsStoreTest, getRawValue_Empty); + FRIEND_TEST(StoreClearTest, setRawValue_Flush); #endif }; diff --git a/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStoreJournal.h b/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStoreJournal.h index 508abfc25..8e6b4d51a 100755 --- a/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStoreJournal.h +++ b/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStoreJournal.h @@ -82,6 +82,8 @@ class XBSStoreJournal FRIEND_TEST(bsStoreJournalTest, getBuildTime); FRIEND_TEST(bsStoreJournalTest, resetClearRfc); FRIEND_TEST(bsStoreJournalTest, clearRfcAndGetDefaultValue); + FRIEND_TEST(bsStoreJournalTest, constructor); + FRIEND_TEST(bsStoreJournalTest, getBuildTime_Version); #endif }; diff --git a/src/hostif/profiles/DeviceInfo/XrdkCentralComRFC.cpp b/src/hostif/profiles/DeviceInfo/XrdkCentralComRFC.cpp index 7268e9140..a63a0114e 100644 --- a/src/hostif/profiles/DeviceInfo/XrdkCentralComRFC.cpp +++ b/src/hostif/profiles/DeviceInfo/XrdkCentralComRFC.cpp @@ -99,7 +99,12 @@ bool XRFCStorage::init() // get the file path IniFile file; - file.load(RFC_PROPERTIES_FILE); + if(!file.load(RFC_PROPERTIES_FILE)) + { + RDK_LOG(RDK_LOG_INFO,LOG_TR69HOSTIF, "[%s] [%d] Failed to load file: %s\n", __FUNCTION__, __LINE__, RFC_PROPERTIES_FILE); + return false; + } + m_storageFile = file.value(TR181_RFC_STORE_KEY); if (m_storageFile.empty()) { diff --git a/src/hostif/profiles/DeviceInfo/XrdkCentralComRFC.h b/src/hostif/profiles/DeviceInfo/XrdkCentralComRFC.h index 7456c2397..fe3707451 100644 --- a/src/hostif/profiles/DeviceInfo/XrdkCentralComRFC.h +++ b/src/hostif/profiles/DeviceInfo/XrdkCentralComRFC.h @@ -48,6 +48,7 @@ class XRFCStorage #if defined(GTEST_ENABLE) FRIEND_TEST(rfcStorageTest, init); + FRIEND_TEST(StoreClearTest, init); #endif }; diff --git a/src/hostif/profiles/DeviceInfo/XrdkCentralComRFCStore.h b/src/hostif/profiles/DeviceInfo/XrdkCentralComRFCStore.h index 553fcb57d..dda061a4f 100644 --- a/src/hostif/profiles/DeviceInfo/XrdkCentralComRFCStore.h +++ b/src/hostif/profiles/DeviceInfo/XrdkCentralComRFCStore.h @@ -25,6 +25,10 @@ #include #include +#if defined(GTEST_ENABLE) +#include +#endif + using namespace std; #if defined(GTEST_ENABLE) @@ -65,6 +69,16 @@ class XRFCStore void initTR181PropertiesFileName(); bool loadFileToCache(const string &filename, unordered_map &dict); bool loadTR181PropertiesIntoCache(); + +#if defined(GTEST_ENABLE) + FRIEND_TEST(rfcStoreTest, getRawValue); + FRIEND_TEST(rfcStoreTest, getRawValue_NONPERSISTENT_FILE); + FRIEND_TEST(rfcStoreTest, setRawValue_NONPERSISTENT_FILE); + FRIEND_TEST(rfcStoreTest, writeHashToFile); + FRIEND_TEST(rfcStoreTest, loadTR181PropertiesIntoCache); + FRIEND_TEST(rfcStoreTest, setRawValue_Invalid_FILE); + FRIEND_TEST(rfcStoreTest, loadFileToCache); +#endif }; #endif // XRDKCENTRALCOMRFCSTORE_H diff --git a/src/hostif/profiles/DeviceInfo/gtest/Makefile.am b/src/hostif/profiles/DeviceInfo/gtest/Makefile.am index fea0094d1..255f9b672 100755 --- a/src/hostif/profiles/DeviceInfo/gtest/Makefile.am +++ b/src/hostif/profiles/DeviceInfo/gtest/Makefile.am @@ -21,20 +21,10 @@ AUTOMAKE_OPTIONS = subdir-objects bin_PROGRAMS = devieInfo_gtest # Define the include directories -COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DUSE_DEV_PROPERTIES_CONF -DPARODUS -DUNIT_TEST -DUSE_REMOTE_DEBUGGER -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I$(TOP_DIR)/src/hostif/handlers/include -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/hostif/httpserver/include -I$(TOP_DIR)/src/hostif/handlers/src -I/usr/include/rbus -I/usr/local/include/rbus -I/usr/remote_debugger/src/ - -if LIBSOUP3_ENABLE -COMMON_CPPFLAGS += -I/usr/include/libsoup-3.0 -DLIBSOUP3_ENABLE -else -COMMON_CPPFLAGS += -I/usr/include/libsoup-2.4 -endif +COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DUSE_DEV_PROPERTIES_CONF -DPARODUS -DUNIT_TEST -DUSE_REMOTE_DEBUGGER -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I$(TOP_DIR)/src/hostif/handlers/include -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/hostif/httpserver/include -I$(TOP_DIR)/src/hostif/handlers/src -I/usr/include/rbus -I/usr/local/include/rbus -I/usr/remote_debugger/src/ -I/usr/include/libsoup-3.0 # Define the libraries to link against -COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl - -if LIBSOUP3_ENABLE -COMMON_LDADD += -lsoup-3.0 -endif +COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl -lsoup-3.0 # Define the compiler flags COMMON_CXXFLAGS = -frtti $(GLIB_CFLAGS) $(SOUP_LIBS) -fprofile-arcs -ftest-coverage diff --git a/src/hostif/profiles/DeviceInfo/gtest/gtest_main.cpp b/src/hostif/profiles/DeviceInfo/gtest/gtest_main.cpp index 956ca25a1..01e95fbb1 100644 --- a/src/hostif/profiles/DeviceInfo/gtest/gtest_main.cpp +++ b/src/hostif/profiles/DeviceInfo/gtest/gtest_main.cpp @@ -72,6 +72,10 @@ char *HTTPServerName = (char *)"HTTPServerThread"; GError *httpError = NULL; T_ARGLIST argList = {{'\0'}, 0}; +#ifdef GTEST_ENABLE +extern bool (*ValidateInput_ArgumentsFunc()) (char *input, FILE *tmp_fptr); +#endif + TEST(rfcStoreTest, setValue) { m_rfcStore = XRFCStore::getInstance(); @@ -681,6 +685,23 @@ TEST(deviceTest, get_Device_DeviceInfo_SoftwareVersion) { } } +TEST(deviceTest, get_JENKINS_BUILD_NUMBER) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + writeToTr181storeFile("trunk", "124", "/version.txt", Plain); + writeToTr181storeFile("JENKINS_BUILD_NUMBER", "5680", "/version.txt", Plain); + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_SoftwareVersion(&msgData,&bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareFilename) { write_on_file("/tmp/currently_running_image_name", "ELTE11MWR_DEV_develop_20250808222527_NG"); HOSTIF_MsgData_t msgData; @@ -710,10 +731,29 @@ TEST(deviceTest, get_Device_DeviceInfo_Migration_MigrationStatus) { int ret = pIface->get_Device_DeviceInfo_Migration_MigrationStatus(&msgData,&bChanged); cout << "msgData.paramValue = " << msgData.paramValue << endl; EXPECT_EQ(ret, OK); - EXPECT_STREQ(msgData.paramValue, "NOT_NEEDED"); + EXPECT_STREQ(msgData.paramValue, "NEEDED"); } } +TEST(deviceTest, get_Device_DeviceInfo_Migration_MigrationStatus_Update) { + std::remove("/opt/secure/persistent/MigrationStatus"); + write_on_file("/opt/secure/persistent/MigrationStatus", "Migrated"); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_Migration_MigrationStatus(&msgData,&bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + EXPECT_STREQ(msgData.paramValue, "Migrated"); + } +} + + TEST(deviceTest, get_Device_DeviceInfo_Manufacturer) { writeToTr181storeFile("MANUFACTURE", "Sky", "/etc/device.properties", Plain); HOSTIF_MsgData_t msgData; @@ -747,13 +787,14 @@ TEST(deviceTest, get_Device_DeviceInfo_X_COMCAST_COM_FirmwareDownloadPercent) { memset(&msgData,0,sizeof(msgData)); bChanged = false; int ret = pIface->get_Device_DeviceInfo_X_COMCAST_COM_FirmwareDownloadPercent(&msgData,&bChanged); - cout << "msgData.paramValue = " << msgData.paramValue << endl; - EXPECT_EQ(ret, OK); - //EXPECT_STREQ(msgData.paramValue, "80"); + cout << "msgData.paramValue = " << get_int(msgData.paramValue) << " msgData.faultCode=" << msgData.faultCode << endl; + EXPECT_EQ(ret, OK); + EXPECT_EQ(get_int(msgData.paramValue), 80); } } TEST(deviceTest, get_Device_DeviceInfo_ModelName) { + std::remove("/tmp/.model"); write_on_file("/tmp/.model", "Xione-UK"); HOSTIF_MsgData_t msgData; bool bChanged; @@ -785,6 +826,70 @@ TEST(deviceTest, get_Device_DeviceInfo_FirstUseDate) { } } +TEST(deviceTest, get_Device_DeviceInfo_FirstUseDate_FileRemoved) { + std::remove("/opt/persistent/firstNtpTime"); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_FirstUseDate(&msgData,&bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, set_xRDKCentralComXREContainerRFCDisable) { + HOSTIF_MsgData_t param; + bool bChanged; + int instanceNumber = 0; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.X_COMCAST-COM_Xcalibur.Client.XRE.xreEnable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + put_boolean(param.paramValue, false); + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->set_xRDKCentralComXREContainerRFCEnable(¶m); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xRDKCentralComXREContainerRFCInvalidtype) { + HOSTIF_MsgData_t param; + bool bChanged; + int instanceNumber = 0; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.X_COMCAST-COM_Xcalibur.Client.XRE.xreEnable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "TestName2", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->set_xRDKCentralComXREContainerRFCEnable(¶m); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + TEST(deviceTest, set_xRDKCentralComXREContainerRFCEnable) { HOSTIF_MsgData_t param; bool bChanged; @@ -809,6 +914,31 @@ TEST(deviceTest, set_xRDKCentralComXREContainerRFCEnable) { } } +TEST(deviceTest, set_xRDKCentralComXREContainerRFCEnable_FileRemoved) { + std::remove("/opt/XRE_container_enable"); + HOSTIF_MsgData_t param; + bool bChanged; + int instanceNumber = 0; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.X_COMCAST-COM_Xcalibur.Client.XRE.xreEnable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + put_boolean(param.paramValue, false); + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->set_xRDKCentralComXREContainerRFCEnable(¶m); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + TEST(deviceTest, set_xOpsRPCDevManageableNotification) { HOSTIF_MsgData_t param; bool bChanged; @@ -976,6 +1106,22 @@ TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType) { } } +TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType_FileRemoved) { + std::remove("/opt/prefered-gateway"); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType(&msgData,&bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportEnable) { HOSTIF_MsgData_t param = { 0 }; memset(¶m,0,sizeof(HOSTIF_MsgData_t)); @@ -1000,6 +1146,31 @@ TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportEnable) { } } +TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportDisable) { + write_on_file("/opt/.ipremote_status", "disabled"); + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_IPRemoteSupport.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + put_boolean(param.paramValue, false); + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); + + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportEnable(¶m); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + TEST(deviceTest, set_xOpsDeviceMgmtForwardSSHEnable) { HOSTIF_MsgData_t param = { 0 }; memset(¶m,0,sizeof(HOSTIF_MsgData_t)); @@ -1024,6 +1195,55 @@ TEST(deviceTest, set_xOpsDeviceMgmtForwardSSHEnable) { } } +TEST(deviceTest, set_xOpsDeviceMgmtForwardSSHDisable) { + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.ForwardSSH.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + put_boolean(param.paramValue, false); + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); + + HOSTIF_MsgData_t msgData; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(¶m,0,sizeof(param)); + int ret = pIface->set_xOpsDeviceMgmtForwardSSHEnable(&msgData); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xOpsDeviceMgmtForwardSSH_FileRemoved) { + std::remove("/opt/secure/.RFC_ForwardSSH"); + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.ForwardSSH.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + put_boolean(param.paramValue, false); + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); + + HOSTIF_MsgData_t msgData; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(¶m,0,sizeof(param)); + int ret = pIface->set_xOpsDeviceMgmtForwardSSHEnable(&msgData); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + TEST(deviceTest, validate_ParamValue) { HOSTIF_MsgData_t param = { 0 }; memset(¶m,0,sizeof(HOSTIF_MsgData_t)); @@ -1099,6 +1319,24 @@ TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportEnable) { } } +TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportDisable) { + std::remove("/opt/.ipremote_status"); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + string partnerId; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportEnable(&msgData, &bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + EXPECT_STREQ(msgData.paramValue, "false"); + } +} + TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportIpaddress) { HOSTIF_MsgData_t msgData; bool bChanged; @@ -1117,12 +1355,30 @@ TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportIpaddress } } +TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportIpaddress_Unknown) { + std::remove("/tmp/ipremote_interface_info"); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + string partnerId; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportIpaddress(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + EXPECT_STREQ(msgData.paramValue, "unknown"); + } +} + TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportMACaddress) { HOSTIF_MsgData_t msgData; bool bChanged; int instanceNumber = 0; - writeToTr181storeFile("MAC_Address", "D4:52:EE:D8:16:4B", "/tmp/ipremote_interface_info", Plain); + writeToTr181storeFile("MAC_Address", " D4:52:EE:D8:16:4B", "/tmp/ipremote_interface_info", Plain); string partnerId; hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); if(pIface) @@ -1136,6 +1392,24 @@ TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportMACaddres } } +TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportMACaddress_Unknown) { + std::remove("/tmp/ipremote_interface_info"); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + string partnerId; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_IPRemoteSupportMACaddress(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + EXPECT_STREQ(msgData.paramValue, "unknown"); + } +} + TEST(deviceTest, get_xOpsReverseSshStatus) { HOSTIF_MsgData_t msgData; bool bChanged; @@ -1199,23 +1473,76 @@ TEST(deviceTest, get_xOpsDeviceMgmtForwardSSHEnable) { } } -TEST(deviceTest, set_xRDKCentralComApparmorBlocklist) { +TEST(deviceTest, get_xOpsDeviceMgmtForwardSSHEnable_Disable) { + + std::remove("/opt/secure/.RFC_ForwardSSH"); HOSTIF_MsgData_t param = { 0 }; - bool bChanged; - int instanceNumber = 0; - write_on_file("/opt/secure/Apparmor_blocklist", "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.NonRootSupport.ApparmorBlocklist:Enabled"); - string partnerId; memset(¶m,0,sizeof(HOSTIF_MsgData_t)); - param.reqType = HOSTIF_SET; - strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.ForwardSSH.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); param.bsUpdate = HOSTIF_NONE; - param.requestor = HOSTIF_SRC_RFC; - strncpy(param.paramValue, "profile1:enforce#profile2:disable#profile3:complain#invalidprofile:invalidmode", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); - param.paramtype = hostIf_StringType; - param.paramLen = strlen(param.paramValue); + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); - hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + bool bChanged; + int instanceNumber = 0; + writeToTr181storeFile("ForwardSSH", "false", "/opt/secure/.RFC_ForwardSSH", Plain); + string partnerId; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->get_xOpsDeviceMgmtForwardSSHEnable(¶m); + cout << "param.paramValue = " << getStringValue(¶m) << endl; + EXPECT_EQ(ret, OK); + EXPECT_EQ(getStringValue(¶m), "false"); + } +} + +TEST(deviceTest, get_xOpsDeviceMgmtForwardSSHEnable_FileRemoved) { + std::remove("/opt/secure/.RFC_ForwardSSH"); + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.ForwardSSH.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); + + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->get_xOpsDeviceMgmtForwardSSHEnable(¶m); + cout << "param.paramValue = " << getStringValue(¶m) << endl; + EXPECT_EQ(ret, NOK); + EXPECT_EQ(getStringValue(¶m), "true"); + } +} + +TEST(deviceTest, set_xRDKCentralComApparmorBlocklist) { + HOSTIF_MsgData_t param = { 0 }; + bool bChanged; + int instanceNumber = 0; + write_on_file("/opt/secure/Apparmor_blocklist", "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.NonRootSupport.ApparmorBlocklist:Enabled"); + string partnerId; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "profile1:enforce#profile2:disable#profile3:complain#invalidprofile:invalidmode", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); if(pIface) { bChanged = false; @@ -1235,7 +1562,53 @@ TEST(deviceTest, NewNtpEnable) { msgData.bsUpdate = HOSTIF_NONE; msgData.requestor = HOSTIF_SRC_WEBPA; - strncpy(msgData.paramValue, "true", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + put_boolean(msgData.paramValue, true); + msgData.paramtype = hostIf_BooleanType; + msgData.paramLen = strlen(msgData.paramValue); + + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->set_xRDKCentralComNewNtpEnable(&msgData); + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, NewNtpEnable_Disable) { + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.newNTP.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_WEBPA; + + put_boolean(msgData.paramValue, false); + msgData.paramtype = hostIf_BooleanType; + msgData.paramLen = strlen(msgData.paramValue); + + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->set_xRDKCentralComNewNtpEnable(&msgData); + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, NewNtpEnable_Disable_FileRemoved) { + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.newNTP.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_WEBPA; + + put_boolean(msgData.paramValue, false); msgData.paramtype = hostIf_BooleanType; msgData.paramLen = strlen(msgData.paramValue); @@ -1267,12 +1640,48 @@ TEST(deviceTest, get_xOpsDMLogsUploadStatus) { } } +TEST(deviceTest, get_xOpsDMLogsUploadStatus_FileRemoved) { + std::remove("/opt/loguploadstatus.txt"); + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->get_xOpsDMLogsUploadStatus(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, get_xOpsDMLogsUploadStatus_EmptyFile) { + const char* filePath = "/opt/loguploadstatus.txt"; + std::ofstream file(filePath); + file.close(); + + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->get_xOpsDMLogsUploadStatus(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + TEST(deviceTest, get_Device_DeviceInfo_IUI_Version) { + std::remove("/tmp/.iuiVersion"); HOSTIF_MsgData_t msgData; memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); bool bChanged; int instanceNumber = 0; - write_on_file("/tmp/.iuiVersion", "2.2"); + write_on_file("/tmp/.iuiVersion", "2.2\n"); hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); if(pIface) { @@ -1284,6 +1693,31 @@ TEST(deviceTest, get_Device_DeviceInfo_IUI_Version) { } } +TEST(deviceTest, set_Device_DeviceInfoEmpty_IUI_Version) { + bool bChanged; + int instanceNumber = 0; + + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM.IUI.Version", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + strncpy (msgData.paramValue, "", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.paramtype = hostIf_StringType; + msgData.paramLen = strlen(msgData.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->set_Device_DeviceInfo_IUI_Version(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + TEST(deviceTest, set_Device_DeviceInfo_IUI_Version) { bool bChanged; int instanceNumber = 0; @@ -1310,6 +1744,39 @@ TEST(deviceTest, set_Device_DeviceInfo_IUI_Version) { } } +TEST(deviceTest, get_Device_DeviceInfo_IUI_Version_FileRemoved) { + std::remove("/tmp/.iuiVersion"); + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_IUI_Version(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, get_Device_DeviceInfo_IUI_Version_EmptyFile) { + std::ofstream file("/tmp/.iuiVersion"); + file.close(); + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_IUI_Version(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOT_HANDLED); + } +} + TEST(deviceTest, set_xOpsDMUploadLogsNow) { bool bChanged; int instanceNumber = 0; @@ -1335,6 +1802,32 @@ TEST(deviceTest, set_xOpsDMUploadLogsNow) { } } +TEST(deviceTest, set_xOpsDMUploadLogsNow_Disable) { + bool bChanged; + int instanceNumber = 0; + + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.Logging.xOpsDMUploadLogsNow", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + put_boolean(msgData.paramValue, false); + msgData.paramtype = hostIf_BooleanType; + msgData.paramLen = sizeof(hostIf_BooleanType); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->set_xOpsDMUploadLogsNow(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + TEST(deviceInfoTest, get_Device_DeviceInfo_MigrationPreparer_MigrationReady) { bool bChanged; int instanceNumber = 0; @@ -1398,6 +1891,9 @@ TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Canary_wakeUpEnd) { } } TEST(deviceTest, readFirmwareInfo) { + + int ret = system("cp ../../../../unittest/stubs/fwdnldstatus.txt /opt/fwdnldstatus.txt"); + EXPECT_EQ(ret, 0); int instanceNumber = 0; HOSTIF_MsgData_t msgData; @@ -1415,7 +1911,6 @@ TEST(deviceTest, readFirmwareInfo) { TEST(deviceInfoTest, writeFirmwareInfo) { int instanceNumber = 0; - char param [] = "CurrentFile"; HOSTIF_MsgData_t msgData; memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); @@ -1434,7 +1929,7 @@ TEST(deviceInfoTest, writeFirmwareInfo) { } TEST(deviceInfoTest, get_X_RDK_FirmwareName) { - write_on_file("/version.txt", "imagename:ELTE11MWR_VBN_25Q3_sprint_20250814010729sdy_NG"); + write_on_file("/version.txt", "imagename:ELTE11MWR_VBN_25Q3_sprint_2025 0814010729sdy_NG"); int instanceNumber = 0; HOSTIF_MsgData_t msgData; @@ -1461,6 +1956,7 @@ TEST(deviceInfoTest, get_X_RDKCENTRAL_COM_LastRebootReason) { int ret = pIface->get_X_RDKCENTRAL_COM_LastRebootReason(&msgData); cout << "msgData.paramValue = " << msgData.paramValue << endl; EXPECT_EQ(ret, OK); + EXPECT_STREQ(msgData.paramValue, "PowerOnReset"); } } @@ -1623,6 +2119,27 @@ TEST(rfcStoreTest, set_xRDKDownloadManager_DownloadStatus) { } } +TEST(deviceTest, set_xRDKDownloadManager_DownloadStatus_InvalidParameterType) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET;strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RDKDownloadManager.DownloadStatus", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "true", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKDownloadManager_DownloadStatus(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + TEST(rfcStoreTest, set_xRDKDownloadManager_InstallPackage) { int instanceNumber = 0; HOSTIF_MsgData_t param = { 0 }; @@ -1644,6 +2161,27 @@ TEST(rfcStoreTest, set_xRDKDownloadManager_InstallPackage) { } } +TEST(rfcStoreTest, set_xRDKDownloadManager_InvalidParamValue) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET;strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RDKDownloadManager.InstallPackage", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKDownloadManager_InstallPackage(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, -1); + } +} + TEST(deviceTest, get_xOpsRPCRebootPendingNotification) { int instanceNumber = 0; HOSTIF_MsgData_t param = { 0 }; @@ -1715,36 +2253,38 @@ TEST(deviceTest, set_xRDKCentralComRFCAutoRebootEnable) { } } -TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadUseCodebig) { +TEST(deviceTest, set_xRDKCentralComRFCAutoRebootEnable_Invalidtype) { + bool bChanged; int instanceNumber = 0; HOSTIF_MsgData_t msgData; memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); msgData.reqType = HOSTIF_SET; - strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_FirmwareDownloadUseCodebig", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.AutoReboot.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); msgData.bsUpdate = HOSTIF_NONE; msgData.requestor = HOSTIF_SRC_RFC; - put_boolean(msgData.paramValue, true); - msgData.paramtype = hostIf_BooleanType; - msgData.paramLen = sizeof(hostIf_BooleanType); + strncpy(msgData.paramValue, "TestName2", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.paramtype = hostIf_StringType; + msgData.paramLen = strlen(msgData.paramValue); hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); if(pIface) { - int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadUseCodebig(&msgData); + bChanged = false; + int ret = pIface->set_xRDKCentralComRFCAutoRebootEnable(&msgData); cout << "msgData.paramValue = " << msgData.paramValue << endl; - EXPECT_EQ(ret, OK); + EXPECT_EQ(ret, NOK); } } -TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadDeferReboot) { +TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadUseCodebig) { int instanceNumber = 0; HOSTIF_MsgData_t msgData; memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); msgData.reqType = HOSTIF_SET; - strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_FirmwareDownloadDeferReboot", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_FirmwareDownloadUseCodebig", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); msgData.bsUpdate = HOSTIF_NONE; msgData.requestor = HOSTIF_SRC_RFC; @@ -1755,7 +2295,30 @@ TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadDefe hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); if(pIface) { - int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadDeferReboot(&msgData); + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadUseCodebig(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadDeferReboot) { + int instanceNumber = 0; + + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_FirmwareDownloadDeferReboot", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + put_boolean(msgData.paramValue, true); + msgData.paramtype = hostIf_BooleanType; + msgData.paramLen = sizeof(hostIf_BooleanType); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadDeferReboot(&msgData); cout << "msgData.paramValue = " << msgData.paramValue << endl; EXPECT_EQ(ret, OK); } @@ -1801,7 +2364,7 @@ TEST(deviceTest, set_Device_DeviceInfo_X_COMCAST_COM_FirmwareDownloadProtocol) { hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); if(pIface) { - int ret = pIface->set_Device_DeviceInfo_X_COMCAST_COM_FirmwareDownloadURL(&msgData); + int ret = pIface->set_Device_DeviceInfo_X_COMCAST_COM_FirmwareDownloadProtocol(&msgData); cout << "msgData.paramValue = " << msgData.paramValue << endl; EXPECT_EQ(ret, OK); } @@ -1830,6 +2393,52 @@ TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Syndication_PartnerI } } +TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Syndication_PartnerId_Unknown) { + int instanceNumber = 0; + + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_Syndication.PartnerId", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + strncpy(msgData.paramValue, "unknown", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.paramtype = hostIf_StringType; + msgData.paramLen = strlen(msgData.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_Syndication_PartnerId(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Syndication_PartnerId_Empty) { + int instanceNumber = 0; + + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_Syndication.PartnerId", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + strncpy(msgData.paramValue, "", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.paramtype = hostIf_StringType; + msgData.paramLen = strlen(msgData.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_Syndication_PartnerId(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType) { int instanceNumber = 0; @@ -1849,6 +2458,65 @@ TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType } } +TEST(deviceInfoTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType_FileRemoved) { + std::remove("/opt/prefered-gateway"); + int instanceNumber = 0; + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "X_RDKCENTRAL-COM_RDKVersion.X_RDKCENTRAL-COM_PreferredGatewayType", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceInfoTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType_FileRemoved) { + int instanceNumber = 0; + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "X_RDKCENTRAL-COM_RDKVersion.X_RDKCENTRAL-COM_PreferredGatewayType", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceInfoTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType_EmptyFile) { + std::ofstream file("/opt/prefered-gateway"); + file.close(); + + int instanceNumber = 0; + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "X_RDKCENTRAL-COM_RDKVersion.X_RDKCENTRAL-COM_PreferredGatewayType", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_PreferredGatewayType(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + TEST(deviceInfoTest, get_Device_DeviceInfo_HardwareVersion) { int instanceNumber = 0; @@ -1950,7 +2618,30 @@ TEST(deviceTest, get_Device_DeviceInfo_X_COMCAST_COM_PowerStatus) { } } -TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset) { +TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset_Warehouse_Cold) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_Reset", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "Cold", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + +TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset_Warehouse) { int instanceNumber = 0; HOSTIF_MsgData_t param = { 0 }; memset(¶m,0,sizeof(HOSTIF_MsgData_t)); @@ -1972,6 +2663,93 @@ TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset) { } } +TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset_Factory) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_Reset", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "Factory", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset_Customer) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_Reset", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "Customer", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset_InvalidInput) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_Reset", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "User", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOT_HANDLED); + } +} + +TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset_NULL) { + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_Reset", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + param.paramValue[0] = '\0'; + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} TEST(deviceTest, get_xOpsReverseSshArgs) @@ -2017,59 +2795,1539 @@ TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_RebootStopEnable) } } -TEST(deviceTest, set_xRDKCentralComDABRFCEnable) +TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_RebootStopEnable_Invalidtype) { int instanceNumber = 0; HOSTIF_MsgData_t param = { 0 }; memset(¶m,0,sizeof(HOSTIF_MsgData_t)); param.reqType = HOSTIF_GET; - strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.DAB.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RebootStop.Enable", 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); + strncpy(param.paramValue, "TestName2", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); if(pIface) { - int ret = pIface->set_xRDKCentralComDABRFCEnable(¶m); + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_RebootStopEnable(¶m); cout << "msgData.paramValue = " << param.paramValue << endl; - EXPECT_EQ(ret, OK); + EXPECT_EQ(ret, NOK); + EXPECT_EQ(param.faultCode, fcInvalidParameterType); } } - -TEST(deviceTest, set_xOpsDeviceMgmtRPCRebootNow) +TEST(deviceTest, set_xRDKCentralComDABRFCDisable) { int instanceNumber = 0; HOSTIF_MsgData_t param = { 0 }; memset(¶m,0,sizeof(HOSTIF_MsgData_t)); param.reqType = HOSTIF_GET; - strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.RebootNow", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.DAB.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); param.bsUpdate = HOSTIF_NONE; param.requestor = HOSTIF_SRC_RFC; - put_boolean(param.paramValue, true); + put_boolean(param.paramValue, false); param.paramtype = hostIf_BooleanType; param.paramLen = sizeof(hostIf_BooleanType); hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); if(pIface) { - int ret = pIface->set_xOpsDeviceMgmtRPCRebootNow(¶m); + int ret = pIface->set_xRDKCentralComDABRFCEnable(¶m); cout << "msgData.paramValue = " << param.paramValue << endl; EXPECT_EQ(ret, OK); } } +TEST(deviceTest, set_xRDKCentralComDABRFCInvalidtype) +{ + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.DAB.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "TestName2", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); -TEST(bsStoreTest, initBSPropertiesFileName) { - m_bsStore = XBSStore::getInstance(); - m_bsStore->initBSPropertiesFileName(); - m_bsStore->m_filename.erase(std::remove(m_bsStore->m_filename.begin(), m_bsStore->m_filename.end(), '"'), m_bsStore->m_filename.end()); - EXPECT_EQ(m_bsStore->m_filename, "/opt/secure/RFC/bootstrap.ini"); + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKCentralComDABRFCEnable(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + EXPECT_EQ(param.faultCode, fcInvalidParameterType); + } +} + + +TEST(deviceTest, set_xRDKCentralComDABRFCEnable) +{ + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.DAB.Enable", 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); + if(pIface) + { + int ret = pIface->set_xRDKCentralComDABRFCEnable(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + +TEST(deviceTest, set_xOpsDeviceMgmtRPCRebootNow) +{ + int instanceNumber = 0; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.RebootNow", 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); + if(pIface) + { + int ret = pIface->set_xOpsDeviceMgmtRPCRebootNow(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, get_Device_DeviceInfo_ManufacturerOUI) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.ManufacturerOUI", 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); + if(pIface) + { + int ret = pIface->get_Device_DeviceInfo_ManufacturerOUI(¶m, &pChanged); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOT_HANDLED); + } + pIface->closeInstance(pIface); + pIface->closeAllInstances(); +} + +TEST(deviceTest, get_Device_DeviceInfo_SerialNumber) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.SerialNumber", 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); + if(pIface) + { + int ret = pIface->get_Device_DeviceInfo_SerialNumber(¶m, &pChanged); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, get_Device_DeviceInfo_AdditionalSoftwareVersion) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.AdditionalSoftwareVersion", 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); + if(pIface) + { + int ret = pIface->get_Device_DeviceInfo_AdditionalSoftwareVersion(¶m, &pChanged); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + + +TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_BootStatus) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM.BootStatus", 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); + if(pIface) + { + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_BootStatus(¶m, &pChanged); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xOpsDMMoCALogEnabled) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.xOpsDMUploadLogsNow", 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); + if(pIface) + { + int ret = pIface->set_xOpsDMMoCALogEnabled(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, get_xOpsDMMoCALogEnabled) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.xOpsDMUploadLogsNow", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_xOpsDMMoCALogEnabled(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_Device_DeviceInfo_X_RDKCENTRAL_COM_XRPollingAction) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_XRPolling.Action", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + + strncpy(param.paramValue, "XRPoll", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_Device_DeviceInfo_X_RDKCENTRAL_COM_XRPollingAction(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xOpsReverseSshTrigger) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.ReverseSSH.xOpsReverseSshTrigger", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + + strncpy(param.paramValue, "start shorts", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xOpsReverseSshTrigger(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xRDKCentralComRFC) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Control.ClearDB", 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); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xRDKCentralComRFC_ClearDB_False) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Control.ClearDB", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + put_boolean(param.paramValue, false); + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + + +TEST(deviceTest, set_xRDKCentralComRFC_ClearDBEnd) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Control.ClearDBEnd", 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); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, set_xRDKCentralComRFC_ClearDBEnd_False) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Control.ClearDBEnd", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + put_boolean(param.paramValue, false); + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, set_xRDKCentralComRFC_RoamTrigger) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RoamTrigger", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "TestTriggerUpdate", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + +TEST(deviceTest, set_xRDKCentralComRFC_ISSUETYPE) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.IssueType", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "TestType", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + +TEST(deviceTest, set_xRDKCentralComRFC_WebCfgData) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.WebCfgData", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "TestType", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xRDKCentralComRFC_CANARY_START_TIME) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Canary.wakeUpStart", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "300", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_IntegerType; + param.paramLen = sizeof(hostIf_IntegerType); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + +TEST(deviceTest, set_xRDKCentralComRFC_CANARY_END_TIME) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Canary.wakeUpEnd", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "480", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_IntegerType; + param.paramLen = sizeof(hostIf_IntegerType); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + +TEST(deviceTest, set_xRDKCentralComRFC_RebootStopEnable) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RebootStop.Enable", 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); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xRDKCentralComRFC_RebootStopEnable_newNTP) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.newNTP.Enable", 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); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xRDKCentralComRFC_RebootStopEnable_AUTOREBOOT) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.AutoReboot.Enable", 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); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xRDKCentralComRFC_RebootStopEnable_XRE_CONTAINER_RFC_ENABLE) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.LXC.XRE.Enable", 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); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFC(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, RDKRemoteDebuggergetProfileData) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.getProfileData", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_RDKRemoteDebuggergetProfileData(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, RDKRemoteDebuggergetProfileData_FileRemoved) +{ + std::remove("/etc/rrd/remote_debugger.json"); + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.getProfileData", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_RDKRemoteDebuggergetProfileData(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, RDKRemoteDebuggergetProfileData_EmptyFile) +{ + std::ofstream file("/etc/rrd/remote_debugger.json"); + file.close(); + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.getProfileData", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_RDKRemoteDebuggergetProfileData(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, set_xRDKCentralComRFCRoamTrigger) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RoamTrigger", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "TestTrigger", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xRDKCentralComRFCRoamTrigger(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xFirmwareDownloadNow) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_FirmwareDownloadNow", 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); + if(pIface) + { + int ret = pIface->set_xFirmwareDownloadNow(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, get_xOpsRPCDevManageableNotification) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.DeviceManageableNotification", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_xOpsRPCDevManageableNotification(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xOpsRPC_Profile_RebootNow) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.RebootNow", 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); + if(pIface) + { + int ret = pIface->set_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xOpsRPC_Profile_NOTIFICATION) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.DeviceManageableNotification", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "TestNotification", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + +TEST(deviceTest, set_xOpsRPC_Profile_STARTED_NOTIFICATION) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.FirmwareDownloadStartedNotification", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + strncpy(param.paramValue, "Started", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xOpsRPC_Profile_COMPLETED_NOTIFICATION) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.FirmwareDownloadCompletedNotification", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "Completed", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xOpsRPC_Profile_PENDING_NOTIFICATION) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.RebootPendingNotification", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "Pending", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->set_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xOpsRPC_Profile_InvalidParameterName) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MOCASSH.Enable", 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); + if(pIface) + { + int ret = pIface->set_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + EXPECT_EQ(param.faultCode, fcInvalidParameterName); + } +} + +TEST(deviceTest, send_DeviceManageableNotification) +{ + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + pIface->send_DeviceManageableNotification(); + EXPECT_EQ(0, 0); + } +} + +TEST(deviceTest, get_X_RDKCENTRAL_COM_experience) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_COMCAST-COM_EXPERIENCE", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_X_RDKCENTRAL_COM_experience(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceInfoTest, get_X_RDK_FirmwareName_FileRemoved) { + std::remove("/version.txt"); + int instanceNumber = 0; + + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_X_RDK_FirmwareName(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceInfoTest, get_X_RDKCENTRAL_COM_LastRebootReason_FileRemoved) { + std::remove("/opt/secure/reboot/previousreboot.info"); + int instanceNumber = 0; + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_X_RDKCENTRAL_COM_LastRebootReason(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceInfoTest, writeFirmwareInfo_FileRemoved) { + std::remove("/opt/fwdnldstatus.txt"); + int instanceNumber = 0; + + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + + strncpy(msgData.paramValue, "SKXI11ADS_MIDDLEWARE_DEV_develop_20250527063924", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.paramtype = hostIf_StringType; + msgData.paramLen = strlen(msgData.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->writeFirmwareInfo((char *)"CurrentFile", &msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, get_PartnerId_From_Script_File) { + write_on_file("/opt/www/authService/partnerId3.dat", "sky"); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + string partnerId; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_PartnerId_From_Script(partnerId); + cout << "partnerId = " << partnerId << endl; + EXPECT_EQ(ret, OK); + EXPECT_EQ(partnerId, "sky"); + } +} + +TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareFilename_Version_TXT_File) { + std::ofstream file("/tmp/currently_running_image_name"); + file.close(); + write_on_file("/version.txt", "imagename:XUSHTC11MWR_8.2s14_PROD"); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareFilename(&msgData,&bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + EXPECT_STREQ(msgData.paramValue, "XUSHTC11MWR_8.2s14_PROD"); + } +} + +TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareToDownload_Version_TXT) { + std::ofstream file("/version.txt"); + file.close(); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareToDownload(&msgData,&bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, get_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadStatus_Version_TXT) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_FirmwareDownloadStatus(&msgData,&bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, get_Device_DeviceInfo_X_COMCAST_COM_FirmwareDownloadPercent_FileRemoved) { + std::remove("/opt/curl_progress"); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_X_COMCAST_COM_FirmwareDownloadPercent(&msgData,&bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, get_ApparmorBlockListStatus_FileRemoved) { + std::remove("/opt/secure/Apparmor_blocklist"); + HOSTIF_MsgData_t msgData = { 0 }; + bool bChanged; + int instanceNumber = 0; + string partnerId; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + bChanged = false; + int ret = pIface->get_ApparmorBlockListStatus(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, -1); + EXPECT_STREQ(msgData.paramValue, "Apparmorblocklist is empty"); + } +} + +TEST(deviceTest, ValidateInput_Arguments) { + FILE *tmp_fptr = NULL; + bool ret = ValidateInput_ArgumentsFunc()(NULL, tmp_fptr); + EXPECT_EQ(ret, false); +} + +TEST(deviceTest, readFirmwareInfo_EmptyFile) { + std::remove("/opt/fwdnldstatus.txt"); + std::ofstream file("/opt/fwdnldstatus.txt"); + file.close(); + + HOSTIF_MsgData_t msgData = { 0 }; + bool bChanged; + int instanceNumber = 0; + string partnerId; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + bChanged = false; + int ret = pIface->readFirmwareInfo((char *)"DnldFile", &msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, readFirmwareInfo_WithoutPipe) { + write_on_file("/opt/fwdnldstatus.txt", "Proto:http"); + + HOSTIF_MsgData_t msgData = { 0 }; + bool bChanged; + int instanceNumber = 0; + string partnerId; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + bChanged = false; + int ret = pIface->readFirmwareInfo((char *)"Proto", &msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceInfoTest, get_X_RDKCENTRAL_COM_LastRebootReason_FileEmpty) { + std::ofstream file("/opt/secure/reboot/previousreboot.info"); + file.close(); + int instanceNumber = 0; + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_X_RDKCENTRAL_COM_LastRebootReason(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceInfoTest, GetLock_ShouldAcquireMutex) { + int instanceNumber = 0; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + pIface->getLock(); + pIface->releaseLock(); + EXPECT_EQ(0, 0); + } +} + +TEST(deviceTest, get_xOpsRPC_Profile_NOTIFICATION) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.DeviceManageableNotification", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, get_xOpsRPC_Profile_STARTED_NOTIFICATION) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.FirmwareDownloadStartedNotification", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + +TEST(deviceTest, get_xOpsRPC_Profile_COMPLETED_NOTIFICATION) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.FirmwareDownloadCompletedNotification", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + + +TEST(deviceTest, get_xOpsRPC_Profile_PENDING_NOTIFICATION) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.RebootPendingNotification", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, get_xOpsRPC_Profile_InvalidParameterName) +{ + int instanceNumber = 0; + bool pChanged; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MOCASSH.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + int ret = pIface->get_xOpsRPC_Profile(¶m); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + EXPECT_EQ(param.faultCode, fcInvalidParameterName); + } +} + +TEST(deviceTest, set_xRDKCentralComRFCLoudnessEquivalenceEnable_InvalidType) { + HOSTIF_MsgData_t param; + bool bChanged; + int instanceNumber = 0; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.LoudnessEquivalence.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + + strncpy(param.paramValue, "TestEquivalence", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + bChanged = false; + int ret = pIface->set_xRDKCentralComRFCLoudnessEquivalenceEnable(¶m); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(ret, NOK); + EXPECT_EQ(param.faultCode, fcInvalidParameterType); + } +} + +TEST(deviceTest, get_xOpsReverseSshStatus_Active) { + std::ofstream pidFile("/var/tmp/rssh.pid"); + pidFile << getpid(); // use current process PID which is definitely valid + pidFile.close(); + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + string partnerId; + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_xOpsReverseSshStatus(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + EXPECT_STREQ(msgData.paramValue, "ACTIVE"); + } +} + +TEST(deviceTest, get_xRDKCentralComRFC) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_GET; + strncpy (msgData.paramName, "Device.Time.NTPServer5", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_xRDKCentralComRFC(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(0, 0); + } +} + +TEST(deviceTest, set_X_RDKCENTRAL_COM_LastRebootReason) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_SET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_LastRebootReason", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->set_X_RDKCENTRAL_COM_LastRebootReason(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, get_xOpsDMMoCALogPeriod) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_GET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.xOpsDMLogsUploadStatus", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_xOpsDMMoCALogPeriod(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, AdditionalHardwareVersion) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_GET; + strncpy (msgData.paramName, "Device.DeviceInfo.HardwareVersion", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_AdditionalHardwareVersion(&msgData, &bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, COM_Reset) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_GET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_Reset", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_X_RDKCENTRAL_COM_Reset(&msgData, &bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, VendorConfigFileNumberOfEntries) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_GET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_Reset", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_VendorConfigFileNumberOfEntries(&msgData, &bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, SupportedDataModelNumber) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_GET; + strncpy (msgData.paramName, "Device.DeviceInfo.SupportedDataModelNumberOfEntries", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_SupportedDataModelNumberOfEntries(&msgData, &bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, VendorLogFileNumberOfEntries) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_GET; + strncpy (msgData.paramName, "Device.DeviceInfo.VendorLogFileNumberOfEntries", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_Device_DeviceInfo_VendorLogFileNumberOfEntries(&msgData, &bChanged); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(deviceTest, xOpsDMUploadLogsNow) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_GET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.xOpsDMUploadLogsNow", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_xOpsDMUploadLogsNow(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, set_xOpsDMMoCALogPeriod) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_GET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.xOpsDMMoCALogPeriod", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->set_xOpsDMMoCALogPeriod(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, OK); + } +} + +TEST(deviceTest, get_xRDKCentralComRFCAccountId) { + HOSTIF_MsgData_t msgData; + bool bChanged; + int instanceNumber = 0; + msgData.reqType = HOSTIF_GET; + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.AccountInfo.AccountID", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.bsUpdate = HOSTIF_NONE; + msgData.requestor = HOSTIF_SRC_RFC; + + hostIf_DeviceInfo *pIface = hostIf_DeviceInfo::getInstance(instanceNumber); + if(pIface) + { + memset(&msgData,0,sizeof(msgData)); + bChanged = false; + int ret = pIface->get_xRDKCentralComRFCAccountId(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + EXPECT_EQ(ret, NOK); + } +} + +TEST(bsStoreTest, initBSPropertiesFileName) { + m_bsStore = XBSStore::getInstance(); + m_bsStore->initBSPropertiesFileName(); + m_bsStore->m_filename.erase(std::remove(m_bsStore->m_filename.begin(), m_bsStore->m_filename.end(), '"'), m_bsStore->m_filename.end()); + EXPECT_EQ(m_bsStore->m_filename, "/opt/secure/RFC/bootstrap.ini"); } TEST(bsStoreTest, getRawValue) { @@ -2079,6 +4337,66 @@ TEST(bsStoreTest, getRawValue) { EXPECT_EQ(value, "time1.com"); } +TEST(bsStoreTest, getRawValue_Empty) { + m_bsStore = XBSStore::getInstance(); + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MOCASSH.Enable"; + string value = m_bsStore->getRawValue(key); + EXPECT_EQ(value, ""); +} + +TEST(bsStoreTest, getValue) { + m_bsStore = XBSStore::getInstance(); + + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.RDKRemoteDebugger.getProfileData", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + int ret = m_bsStore->getValue(¶m); //Get value before partnerId + + std::cout << "paramValue: " << getStringValue(¶m) << " ret = " << ret << std::endl; + EXPECT_EQ(ret, fcInternalError); +} + +TEST(bsStoreTest, setValue_BS_CLEAR_DB_START) { + m_bsStore = XBSStore::getInstance(); + + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Bootstrap.Control.ClearDB", 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); + int ret = m_bsStore->overrideValue(¶m); + + std::cout << "ret = " << ret << std::endl; + EXPECT_EQ(ret, 0); +} + +TEST(bsStoreTest, setValue_BS_CLEAR_DB_END) { + m_bsStore = XBSStore::getInstance(); + + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Bootstrap.Control.ClearDBEnd", 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); + int ret = m_bsStore->overrideValue(¶m); + + std::cout << "ret = " << ret << std::endl; + EXPECT_EQ(ret, 0); +} + TEST(bsStoreTest, createFile) { createFile("/tmp/bootstrap.txt"); EXPECT_EQ(0, 0); @@ -2089,11 +4407,53 @@ TEST(bsStoreTest, createDirectory) { EXPECT_EQ(ret, true); } +TEST(bsStoreTest, createDirectory_Error) { + bool ret = createDirectory("/opt/test/RFC"); + EXPECT_EQ(ret, false); +} + TEST(bsStoreTest, createBspCompleteFiles) { bool ret = createBspCompleteFiles(); EXPECT_EQ(ret, true); } +TEST(bsStoreTest, getPartnerDeviceConfig) { + m_bsStore = XBSStore::getInstance(); + const string partnerId = "comcast"; + + cJSON* partnerConfig = cJSON_CreateObject(); + cJSON_AddStringToObject(partnerConfig, "firmwareVersion", "v1.2.3"); + + bool ret = m_bsStore->getPartnerDeviceConfig(partnerConfig, partnerId); + EXPECT_EQ(ret, true); + cJSON_Delete(partnerConfig); +} + +TEST(bsStoreTest, getPartnerDeviceConfig_generic) { + m_bsStore = XBSStore::getInstance(); + const string partnerId = "default"; + + cJSON* partnerConfig = cJSON_CreateObject(); + cJSON_AddStringToObject(partnerConfig, "Device.Time.NTPServer1", "time.com"); + + bool ret = m_bsStore->getPartnerDeviceConfig(partnerConfig, partnerId); + EXPECT_EQ(ret, true); + cJSON_Delete(partnerConfig); +} + +TEST(bsStoreTest, getPartnerDeviceConfig_FileRemoved) { + std::remove("/etc/partners_defaults_device.json"); + m_bsStore = XBSStore::getInstance(); + const string partnerId = "comcast"; + + cJSON* partnerConfig = cJSON_CreateObject(); + cJSON_AddStringToObject(partnerConfig, "firmwareVersion", "v1.2.3"); + + bool ret = m_bsStore->getPartnerDeviceConfig(partnerConfig, partnerId); + EXPECT_EQ(ret, true); + cJSON_Delete(partnerConfig); +} + TEST(bsStoreJournalTest, getBuildTime) { m_bsStoreJournal = XBSStoreJournal::getInstance("/opt/secure/RFC/bootstrap.journal"); writeToTr181storeFile("BUILD_TIME", "2025-05-27 06:39:24", "/version.txt", Quoted); @@ -2155,6 +4515,53 @@ TEST(bsStoreJournalTest, clearRfcAndGetDefaultValue) { EXPECT_EQ(defaultValue, "time.com"); } +TEST(bsStoreJournalTest, rfcUpdateStarted) { + m_bsStoreJournal = XBSStoreJournal::getInstance("/opt/secure/RFC/bootstrap.journal"); + const string key = "Device.Time.NTPServer4"; + + bool result = m_bsStoreJournal->rfcUpdateStarted(); + EXPECT_EQ(result, true); +} + +TEST(bsStoreJournalTest, rfcUpdateEnd) { + m_bsStoreJournal = XBSStoreJournal::getInstance("/opt/secure/RFC/bootstrap.journal"); + const string key = "Device.Time.NTPServer4"; + + bool result = m_bsStoreJournal->rfcUpdateEnd(); + EXPECT_EQ(result, true); +} + +TEST(bsStoreJournalTest, constructor) { + XBSStoreJournal* journalPtr = new XBSStoreJournal(); + EXPECT_EQ(0, 0); +} + +TEST(bsStoreJournalTest, setJournalValue_New_Key) { + m_bsStoreJournal = XBSStoreJournal::getInstance("/opt/secure/RFC/bootstrap.journal"); + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MOCASSH.Enable"; + const string value = "false"; + + bool result = m_bsStoreJournal->setJournalValue(key, value, HOSTIF_SRC_RFC); + EXPECT_EQ(result, true); +} + +TEST(bsStoreJournalTest, setJournalValue_HOSTIF_SRC_DEFAULT) { + m_bsStoreJournal = XBSStoreJournal::getInstance("/opt/secure/RFC/bootstrap.journal"); + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.FWUpdate.Enable"; + const string value = "true"; + + bool result = m_bsStoreJournal->setJournalValue(key, value, HOSTIF_SRC_DEFAULT); + EXPECT_EQ(result, true); +} + +/* TEST(bsStoreJournalTest, resetCacheAndStore) { + m_bsStoreJournal = XBSStoreJournal::getInstance("/opt/secure/RFC/bootstrap.journal"); + const string key = "Device.Time.NTPServer4"; + + m_bsStoreJournal->resetCacheAndStore(); + EXPECT_EQ(0, 0); +} */ + TEST(rfcStoreTest, init_rfcdefaults) { m_rfcStore = XRFCStore::getInstance(); @@ -2163,17 +4570,98 @@ TEST(rfcStoreTest, init_rfcdefaults) { } TEST(rfcStoreTest, reloadCache) { + writeToTr181storeFile("Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.NonPersistent.WebPACDL.Enable", "true", "/opt/secure/RFC/tr181store_nonpersist.ini", Plain); m_rfcStore = XRFCStore::getInstance(); - m_rfcStore->reloadCache(); EXPECT_EQ(0, 0); } +TEST(rfcStoreTest, loadTR181PropertiesIntoCache) { + std::remove("/tmp/rfcdefaults.ini"); + m_rfcStore = XRFCStore::getInstance(); + + bool ret = m_rfcStore->loadTR181PropertiesIntoCache(); + EXPECT_EQ(ret, true); +} + +TEST(rfcStoreTest, getRawValue) { + m_rfcStore = XRFCStore::getInstance(); + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.NonPersistent.Enable"; + string value = m_rfcStore->getRawValue(key); + EXPECT_EQ(value, ""); +} + +TEST(rfcStoreTest, getRawValue_NONPERSISTENT_FILE) { + write_on_file("/tmp/.rfcSyncDone", "PREFIX)"); + m_rfcStore = XRFCStore::getInstance(); + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.NonPersistent.WebPACDL.Enable"; + string value = m_rfcStore->getRawValue(key); + EXPECT_EQ(value, "true"); +} + +TEST(rfcStoreTest, setRawValue_Invalid_FILE) { + m_rfcStore = XRFCStore::getInstance(); + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MTLS.mTlsCrashdumpUpload.Enable"; + const string value = "true"; + m_rfcStore->m_updateInProgress = true; + m_rfcStore->m_filename = "/opt/secure/RFC/bootrap.ini"; + bool ret = m_rfcStore->setRawValue(key, value); + EXPECT_EQ(ret, true); +} + +TEST(rfcStoreTest, writeHashToFile) { + m_rfcStore = XRFCStore::getInstance(); + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.MTLS.mTlsCrashdumpUpload.Enable"; + const string value = "true"; + unordered_map dict; + bool ret = m_rfcStore->writeHashToFile(key, value, dict, "/opt/secure/RFC1/boottrap.ini"); + EXPECT_EQ(ret, false); +} + +TEST(rfcStoreTest, setValue_RFC_PREFIX) { + m_rfcStore = XRFCStore::getInstance(); + + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.NonPersistent.WebPACDL.Enable", 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); + faultCode_t ret = m_rfcStore->setValue(¶m); + + EXPECT_EQ(ret, fcNoFault); +} + +TEST(rfcStoreTest, loadFileToCache) { + std::ofstream file("/opt/secure/RFC/tr181temp.ini"); + file.close(); + m_rfcStore = XRFCStore::getInstance(); + unordered_map dict; + bool ret = m_rfcStore->loadFileToCache("/opt/secure/RFC/tr181temp.ini", dict); + + EXPECT_EQ(ret, true); +} + +TEST(rfcStoreTest, getValue_rfcdefaults) { + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(msgData)); + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.FWUpdate.AutoExcluded.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + int ret = m_rfcStore->getValue(&msgData); + EXPECT_EQ(ret, OK); + EXPECT_STREQ(msgData.paramValue, "true"); +} + TEST(rfcStorageTest, init) { + int ret = system("cp ../../../../unittest/stubs/rfc.properties /etc/rfc.properties"); + EXPECT_EQ(ret, 0); m_rfcStoreage = new XRFCStorage(); bool result = m_rfcStoreage->init(); - EXPECT_EQ(result, true); + EXPECT_EQ(result, true); } TEST(rfcStorageTest, getValue) { @@ -2185,6 +4673,15 @@ TEST(rfcStorageTest, getValue) { EXPECT_STREQ(msgData.paramValue, "true"); } +/* TEST(rfcStorageTest, getValue_rfcdefaults) { + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(msgData)); + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.FWUpdate.AutoExcluded.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + int ret = m_rfcStoreage->getValue(&msgData); + EXPECT_EQ(ret, OK); + EXPECT_STREQ(msgData.paramValue, "true"); +} */ + TEST(rfcStorageTest, getRawValue) { const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.FWUpdate.Enable"; @@ -2207,6 +4704,20 @@ TEST(rfcStorageTest, setValue) { EXPECT_EQ(ret, OK); } +TEST(rfcStorageTest, setSameValue) { + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(msgData)); + strncpy (msgData.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Bootstrap.PartnerName", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + + strncpy(msgData.paramValue, "comcast", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + msgData.paramtype = hostIf_StringType; + msgData.paramLen = strlen(msgData.paramValue); + + int ret = m_rfcStoreage->setValue(&msgData); + cout << "msgData.paramValue = " << msgData.paramValue << endl; + + EXPECT_EQ(ret, OK); +} TEST(rfcStorageTest, setRawValue) { @@ -2214,7 +4725,6 @@ TEST(rfcStorageTest, setRawValue) { const string value = "TestOsClass"; bool ret = m_rfcStoreage->setRawValue(key, value); - EXPECT_EQ(ret, true); } @@ -2244,6 +4754,21 @@ TEST(processTest, get_Device_DeviceInfo_Processor_Architecture) { } } +TEST(processTest, Processor_Lock_ReleaseLock) { + int instanceNumber = 0; + + hostIf_DeviceProcessorInterface *processorIface = hostIf_DeviceProcessorInterface::getInstance(instanceNumber); + if(processorIface) + { + processorIface->getLock(); + processorIface->releaseLock(); + EXPECT_EQ(0, 0); + } + processorIface->closeInstance(processorIface); + processorIface->closeAllInstances(); + +} + TEST(processTest, getProcessStatusCPUUsage) { int instanceNumber = 0; @@ -2273,6 +4798,48 @@ TEST(processTest, get_Device_DeviceInfo_ProcessStatus_CPUUsage) { } } +TEST(processTest, getProcessStatParam) { + int instanceNumber = 0; + bool pChanged; + + long long unsigned int mUser = 0; + long long unsigned int mNice = 0; + long long unsigned int mSystem = 0; + long long unsigned int mIdle = 0; + long long unsigned int mIOwait = 0; + long long unsigned int mIrq = 0; + long long unsigned int mSoftirq = 0; + + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + hostIf_DeviceProcessStatusInterface *processStatusIface = hostIf_DeviceProcessStatusInterface::getInstance(instanceNumber); + if(processStatusIface) + { + pChanged = false; + int ret = processStatusIface->getProcessStatParam(&mUser, &mNice, &mSystem, &mIdle, &mIOwait, &mIrq, &mSoftirq); + EXPECT_EQ(ret, OK); + } +} + +TEST(processTest, ProcessStatus_Lock_ReleaseLock) { + int instanceNumber = 0; + bool pChanged; + + HOSTIF_MsgData_t msgData; + memset(&msgData,0,sizeof(HOSTIF_MsgData_t)); + hostIf_DeviceProcessStatusInterface *processStatusIface = hostIf_DeviceProcessStatusInterface::getInstance(instanceNumber); + if(processStatusIface) + { + pChanged = false; + processStatusIface->getLock(); + processStatusIface->releaseLock(); + EXPECT_EQ(0, 0); + } + processStatusIface->closeInstance(processStatusIface); + processStatusIface->closeAllInstances(); +} + + TEST(clearTest, rfcclearAll) { m_rfcStore = XRFCStore::getInstance(); @@ -2283,20 +4850,47 @@ TEST(clearTest, rfcclearAll) { TEST(clearTest, rfcStorageclearAll) { m_rfcStoreage->clearAll(); EXPECT_EQ(0, 0); - - delete m_rfcStoreage; } -/*TEST(bsClearTest, clearRfcValues) { +TEST(StoreClearTest, clearRfcValues) { m_bsStore = XBSStore::getInstance(); bool ret = m_bsStore->clearRfcValues(); EXPECT_EQ(ret, true); } -TEST(bsClearTest, resetCacheAndStore) { +TEST(StoreClearTest, resetCacheAndStore) { m_bsStore = XBSStore::getInstance(); m_bsStore->resetCacheAndStore(); EXPECT_EQ(0, 0); +} + +/* TEST(StoreClearTest, init) { + std::remove("/opt/secure/RFC/tr181store.ini"); + std::ofstream file("/opt/secure/RFC/tr181store.ini"); + file.close(); + + bool ret = m_rfcStoreage->init(); + EXPECT_EQ(ret, false); +} + +TEST(StoreClearTest, getRawValue) { + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.FWUpdate.Enable"; + string value = m_rfcStoreage->getRawValue(key); + EXPECT_EQ(value, ""); +} + +TEST(StoreClearTest, setRawValue_Flush) { + m_bsStore = XBSStore::getInstance(); + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Bootstrap.PartnerName"; + const string value = "sky"; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_SET; + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + m_bsStore->m_initialUpdate = true; + bool ret = m_bsStore->setRawValue(key, value,param.requestor); + EXPECT_EQ(ret, true); } */ GTEST_API_ int main(int argc, char *argv[]){ diff --git a/src/hostif/profiles/Ethernet/gtest/Makefile.am b/src/hostif/profiles/Ethernet/gtest/Makefile.am index b78f62cfb..1f03470da 100644 --- a/src/hostif/profiles/Ethernet/gtest/Makefile.am +++ b/src/hostif/profiles/Ethernet/gtest/Makefile.am @@ -21,20 +21,10 @@ AUTOMAKE_OPTIONS = subdir-objects bin_PROGRAMS = ethernet_gtest # Define the include directories -COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/handlers/include -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/hostif/profiles/Ethernet -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I/usr/include/rbus -I/usr/local/include/rbus $(GLIB_CFLAGS) $(G_THREAD_CFLAGS) - -if LIBSOUP3_ENABLE -COMMON_CPPFLAGS += -I/usr/include/libsoup-3.0 -DLIBSOUP3_ENABLE -else -COMMON_CPPFLAGS += -I/usr/include/libsoup-2.4 -endif +COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/handlers/include -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/hostif/profiles/Ethernet -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I/usr/include/rbus -I/usr/local/include/rbus $(GLIB_CFLAGS) $(G_THREAD_CFLAGS) -I/usr/include/libsoup-3.0 # Define the libraries to link against -COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl - -if LIBSOUP3_ENABLE -COMMON_LDADD += -lsoup-3.0 -endif +COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl -lsoup-3.0 # Define the compiler flags COMMON_CXXFLAGS = -frtti $(GLIB_CFLAGS) $(SOUP_LIBS) -fprofile-arcs -ftest-coverage diff --git a/src/hostif/profiles/Ethernet/gtest/gtest_ethernet.cpp b/src/hostif/profiles/Ethernet/gtest/gtest_ethernet.cpp index 3ab90fcd5..28a6bcb8e 100644 --- a/src/hostif/profiles/Ethernet/gtest/gtest_ethernet.cpp +++ b/src/hostif/profiles/Ethernet/gtest/gtest_ethernet.cpp @@ -178,6 +178,19 @@ TEST(EthernetTest, set_Device_Ethernet_Interface_Enable) { } } +TEST(EthernetTest, InterfaceLock_ReleaseLock) { + int instanceNumber = 0; + hostIf_EthernetInterface *ethernetIf= hostIf_EthernetInterface::getInstance(instanceNumber); + if(ethernetIf) + { + ethernetIf->getLock(); + ethernetIf->releaseLock(); + EXPECT_EQ(0, 0); + } + ethernetIf->closeInstance(ethernetIf); + ethernetIf->closeAllInstances(); +} + TEST(EthernetTest, get_Device_Ethernet_Interface_Stats_BytesSent) { int instanceNumber = 1; HOSTIF_MsgData_t param = { 0 }; @@ -395,6 +408,19 @@ TEST(EthernetTest, get_Device_Ethernet_Interface_Stats_UnknownProtoPacketsReceiv } } +TEST(EthernetTest, Lock_ReleaseLock) { + int instanceNumber = 0; + hostIf_EthernetInterfaceStats *ethernetIfStats = hostIf_EthernetInterfaceStats::getInstance(instanceNumber); + if(ethernetIfStats) + { + ethernetIfStats->getLock(); + ethernetIfStats->releaseLock(); + EXPECT_EQ(0, 0); + } + ethernetIfStats->closeInstance(ethernetIfStats); + ethernetIfStats->closeAllInstances(); +} + GTEST_API_ int main(int argc, char *argv[]){ char testresults_fullfilepath[GTEST_REPORT_FILEPATH_SIZE]; char buffer[GTEST_REPORT_FILEPATH_SIZE]; diff --git a/src/hostif/profiles/Time/Device_Time.h b/src/hostif/profiles/Time/Device_Time.h index 9378b49bf..7fc5cd481 100644 --- a/src/hostif/profiles/Time/Device_Time.h +++ b/src/hostif/profiles/Time/Device_Time.h @@ -436,6 +436,10 @@ class hostIf_Time { int get_Device_Time_CurrentUTCTime(HOSTIF_MsgData_t *, bool *pChanged = NULL); +#if defined(GTEST_ENABLE) + FRIEND_TEST(TimeTest, releaseLock); +#endif + }; /* End of TR_069_DEVICE_TIME_SETTER_API doxygen group. */ /** diff --git a/src/hostif/profiles/Time/gtest/Makefile.am b/src/hostif/profiles/Time/gtest/Makefile.am index 56c6fb60d..b3b56f490 100644 --- a/src/hostif/profiles/Time/gtest/Makefile.am +++ b/src/hostif/profiles/Time/gtest/Makefile.am @@ -21,21 +21,10 @@ AUTOMAKE_OPTIONS = subdir-objects bin_PROGRAMS = time_gtest # Define the include directories -COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DPARODUS -DUNIT_TEST -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/handlers/include -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/hostif/profiles/Time -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I/usr/include/rbus -I/usr/local/include/rbus $(GLIB_CFLAGS) $(G_THREAD_CFLAGS) - - -if LIBSOUP3_ENABLE -COMMON_CPPFLAGS += -I/usr/include/libsoup-3.0 -DLIBSOUP3_ENABLE -else -COMMON_CPPFLAGS += -I/usr/include/libsoup-2.4 -endif +COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DPARODUS -DUNIT_TEST -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/handlers/include -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/hostif/profiles/Time -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I/usr/include/rbus -I/usr/local/include/rbus $(GLIB_CFLAGS) $(G_THREAD_CFLAGS) -I/usr/include/libsoup-3.0 # Define the libraries to link against -COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl - -if LIBSOUP3_ENABLE -COMMON_LDADD += -lsoup-3.0 -endif +COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl -lsoup-3.0 # Define the compiler flags COMMON_CXXFLAGS = -frtti $(GLIB_CFLAGS) $(SOUP_LIBS) -fprofile-arcs -ftest-coverage diff --git a/src/hostif/profiles/Time/gtest/gtest_time.cpp b/src/hostif/profiles/Time/gtest/gtest_time.cpp index 950250861..6d07b29e5 100644 --- a/src/hostif/profiles/Time/gtest/gtest_time.cpp +++ b/src/hostif/profiles/Time/gtest/gtest_time.cpp @@ -123,6 +123,36 @@ TEST(TimeTest, get_Device_Time_CurrentUTCTime) { } } +TEST(TimeTest, releaseLock) { + int instanceNumber = 0; + bool pChanged = false; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + + hostIf_Time *hostIfTime= hostIf_Time::getInstance(instanceNumber); + if(hostIfTime) + { + hostIfTime->getLock(); + gboolean locked = g_mutex_trylock(&hostIfTime->m_mutex); + EXPECT_EQ(locked, false); + hostIfTime->releaseLock(); + } +} + +TEST(TimeTest, closeInstance) { + int instanceNumber = 0; + bool pChanged = false; + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + + hostIf_Time *hostIfTime= hostIf_Time::getInstance(instanceNumber); + if(hostIfTime) + { + hostIf_Time::closeInstance(hostIfTime); + hostIfTime->closeAllInstances(); + } +} + GTEST_API_ int main(int argc, char *argv[]){ char testresults_fullfilepath[GTEST_REPORT_FILEPATH_SIZE]; char buffer[GTEST_REPORT_FILEPATH_SIZE]; diff --git a/src/hostif/src/gtest/Makefile.am b/src/hostif/src/gtest/Makefile.am index 72cb04efa..abe5dd873 100644 --- a/src/hostif/src/gtest/Makefile.am +++ b/src/hostif/src/gtest/Makefile.am @@ -21,25 +21,13 @@ AUTOMAKE_OPTIONS = subdir-objects bin_PROGRAMS = src_gtest # Define the include directories -COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DPARODUS -DUNIT_TEST -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I$(TOP_DIR)/src/hostif/handlers/include -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/hostif/httpserver/include -I$(TOP_DIR)/src/hostif/handlers/src -I/usr/include/rbus -I/usr/local/include/rbus +COMMON_CPPFLAGS = -std=c++11 -DGTEST_ENABLE -DPARODUS -DUNIT_TEST -I/usr/include -I/usr/include/cjson -I$(TOP_DIR)/src/hostif/include -I$(TOP_DIR)/src/hostif/profiles/DeviceInfo -I$(TOP_DIR)/src/unittest/stubs -I$(TOP_DIR)/src/unittest/stubs/ds -I$(TOP_DIR)/src/unittest/stubs/rbus/include -I$(TOP_DIR)/src/hostif/handlers/include -I$(TOP_DIR)/src/hostif/parodusClient/pal -I$(TOP_DIR)/src/hostif/parodusClient/waldb -I$(TOP_DIR)/src/hostif/httpserver/include -I$(TOP_DIR)/src/hostif/handlers/src -I/usr/include/rbus -I/usr/local/include/rbus -I/usr/include/libsoup-3.0 -if LIBSOUP3_ENABLE -COMMON_CPPFLAGS += -I/usr/include/libsoup-3.0 -DLIBSOUP3_ENABLE -else -COMMON_CPPFLAGS += -I/usr/include/libsoup-2.4 -endif - -# Define the libraries to link against -COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl - -if LIBSOUP3_ENABLE -COMMON_LDADD += -lsoup-3.0 -endif +COMMON_LDADD = -lgtest -lgtest_main -lgmock_main -lgmock -lgcov $(GLIB_LIBS) -ltinyxml2 -lcjson -lcurl -lsoup-3.0 # Define the compiler flags COMMON_CXXFLAGS = -frtti $(GLIB_CFLAGS) $(SOUP_LIBS) -fprofile-arcs -ftest-coverage - # Define the source files src_gtest_SOURCES = $(TOP_DIR)/src/hostif/src/hostIf_utils.cpp $(TOP_DIR)/src/hostif/src/IniFile.cpp $(TOP_DIR)/src/unittest/stubs/secure_wrapper.c $(TOP_DIR)/src/hostif/profiles/DeviceInfo/XrdkCentralComRFCStore.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/XrdkCentralComRFC.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStore.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/XrdkCentralComBSStoreJournal.cpp $(TOP_DIR)/src/hostif/profiles/DeviceInfo/Device_DeviceInfo.cpp $(TOP_DIR)/src/hostif/handlers/src/hostIf_NotificationHandler.cpp $(TOP_DIR)/src/hostif/parodusClient/pal/webpa_notification.cpp $(TOP_DIR)/src/unittest/stubs/dm_stubs.cpp $(TOP_DIR)/src/hostif/parodusClient/waldb/waldb.cpp $(TOP_DIR)/src/unittest/stubs/wdmp-c.c $(TOP_DIR)/src/unittest/stubs/wdmp_internal.c $(TOP_DIR)/src/hostif/httpserver/src/http_server.cpp $(TOP_DIR)/src/hostif/httpserver/src/request_handler.cpp $(TOP_DIR)/src/hostif/httpserver/src/XrdkCentralComRFCVar.cpp $(TOP_DIR)/src/unittest/stubs/file_writer.cpp $(TOP_DIR)/src/hostif/src/gtest/gtest_src.cpp diff --git a/src/hostif/src/gtest/gtest_src.cpp b/src/hostif/src/gtest/gtest_src.cpp index b6ae6fcca..639b3f0a8 100644 --- a/src/hostif/src/gtest/gtest_src.cpp +++ b/src/hostif/src/gtest/gtest_src.cpp @@ -48,6 +48,10 @@ extern "C" using namespace std; +#ifdef GTEST_ENABLE +extern size_t (*getWriteCurlResponse(void))(void *ptr, size_t size, size_t nmemb, std::string stream); +#endif + XRFCStore* m_rfcStore; XBSStore* m_bsStore; XBSStoreJournal* m_bsStoreJournal; @@ -69,6 +73,14 @@ TEST(srcTest, load) { delete m_ini; } +TEST(srcTest, inValidFile) { + IniFile* m_ini = new IniFile(); + const string filename = "/opt/secure/RFC/bootstrap_test.ini"; + bool result = m_ini->load(filename); + EXPECT_EQ(result, false); + delete m_ini; +} + TEST(srcTest, value) { IniFile* m_ini = new IniFile(); const string key = "Device.Time.NTPServer5"; @@ -76,7 +88,7 @@ TEST(srcTest, value) { bool ret = m_ini->load("/opt/secure/RFC/bootstrap.ini"); string result = m_ini->value(key, defaultValue); - EXPECT_EQ(result, "time"); + EXPECT_EQ(result, "override_time4.com"); delete m_ini; } @@ -91,6 +103,26 @@ TEST(srcTest, srcsetValue) { delete m_ini; } +TEST(srcTest, srcsetDefaultValue) { + IniFile* m_ini = new IniFile(); + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_Syndication.PartnerId"; + const string value = "sky"; + + bool result = m_ini->setValue(key, value); + EXPECT_EQ(result, false); + delete m_ini; +} + +TEST(srcTest, flush) { + IniFile* m_ini = new IniFile(); + const string key = "Device.DeviceInfo.X_RDKCENTRAL-COM_Syndication.PartnerId"; + const string value = "sky"; + + m_ini->m_filename = "/opt/secure/RFC_test/bootstrap_temp.ini"; + bool result = m_ini->flush(); + EXPECT_EQ(result, false); + delete m_ini; +} /* TEST(srcTest, clear) { IniFile *inFile = new IniFile(); @@ -112,6 +144,8 @@ TEST(srcTest, getStringFromEnum) { const char *result = getStringFromEnum(myEnumMap, size, inputCode); EXPECT_EQ(result, "TWO"); + + const char *ret = getStringFromEnum(myEnumMap, 0, inputCode); } TEST(srcTest, getEnumFromString) { @@ -126,6 +160,9 @@ TEST(srcTest, getEnumFromString) { int ret = getEnumFromString(myEnumMap, size, "THREE"); EXPECT_EQ(ret, 3); + + int result = getEnumFromString(myEnumMap, 0, "THREE"); + EXPECT_EQ(result, -1); } TEST(srcTest, type_conversions) { @@ -151,13 +188,6 @@ TEST(srcTest, type_conversions) { uint uiret = get_uint(uptr); EXPECT_EQ(uiret, number); - /*const char* input = "true"; - bool ret = get_boolean("true"); - EXPECT_EQ(ret, true); */ - - string btosret = bool_to_string(false); - EXPECT_EQ(btosret, "false"); - int stoiret = string_to_int("123"); EXPECT_EQ(stoiret, 123); @@ -171,6 +201,22 @@ TEST(srcTest, type_conversions) { EXPECT_EQ(stobret, false); } +TEST(srcTest, bool_to_string) { + std::string value = bool_to_string(true); + EXPECT_EQ(value, "true"); + + string ret = bool_to_string(false); + EXPECT_EQ(ret, "false"); +} + +TEST(srcTest, string_to_bool) { + bool ret = string_to_bool("false"); + EXPECT_EQ(ret, false); + + bool value = string_to_bool("1"); + EXPECT_EQ(value, true); +} + TEST(srcTest, getBSUpdateEnum) { HostIf_Source_Type_t type; type = getBSUpdateEnum("allUpdate"); @@ -181,6 +227,12 @@ TEST(srcTest, getBSUpdateEnum) { type = getBSUpdateEnum("default"); EXPECT_EQ(type, HOSTIF_SRC_DEFAULT); + + type = getBSUpdateEnum("none"); + EXPECT_EQ(type, HOSTIF_NONE); + + type = getBSUpdateEnum(NULL); + EXPECT_EQ(type, HOSTIF_NONE); } @@ -249,6 +301,160 @@ TEST(srcTest, timeValDiff) { EXPECT_EQ(msec, 1700); } +TEST(srcTest, writeCurlResponse) { + const char* input = "MockCurlData"; + size_t size = 1; + size_t nmemb = strlen(input); + std::string response; + size_t written = getWriteCurlResponse()((void*)input, size, nmemb, response); + EXPECT_EQ(written, nmemb); +} + +TEST(srcTest, getCurrentTime) { + struct timespec ts; + getCurrentTime(&ts); + EXPECT_GT(ts.tv_sec, 0); + + EXPECT_GE(ts.tv_nsec, 0); + EXPECT_LT(ts.tv_nsec, 1000000000L); + +} + +TEST(srcTest, ReturnsEnvValueIfSet) +{ + const char* envName = "TEST_ENV_VAR"; + const char* envValue = "expected_value"; + const char* defaultValue = "default_value"; + + // Set environment variable + setenv(envName, envValue, 1); + + // Call function + char* result = getenvOrDefault(envName, defaultValue); + + // Validate + EXPECT_EQ(std::string(result), std::string(envValue)); +} + + +TEST(srcTest, triggerResetScript) +{ + setResetState(ColdReset); + triggerResetScript(); + + setResetState(FactoryReset); + triggerResetScript(); + + setResetState(WarehouseReset); + triggerResetScript(); + + setResetState(CustomerReset); + triggerResetScript(); + + EXPECT_EQ(0, 0); +} + +TEST(srcTest, getResetState) +{ + setResetState(FactoryReset); + eSTBResetState state = getResetState(); + EXPECT_EQ(state, FactoryReset); +} + +TEST(srcTest, get_security_token) +{ + std::string token = get_security_token(); + EXPECT_EQ(token, ""); +} + +TEST(srcTest, putBoolValue) +{ + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Airplay.Enable", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_BooleanType; + param.paramLen = sizeof(hostIf_BooleanType); + + putValue(¶m, "true"); + cout << "msgData.paramValue = " << get_boolean(param.paramValue) << endl; + EXPECT_EQ(get_boolean(param.paramValue), true); +} + +TEST(srcTest, putIntValue) +{ + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.SWDLSpLimit.TopSpeed", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_IntegerType; + param.paramLen = sizeof(hostIf_IntegerType); + + putValue(¶m, "14200"); + cout << "msgData.paramValue = " << get_int(param.paramValue) << endl; + EXPECT_EQ(get_int(param.paramValue), 14200); +} + +TEST(srcTest, putStringValue) +{ + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Bootstrap.PartnerProductName", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_StringType; + param.paramLen = strlen(param.paramValue); + + putValue(¶m, "testName"); + cout << "msgData.paramValue = " << param.paramValue << endl; + EXPECT_STREQ(param.paramValue, "testName"); +} + +TEST(srcTest, putUnsignedValue) +{ + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.IP.Interface.1.Stats.BytesReceived", TR69HOSTIFMGR_MAX_PARAM_LEN - 1); + param.bsUpdate = HOSTIF_NONE; + param.requestor = HOSTIF_SRC_RFC; + param.paramtype = hostIf_UnsignedLongType; + param.paramLen = sizeof(hostIf_UnsignedLongType); + + putValue(¶m, "1048576"); + cout << "msgData.paramValue = " << get_ulong(param.paramValue) << endl; + EXPECT_EQ(get_ulong(param.paramValue), 1048576); +} + +TEST(srcTest, ReturnsTrueWhenInputIsTrue) +{ + bool value = true; + EXPECT_EQ(get_boolean((const char *)&value), true); +} + + +TEST(srcTest, getStringValue) +{ + HOSTIF_MsgData_t param = { 0 }; + memset(¶m,0,sizeof(HOSTIF_MsgData_t)); + param.reqType = HOSTIF_GET; + strncpy (param.paramName, "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Airplay.Enable", 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); + + std::string value = getStringValue(¶m); + cout << "param.paramValue = " << param.paramValue << endl; + EXPECT_EQ(value, "true"); +} GTEST_API_ int main(int argc, char *argv[]){ char testresults_fullfilepath[GTEST_REPORT_FILEPATH_SIZE]; diff --git a/src/hostif/src/hostIf_utils.cpp b/src/hostif/src/hostIf_utils.cpp index 054a55c29..68627f913 100644 --- a/src/hostif/src/hostIf_utils.cpp +++ b/src/hostif/src/hostIf_utils.cpp @@ -643,5 +643,11 @@ string getJsonRPCData(std::string postData) } } +#ifdef GTEST_ENABLE +size_t (*getWriteCurlResponse(void))(void *ptr, size_t size, size_t nmemb, std::string stream) { + return &writeCurlResponse; +} +#endif + /** @} */ /** @} */ diff --git a/src/integrationtest/conf/bootstrap.ini b/src/integrationtest/conf/bootstrap.ini index 2c68c633c..99467fef3 100644 --- a/src/integrationtest/conf/bootstrap.ini +++ b/src/integrationtest/conf/bootstrap.ini @@ -1 +1,2 @@ Device.DeviceInfo.X_RDKCENTRAL-COM_Syndication.PartnerId=global +Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Bootstrap.PartnerName=comcast diff --git a/src/unittest/stubs/remote_debugger.json b/src/unittest/stubs/remote_debugger.json new file mode 100644 index 000000000..1f36b579c --- /dev/null +++ b/src/unittest/stubs/remote_debugger.json @@ -0,0 +1,68 @@ +{ + "DebugCategory": { + "DebugIssueType": { + "DebugCommands": "command1;command2;commmand3", + "DebugTimeout" : 10 + } + }, + "Sanity": { + "Check" : { + "Commands" : [ "rm -rf", "kill", "pkill", "iptables", "ip6tables" ] + } + }, + "Device" : { + "Info" : { + "Commands": "cat /version.txt;cat /etc/device.properties;uname -r", + "Timeout" : 10 + }, + "Uptime" : { + "Commands": "uptime", + "Timeout" : 10 + }, + "Dump" : { + "Commands": "tcpdump -w RRD_LOCATION/capture.pcap &", + "Timeout" : 10 + } + }, + "Command" : { + "Harm" : { + "Commands": "rm -rf", + "Timeout" : 10 + } + }, + "Process" : { + "ProcessStatus" : { + "Commands": "cat /opt/logs/top_log.txt*", + "Timeout" : 10 + }, + "ServiceStatus" : { + "Commands": "systemctl list-units --type=service --all", + "Timeout" : 10 + } + }, + "DeepSleep": { + "Audio" : { + "AudioStatus" : { + "Commands": "cat /sys/class/avsync_session0/session_stat;cat /sys/class/vdec/vdec_status;hal_dump", + "Timeout" : 10 + } + }, + "Video" : { + "VideoStatus" : { + "Commands": "cat /sys/class/avsync_session0/session_stat;cat /sys/class/vdec/vdec_status;hal_dump", + "Timeout" : 10 + } + }, + "Process" : { + "ProcessStatus" : { + "Commands": "cat /opt/logs/top_log.txt*", + "Timeout" : 10 + }, + "ServiceStatus" : { + "Commands": "systemctl list-units --type=service --all", + "Timeout" : 10 + } + + } + } +} diff --git a/src/unittest/stubs/rfcdefaults.ini b/src/unittest/stubs/rfcdefaults.ini index 1cedddc0d..a3713354e 100644 --- a/src/unittest/stubs/rfcdefaults.ini +++ b/src/unittest/stubs/rfcdefaults.ini @@ -1 +1,2 @@ Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Airplay.Enable=false +Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.FWUpdate.AutoExcluded.Enable=true