Backup:MissionManager module.

application/HunttingCamera/src/MainThread.cpp

@@ -79,4 +79,10 @@ void MainThread::Runing(void)
     while (mMainThreadRuning) {
         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
     }
+}
+extern bool CreateProtocolHandleImpl(void);
+void MainThread::CustomizationInit(void)
+{
+    //
+    CreateProtocolHandleImpl();
 }

application/HunttingCamera/src/MainThread.h

@@ -26,7 +26,7 @@ public:
     virtual StatusCode UnInit(void);
     void Runing(void);
     void Exit(void) { mMainThreadRuning = false; }
-    virtual void CustomizationInit(void) {}
+    virtual void CustomizationInit(void);
 
 private:
     StatusCode CreateAllModules(void);

application/MissionManager/src/AppMonitor.cpp

@@ -1,6 +1,8 @@
 #include "AppMonitor.h"
+#include "ILog.h"
 StatusCode AppMonitor::GetProductInfo(AppGetProductInfo &param)
 {
+    LogInfo("AppMonitor::GetProductInfo.\n");
     param.mModel = "test";
     param.mCompany = "test";
     param.mSoc = "test";

application/MissionManager/src/MissionState.h

@@ -16,7 +16,7 @@
 #define MISSION_STATE_H
 #include "DataProcessing.h"
 #include "IStateMachine.h"
-class MissionState : public State, public DataProcessing
+class MissionState : public State, public DataProcessing, public std::enable_shared_from_this<MissionState>
 {
 public:
     MissionState(const std::string &name);

application/MissionManager/src/TestMissionState.cpp

@@ -20,8 +20,11 @@ void TestMissionState::GoInState()
 {
     MissionState::GoInState();
     LogInfo(" ========== TestMissionState::GoInState.\n");
-    AppParam mAppParam("192.168.1.29", APP_MANAGER_HTTP_SERVER_PORT); // TODO:
+    AppParam mAppParam(APP_MANAGER_HTTP_SERVER_IP, APP_MANAGER_HTTP_SERVER_PORT); // TODO:
     IAppManager::GetInstance()->Init(mAppParam);
+    std::shared_ptr<VAppMonitor> monitor =
+        std::dynamic_pointer_cast<TestMissionState>(MissionState::shared_from_this());
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
 }
 void TestMissionState::GoOutState()
 {

build/cmake/toolchain/linux.toolchain.cmake

@@ -49,7 +49,7 @@ set(LOG_SUPPORT                            "true")
 set(GOAHEAD_DOCUMENTS_PATH                 "web")
 set(GOAHEAD_UPLOAD_TMP_PATH                "./goahead")
 set(GOAHEAD_UPLOAD_PATH                    "${GOAHEAD_UPLOAD_TMP_PATH}")
-set(GOAHEAD_LIMIT_POST                     "33554432") # If not defined means using default setting. See goahead-linux-static-fancy.mk
+set(GOAHEAD_LIMIT_POST                     "335544320") # If not defined means using default setting. See goahead-linux-static-fancy.mk
 # GOAHEAD_CONFIG_FILE_PATH should be set when cross compile
 # set(GOAHEAD_CONFIG_FILE_PATH               "./")
 # ------------ build GoAhead end ------------ #

middleware/AppManager/src/AppManager.cpp

@@ -19,8 +19,8 @@
 #include "WebServer.h"
 AppManager::AppManager()
 {
-    //
     // mHttpServerRuning = false;
+    mProtocolHandle = std::make_shared<IAppProtocolHandle>();
 }
 const StatusCode AppManager::Init(const AppParam &param)
 {

middleware/AppManager/src/Protocol/SixFrame/SixFrameHandle.cpp

@@ -102,14 +102,24 @@ void SixFrameHandle::RequestGetProductInfo(const std::string &url, ResponseHandl
 {
     LogInfo("RequestGetProductInfo.\n");
     char *resultStr = nullptr;
-    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
-    resultStr = cJSON_Print(result);
     AppGetProductInfo param;
     mAppMonitor->GetProductInfo(param);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    ResponseGetProductInfo(result, param);
+    resultStr = cJSON_Print(result);
     responseHandle(resultStr, context);
     free(resultStr);
     cJSON_Delete(result);
 }
+void inline SixFrameHandle::ResponseGetProductInfo(cJSON *result, const AppGetProductInfo &param)
+{
+    cJSON *info = nullptr;
+    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
+    cJSON_AddStringToObject(info, "model", param.mModel.c_str());
+    cJSON_AddStringToObject(info, "company", param.mCompany.c_str());
+    cJSON_AddStringToObject(info, "soc", param.mSoc.c_str());
+    cJSON_AddStringToObject(info, "sp", param.mSp.c_str());
+}
 void SixFrameHandle::RequestGetDeviceAttr(const std::string &url, ResponseHandle responseHandle, void *context)
 {
     LogInfo("RequestGetDeviceAttr.\n");

middleware/AppManager/src/Protocol/SixFrame/SixFrameHandle.h

@@ -59,6 +59,7 @@ private:
                         void *context);
     void DoNothing(const std::string &url, ResponseHandle responseHandle, void *context);
     void RequestGetProductInfo(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetProductInfo(cJSON *result, const AppGetProductInfo &param);
     void RequestGetDeviceAttr(const std::string &url, ResponseHandle responseHandle, void *context);
     void ResponseGetDeviceAttr(cJSON *result, const AppGetDeviceAttr &param);
     void RequestGetMediaInfo(const std::string &url, ResponseHandle responseHandle, void *context);

test/application/CMakeLists.txt

@@ -1,2 +1,3 @@
 
-add_subdirectory(HunttingCamera)
+add_subdirectory(HunttingCamera)
+add_subdirectory(MissionManager)

test/application/HunttingCamera/src_mock/HunttingCamera_Mock_Test.cpp

@@ -73,7 +73,7 @@ TEST_F(HunttingCameraTest, INTEGRATION_DeviceManager_EXAMPLE_Demo)
     MainThread::GetInstance()->Init();
     TestManager::ResetTimeOut(1000 * 3);
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    MockGetMediaInfo();
+    MockGetProductInfo();
     MainThread::GetInstance()->Runing();
 }
 } // namespace HunttingCameraTest

test/application/MissionManager/CMakeLists.txt

@@ -0,0 +1,2 @@
+
+add_subdirectory(tool)

test/application/MissionManager/tool/CMakeLists.txt

@@ -0,0 +1,58 @@
+include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
+set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
+set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
+
+include_directories(
+    ./src
+    ./include
+    ${UTILS_SOURCE_PATH}/StatusCode/include
+    ${UTILS_SOURCE_PATH}/Log/include
+    ${APPLICATION_SOURCE_PATH}/MissionManager/include
+    ${APPLICATION_SOURCE_PATH}/MissionManager/src
+    ${MIDDLEWARE_SOURCE_PATH}/AppManager/include
+    ${MIDDLEWARE_SOURCE_PATH}/StateMachine/include
+    ${TEST_SOURCE_PATH}
+    ${TEST_SOURCE_PATH}/middleware/AppManager/tool/include
+    ${TEST_SOURCE_PATH}/middleware/AppManager/tool/src
+    ${EXTERNAL_SOURCE_PATH}/gtest/googletest-release-1.11.0/googletest/include
+    ${EXTERNAL_SOURCE_PATH}/gtest/googletest-release-1.11.0/googlemock/include
+)
+# link_directories(
+#     ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
+# )
+
+aux_source_directory(./src TEST_TOOL_SRC_FILES)
+set(TEST_TOOL_TARGET MissionManagerTestTool)
+add_library(${TEST_TOOL_TARGET} STATIC ${TEST_TOOL_SRC_FILES})
+target_link_libraries(${TEST_TOOL_TARGET} MissionManager AppManagerTestTool Log)
+
+if ("${CLANG_TIDY_SUPPORT}" MATCHES "true")
+add_custom_target(
+    MissionManagerTestTool_code_check
+    COMMAND ${CLANG_TIDY_EXE}
+    -checks='${CLANG_TIDY_CHECKS}'
+    --header-filter=.*
+    --system-headers=false
+    ${TEST_TOOL_SRC_FILES}
+    ${CLANG_TIDY_CONFIG}
+    -p ${PLATFORM_PATH}/cmake-shell
+    WORKING_DIRECTORY ${TEST_SOURCE_PATH}/application/MissionManager/tool
+)
+file(GLOB_RECURSE HEADER_FILES *.h)
+add_custom_target(
+    MissionManagerTestTool_code_format
+    COMMAND ${CLANG_FORMAT_EXE}
+    -style=file
+    -i ${TEST_TOOL_SRC_FILES} ${HEADER_FILES}
+    WORKING_DIRECTORY ${TEST_SOURCE_PATH}/application/MissionManager/tool
+)
+add_custom_command(
+    TARGET ${TEST_TOOL_TARGET}
+    PRE_BUILD
+    COMMAND make MissionManagerTestTool_code_check
+    COMMAND make MissionManagerTestTool_code_format
+    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
+)
+endif()
+
+define_file_name(${TEST_TOOL_TARGET})

test/application/MissionManager/tool/include/MissionManagerTestTool.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * 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.
+ */
+#ifndef MISSION_MANAGER_TEST_TOOL_H
+#define MISSION_MANAGER_TEST_TOOL_H
+#include "GtestUsing.h"
+#include "IMissionManager.h"
+#include <memory>
+class MissionManagerTestTool
+{
+public:
+    MissionManagerTestTool() = default;
+    virtual ~MissionManagerTestTool() = default;
+    void Init(void);
+    void UnInit(void);
+
+private:
+    // void MissionManagerMockInit(std::shared_ptr<IMissionManager> &vMock);
+
+    // private:
+    //     std::shared_ptr<IMissionManager> mMissionManagerMock;
+    //     std::shared_ptr<VAppMonitor> mAppMonitorMock;
+
+    // public:
+    //     static std::shared_ptr<VAppMonitor> MakeMonitorMock(void);
+    //     void AppMonitorInit(std::shared_ptr<VAppMonitor> &vMock);
+};
+#endif

test/application/MissionManager/tool/src/MissionManagerTestTool.cpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * 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.
+ */
+#include "MissionManagerTestTool.h"
+void MissionManagerTestTool::Init(void)
+{
+    // ServersMock::GetInstance()->Init();
+    // mMissionManagerMock = std::make_shared<MissionManagerMock>();
+    // MissionManagerMockInit(mMissionManagerMock);
+    // std::shared_ptr<MissionManagerMock> mock = std::dynamic_pointer_cast<MissionManagerMock>(mMissionManagerMock);
+    // OverrideMissionManagerMakePtrObject(mock);
+}
+void MissionManagerTestTool::UnInit(void)
+{
+    // ServersMock::GetInstance()->UnInit();
+    // mMissionManagerMock.reset();
+    // mAppMonitorMock.reset();
+    // CancelOverrideMissionManagerMakePtrObject();
+}

test/application/MissionManager/tool/src/TestMissionStateMock.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * 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.
+ */
+#include "TestMissionStateMock.h"
+#include "AppMonitorMock.h"
+#include "ILog.h"
+StatusCode TestMissionStateTest::GetProductInfo(AppGetProductInfo &param)
+{
+    LogInfo("TestMissionStateTest::GetProductInfo\n");
+    StatusCode code = GetProductInfoTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return AppMonitor::GetProductInfo(param);
+    }
+    return code;
+}
+StatusCode TestMissionStateTest::GetDeviceAttr(AppGetDeviceAttr &param)
+{
+    LogInfo("TestMissionStateTest::GetDeviceAttr\n");
+    StatusCode code = GetDeviceAttrTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return AppMonitor::GetDeviceAttr(param);
+    }
+    return code;
+}
+StatusCode TestMissionStateTest::GetMediaInfo(AppGetMeidaInfo &param)
+{
+    LogInfo("TestMissionStateTest::GetMediaInfo\n");
+    StatusCode code = GetMediaInfoTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return AppMonitor::GetMediaInfo(param);
+    }
+    return code;
+}
+StatusCode TestMissionStateTest::GetSdCardInfo(AppGetSdCardInfo &param)
+{
+    LogInfo("TestMissionStateTest::GetSdCardInfo\n");
+    StatusCode code = GetSdCardInfoTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return AppMonitor::GetSdCardInfo(param);
+    }
+    return code;
+}
+StatusCode TestMissionStateTest::GetBatteryInfo(AppGetBatteryInfo &param)
+{
+    LogInfo("TestMissionStateTest::GetBatteryInfo\n");
+    StatusCode code = GetBatteryInfoTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return AppMonitor::GetBatteryInfo(param);
+    }
+    return code;
+}
+StatusCode TestMissionStateTest::SetDateTime(AppSetDateTime &param)
+{
+    LogInfo("TestMissionStateTest::SetDateTime\n");
+    LogInfo("mYear = %u\n", param.mYear);
+    LogInfo("mMonth = %02u\n", param.mMonth);
+    LogInfo("mDay = %02u\n", param.mDay);
+    LogInfo("mHour = %02u\n", param.mHour);
+    LogInfo("mMinute = %02u\n", param.mMinute);
+    LogInfo("mSecond = %02u\n", param.mSecond);
+    StatusCode code = SetDateTimeTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return AppMonitor::SetDateTime(param);
+    }
+    return code;
+}
+StatusCode TestMissionStateTest::SetTimeZone(const unsigned int &zone)
+{
+    LogInfo("TestMissionStateTest::SetTimeZone = %u\n", zone);
+    StatusCode code = SetTimeZoneTrace(zone);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return AppMonitor::SetTimeZone(zone);
+    }
+    return code;
+}
+StatusCode TestMissionStateTest::UploadFile(AppUploadFile &param)
+{
+    LogInfo("TestMissionStateTest::UploadFile\n");
+    StatusCode code = UploadFileTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return AppMonitor::UploadFile(param);
+    }
+    return code;
+}

test/application/MissionManager/tool/src/TestMissionStateMock.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * 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.
+ */
+#ifndef TEST_MISSION_STATE_MOCK_H
+#define TEST_MISSION_STATE_MOCK_H
+#include "AppMonitorMock.h"
+#include "MissionManagerTestTool.h"
+#include "TestMissionState.h"
+class TestMissionStateTest : public TestMissionState, virtual public AppMonitorTrace
+{
+public:
+    TestMissionStateTest() = default;
+    virtual ~TestMissionStateTest() = default;
+    StatusCode GetProductInfo(AppGetProductInfo &param) override;
+    StatusCode GetDeviceAttr(AppGetDeviceAttr &param) override;
+    StatusCode GetMediaInfo(AppGetMeidaInfo &param) override;
+    StatusCode GetSdCardInfo(AppGetSdCardInfo &param) override;
+    StatusCode GetBatteryInfo(AppGetBatteryInfo &param) override;
+    StatusCode SetDateTime(AppSetDateTime &param) override;
+    StatusCode SetTimeZone(const unsigned int &zone) override;
+    StatusCode UploadFile(AppUploadFile &param) override;
+    // const StatusCode SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor) override;
+
+protected:
+    // virtual const StatusCode SetAppMonitorTrace(std::shared_ptr<VAppMonitor> &monitor);
+};
+class TestMissionStateMock : public AppMonitorMock, public TestMissionStateTest
+{
+public:
+    TestMissionStateMock() = default;
+    virtual ~TestMissionStateMock() = default;
+    // MOCK_METHOD1(SetAppMonitorTrace, const StatusCode(std::shared_ptr<VAppMonitor> &));
+};
+#endif

test/middleware/AppManager/tool/src/AppManagerTestTool.cpp

@@ -36,84 +36,82 @@ void AppManagerTestTool::UnInit(void)
 }
 void AppManagerTestTool::MockGetProductInfo(void)
 {
-    //
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (mock) {
+        EXPECT_CALL(*mock.get(), GetProductInfoTrace(_))
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    }
     ServersMock::GetInstance()->MockGetProductInfo();
 }
 void AppManagerTestTool::MockGetDeviceAttr(void)
 {
     std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
-    if (!mock) {
+    if (mock) {
-        LogError("vMock error.\n");
+        EXPECT_CALL(*mock.get(), GetDeviceAttrTrace(_))
-        return;
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     }
-    EXPECT_CALL(*mock.get(), GetDeviceAttrTrace(_))
-        .Times(ONLY_BE_CALLED_ONCE)
-        .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     ServersMock::GetInstance()->MockGetDeviceAttr();
 }
 void AppManagerTestTool::MockGetMediaInfo(void)
 {
     std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
-    if (!mock) {
+    if (mock) {
-        LogError("vMock error.\n");
+        EXPECT_CALL(*mock.get(), GetMediaInfoTrace(_))
-        return;
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     }
-    EXPECT_CALL(*mock.get(), GetMediaInfoTrace(_))
-        .Times(ONLY_BE_CALLED_ONCE)
-        .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     ServersMock::GetInstance()->MockGetMediaInfo();
 }
 void AppManagerTestTool::MockGetSdCardInfo(void)
 {
     std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
-    if (!mock) {
+    if (mock) {
-        LogError("vMock error.\n");
+        EXPECT_CALL(*mock.get(), GetSdCardInfoTrace(_))
-        return;
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     }
-    EXPECT_CALL(*mock.get(), GetSdCardInfoTrace(_))
-        .Times(ONLY_BE_CALLED_ONCE)
-        .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     ServersMock::GetInstance()->MockGetSdCardInfo();
 }
 void AppManagerTestTool::MockGetBatteryInfo(void)
 {
     std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
-    if (!mock) {
+    if (mock) {
-        LogError("vMock error.\n");
+        EXPECT_CALL(*mock.get(), GetBatteryInfoTrace(_))
-        return;
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     }
-    EXPECT_CALL(*mock.get(), GetBatteryInfoTrace(_))
-        .Times(ONLY_BE_CALLED_ONCE)
-        .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     ServersMock::GetInstance()->MockGetBatteryInfo();
 }
 void AppManagerTestTool::MockSetDateTime(void)
 {
     std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
-    if (!mock) {
+    if (mock) {
-        LogError("vMock error.\n");
+        EXPECT_CALL(*mock.get(), SetDateTimeTrace(_))
-        return;
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     }
-    EXPECT_CALL(*mock.get(), SetDateTimeTrace(_))
-        .Times(ONLY_BE_CALLED_ONCE)
-        .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     ServersMock::GetInstance()->MockSetDateTime();
 }
 void AppManagerTestTool::MockSetTimeZone(void)
 {
     std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
-    if (!mock) {
+    if (mock) {
-        LogError("vMock error.\n");
+        EXPECT_CALL(*mock.get(), SetTimeZoneTrace(_))
-        return;
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     }
-    EXPECT_CALL(*mock.get(), SetTimeZoneTrace(_))
-        .Times(ONLY_BE_CALLED_ONCE)
-        .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     ServersMock::GetInstance()->MockSetTimeZone();
 }
 void AppManagerTestTool::MockUploadFiles(void)
 {
-    //
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (mock) {
+        EXPECT_CALL(*mock.get(), UploadFileTrace(_))
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    }
     ServersMock::GetInstance()->MockUploadFiles();
 }
 void AppManagerTestTool::AppManagerMockInit(std::shared_ptr<IAppManager> &vMock)