Germany/embedded-framework
7
0
Fork 0
mirror of https://gitee.com/jiuyilian/embedded-framework.git synced 2025-01-06 10:16:51 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add:SixFrame protocol.

Browse Source
This commit is contained in:
Fancy code 2024-03-23 20:39:05 +08:00
parent 7f5847cbdb
commit 053d2dbda3
17 changed files with 815 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -60,6 +60,8 @@ if ("${CLANG_TIDY_SUPPORT}" MATCHES "true")
--header-filter=.*
--system-headers=false
${ALL_MODEFIED_FILES}
${CLANG_TIDY_CONFIG}
--line-filter='[{\"name\":\"${EXTERNAL_SOURCE_PATH}/gtest/googletest-release-1.11.0/googletest/include/getest/*.h\"}]'
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${PLATFORM_PATH}
)

2
application/MissionManager/src/AppMonitor.cpp
View File

@ -60,7 +60,7 @@ StatusCode AppMonitor::GetBatteryInfo(AppGetBatteryInfo &param)
param.mChargeStatus = ChargeStatus::CHARGING;
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode AppMonitor::SetDateTime(AppSetDateTime &param)
StatusCode AppMonitor::SetDateTime(const AppSetDateTime &param)
{
//
return CreateStatusCode(STATUS_CODE_OK);

2
application/MissionManager/src/AppMonitor.h
View File

@ -25,7 +25,7 @@ public:
StatusCode GetMediaInfo(AppGetMeidaInfo &param) override;
StatusCode GetSdCardInfo(AppGetSdCardInfo &param) override;
StatusCode GetBatteryInfo(AppGetBatteryInfo &param) override;
StatusCode SetDateTime(AppSetDateTime &param) override;
StatusCode SetDateTime(const AppSetDateTime &param) override;
StatusCode SetTimeZone(const unsigned int &zone) override;
StatusCode UploadFile(AppUploadFile &param) override;
};

152
middleware/AppManager/include/IAppManager.h
View File

@ -62,6 +62,92 @@ enum class StorageType
SD_CARD_2,
END
};
enum class PlayBackEvent
{
START = 0,
STOP,
END
};
enum class StorageFileType
{
VIDEO = 0,
PICTURE,
END
};
enum class StorageFileEvent
{
LOOP = 0,
PIR,
CRASH,
END
};
enum class MicStatus
{
OFF = 0,
ON,
END
};
enum class GpsCapability
{
NOT_SUPPORT = 0,
END
};
enum class DeviceType
{
DASH_CAMERA = 0,
END
};
enum class DashAlbum
{
SUPPORT_PARKING_MONITOR_ALBUM = 0,
NOT_SUPPORT_PARKING_MONITOR_ALBUM,
END
};
enum class AppLock
{
NOT_SUPPORT_APP_LOCK = 0,
SUPPORT_APP_LOCK,
END
};
enum class DeleteLock
{
SUPPORT_DELETE_LOCK = 0,
NOT_SUPPORT_DELETE_LOCK,
END
};
enum class DeviceMode
{
NEED_TO_SWITCH = 0,
NOT_NEED_TO_SWITCH,
END
};
enum class PlaybackType
{
DOWNLOAD_PLAYBACK = 0,
RTSP_TCP,
RTSP_UDP,
END
};
enum class PhotographCapability
{
SUPPORT_TAKE_PICTURE = 0,
NOT_SUPPORT_TAKE_PICTURE,
END
};
enum class WifiCapability
{
SUPPORT_MODIFY_SSID_AND_PASSWORD = 0,
ONLY_SUPPORT_MODIFY_PASSWORD,
NOLY_SUPPORT_MODIFY_SSID,
NOT_SUPPORT_MODIFY_ANYTHING,
END
};
enum class FileCopy
{
NOT_SUPPORT_COPY = 0,
SUPPORT_COPY,
END
};
typedef struct app_get_product_info
{
app_get_product_info() {}
@ -114,23 +200,34 @@ typedef struct app_get_battery_info
} AppGetBatteryInfo;
typedef struct app_get_param_value
{
app_get_param_value()
{
mCapacity = 0;
mChargeStatus = ChargeStatus::END;
}
int mCapacity;
ChargeStatus mChargeStatus;
app_get_param_value() { mMicStatus = MicStatus::END; }
MicStatus mMicStatus;
} AppGetParamValue;
typedef struct app_get_capability
{
app_get_capability()
{
mCapacity = 0;
mChargeStatus = ChargeStatus::END;
mGpsCapability = GpsCapability::END;
mDeviceType = DeviceType::END;
mAlbum = DashAlbum::END;
mAppLock = AppLock::END;
mDeleteLock = DeleteLock::END;
mDeviceMode = DeviceMode::END;
mPlaybackType = PlaybackType::END;
mPhotographCapability = PhotographCapability::END;
mWifiCapability = WifiCapability::END;
mFileCopy = FileCopy::END;
}
int mCapacity;
ChargeStatus mChargeStatus;
GpsCapability mGpsCapability;
DeviceType mDeviceType;
DashAlbum mAlbum;
AppLock mAppLock;
DeleteLock mDeleteLock;
DeviceMode mDeviceMode;
PlaybackType mPlaybackType;
PhotographCapability mPhotographCapability;
WifiCapability mWifiCapability;
FileCopy mFileCopy;
} AppGetCapability;
typedef struct app_get_storage_info
{
@ -147,6 +244,33 @@ typedef struct app_get_storage_info
int mFree;
int mTotal;
} AppGetStorageInfo;
typedef struct app_get_file_info
{
app_get_file_info()
{
mStartIndex = 0;
mStopIndex = 0;
mEvent = StorageFileEvent::END;
}
int mStartIndex;
int mStopIndex;
StorageFileEvent mEvent;
} AppGetFileInfo;
typedef struct app_get_file_list
{
app_get_file_list()
{
mDuration = 0;
mSize = 0;
mCreateTime_s = 0;
mType = StorageFileType::END;
}
std::string mName;
int mDuration;
int mSize;
time_t mCreateTime_s;
StorageFileType mType;
} AppGetFileList;
typedef struct app_set_param_value
{
app_set_param_value() { mValue = -1; }
@ -191,10 +315,12 @@ public:
virtual StatusCode GetCapability(AppGetCapability &param);
virtual StatusCode GetLockVideoStatus(LockVideoStatus &param);
virtual StatusCode GetStorageInfo(std::vector<AppGetStorageInfo> &param);
virtual StatusCode SetDateTime(AppSetDateTime &param);
virtual StatusCode GetStorageFileList(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param);
virtual StatusCode SetDateTime(const AppSetDateTime &param);
virtual StatusCode SetTimeZone(const unsigned int &zone);
virtual StatusCode SetParamValue(AppSetParamValue &param);
virtual StatusCode SetParamValue(const AppSetParamValue &param);
virtual StatusCode EnterRecorder(void);
virtual StatusCode AppPlayback(const PlayBackEvent &event);
virtual StatusCode UploadFile(AppUploadFile &param);
};
typedef struct app_param

15
middleware/AppManager/src/IAppManager.cpp
View File

@ -47,13 +47,24 @@ StatusCode VAppMonitor::GetStorageInfo(std::vector<AppGetStorageInfo> &param)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode VAppMonitor::SetDateTime(AppSetDateTime &param) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }
StatusCode VAppMonitor::GetStorageFileList(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode VAppMonitor::SetDateTime(const AppSetDateTime &param)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode VAppMonitor::SetTimeZone(const unsigned int &zone) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }
StatusCode VAppMonitor::SetParamValue(AppSetParamValue &param)
StatusCode VAppMonitor::SetParamValue(const AppSetParamValue &param)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode VAppMonitor::EnterRecorder(void) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }
StatusCode VAppMonitor::AppPlayback(const PlayBackEvent &event)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode VAppMonitor::UploadFile(AppUploadFile &param) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }
std::shared_ptr<IAppManager> &IAppManager::GetInstance(std::shared_ptr<IAppManager> *impl)
{

170
middleware/AppManager/src/Protocol/SixFrame/SixFrameHandle.cpp
View File

@ -20,21 +20,25 @@ using std::placeholders::_1;
using std::placeholders::_2;
using std::placeholders::_3;
// using std::placeholders::_4;
const char *CJSON_INFO_STRING = "info";
const char *APP_GET_PRODUCT_INFO = "/app/getproductinfo";
const char *APP_GET_DEVICE_ATTR = "/app/getdeviceattr";
const char *APP_GET_MEDIA_INFO = "/app/getmediainfo";
const char *APP_GET_SD_CARD_INFO = "/app/getsdinfo";
const char *APP_GET_BATTERY_INFO = "/app/getbatteryinfo";
const char *APP_GET_PARAM_VALUE = "/app/getparamvalue";
const char *APP_GET_CAPABILITY = "/app/capability";
const char *APP_GET_LOCK_VIDEO_STATUS = "/app/getlockvideostatus";
const char *APP_GET_STORAGE_INFO = "/app/getstorageinfo";
const char *APP_SET_DATE_TIME = "/app/setsystime";
const char *APP_SET_TIME_ZONE = "/app/settimezone";
const char *APP_SET_PARAM_VALUE = "/app/setparamvalue";
const char *APP_ENTER_RECORDER = "/app/enterrecorder";
const char *APP_UPLOAD_FILE = "/upload";
// clang-format off
const char *CJSON_INFO_STRING = "info";
const char *APP_GET_PRODUCT_INFO = "/app/getproductinfo";
const char *APP_GET_DEVICE_ATTR = "/app/getdeviceattr";
const char *APP_GET_MEDIA_INFO = "/app/getmediainfo";
const char *APP_GET_SD_CARD_INFO = "/app/getsdinfo";
const char *APP_GET_BATTERY_INFO = "/app/getbatteryinfo";
const char *APP_GET_PARAM_VALUE = "/app/getparamvalue";
const char *APP_GET_CAPABILITY = "/app/capability";
const char *APP_GET_LOCK_VIDEO_STATUS = "/app/getlockvideostatus";
const char *APP_GET_STORAGE_INFO = "/app/getstorageinfo";
const char *APP_GET_FILE_LIST = "/app/getfilelist";
const char *APP_SET_DATE_TIME = "/app/setsystime";
const char *APP_SET_TIME_ZONE = "/app/settimezone";
const char *APP_SET_PARAM_VALUE = "/app/setparamvalue";
const char *APP_ENTER_RECORDER = "/app/enterrecorder";
const char *APP_PLAYBACK = "/app/playback";
const char *APP_UPLOAD_FILE = "/upload";
// clang-format on
constexpr bool SET_REQUEST_RESPONSE = true;
SixFrameHandle::SixFrameHandle()
{
@ -48,9 +52,13 @@ SixFrameHandle::SixFrameHandle()
mResquesHandleFunc[APP_GET_CAPABILITY] = std::bind(&SixFrameHandle::RequestGetCapability, this, _1, _2, _3);
mResquesHandleFunc[APP_GET_LOCK_VIDEO_STATUS] =
std::bind(&SixFrameHandle::RequestGetLockVideoStatus, this, _1, _2, _3);
mResquesHandleFunc[APP_GET_STORAGE_INFO] = std::bind(&SixFrameHandle::RequestGetStorageInfo, this, _1, _2, _3);
mResquesHandleFunc[APP_GET_FILE_LIST] = std::bind(&SixFrameHandle::RequestGetFileList, this, _1, _2, _3);
mResquesHandleFunc[APP_SET_DATE_TIME] = std::bind(&SixFrameHandle::RequestSetDateTime, this, _1, _2, _3);
mResquesHandleFunc[APP_SET_TIME_ZONE] = std::bind(&SixFrameHandle::RequestSetTimeZone, this, _1, _2, _3);
mResquesHandleFunc[APP_SET_PARAM_VALUE] = std::bind(&SixFrameHandle::RequestSetParamValue, this, _1, _2, _3);
mResquesHandleFunc[APP_ENTER_RECORDER] = std::bind(&SixFrameHandle::RequestEnterRecorder, this, _1, _2, _3);
mResquesHandleFunc[APP_PLAYBACK] = std::bind(&SixFrameHandle::RequestPlayback, this, _1, _2, _3);
mResquesHandleFunc[APP_UPLOAD_FILE] = std::bind(&SixFrameHandle::RequestUpload, this, _1, _2, _3);
// mResquesHandleFunc["favicon.ico"] = std::bind(&SixFrameHandle::DoNothing, this, _1, _2, _);
}
@ -190,6 +198,7 @@ void inline SixFrameHandle::ResponseGetMediaInfo(cJSON *result, const AppGetMeid
cJSON_AddStringToObject(info, "rtsp", param.mRtspUrl.c_str());
cJSON_AddStringToObject(info, "transport", param.mTransport.c_str());
cJSON_AddNumberToObject(info, "port", param.mPort);
cJSON_AddNumberToObject(info, "page", 1); // TODO: 1 means app will paging to retrieve files.
}
void SixFrameHandle::RequestGetSdCardInfo(const std::string &url, ResponseHandle responseHandle, void *context)
{
@ -253,10 +262,18 @@ void SixFrameHandle::RequestGetParamValue(const std::string &url, ResponseHandle
}
void inline SixFrameHandle::ResponseGetParamValue(cJSON *result, const AppGetParamValue &param)
{
cJSON *info = nullptr;
cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
cJSON_AddNumberToObject(info, "charge", static_cast<int>(param.mChargeStatus));
cJSON_AddNumberToObject(info, "capacity", param.mCapacity);
cJSON *info = cJSON_CreateArray();
if (nullptr == info) {
LogError("cJSON_CreateArray failed.\n");
return;
}
cJSON_AddItemToObject(result, CJSON_INFO_STRING, info);
cJSON *mic = cJSON_CreateObject();
if (nullptr != mic) {
cJSON_AddItemToArray(info, mic);
cJSON_AddStringToObject(mic, "name", "mic");
cJSON_AddNumberToObject(mic, "value", static_cast<int>(param.mMicStatus));
}
}
void SixFrameHandle::RequestGetCapability(const std::string &url, ResponseHandle responseHandle, void *context)
{
@ -277,8 +294,18 @@ void inline SixFrameHandle::ResponseGetCapability(cJSON *result, const AppGetCap
{
cJSON *info = nullptr;
cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
cJSON_AddNumberToObject(info, "charge", static_cast<int>(param.mChargeStatus));
cJSON_AddNumberToObject(info, "capacity", param.mCapacity);
std::ostringstream value;
value << static_cast<int>(param.mGpsCapability);
value << static_cast<int>(param.mDeviceType);
value << static_cast<int>(param.mAlbum);
value << static_cast<int>(param.mAppLock);
value << static_cast<int>(param.mDeleteLock);
value << static_cast<int>(param.mDeviceMode);
value << static_cast<int>(param.mPlaybackType);
value << static_cast<int>(param.mPhotographCapability);
value << static_cast<int>(param.mWifiCapability);
value << static_cast<int>(param.mFileCopy);
cJSON_AddStringToObject(info, "value", value.str().c_str());
}
void SixFrameHandle::RequestGetLockVideoStatus(const std::string &url, ResponseHandle responseHandle, void *context)
{
@ -337,6 +364,74 @@ void inline SixFrameHandle::ResponseGetStorageInfo(cJSON *result, const std::vec
}
}
}
AppGetFileInfo inline SixFrameHandle::RequestGetFileListParse(const std::string &url)
{
auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
std::shared_ptr<ParseUrl<AppGetFileInfo>> parseyImpl =
std::dynamic_pointer_cast<ParseUrl<AppGetFileInfo>>(parse);
if ("folder" == key) {
if ("loop" == value) {
parseyImpl->mData.mEvent = StorageFileEvent::END;
}
if ("emr" == value) {
parseyImpl->mData.mEvent = StorageFileEvent::END;
}
if ("event" == value) {
parseyImpl->mData.mEvent = StorageFileEvent::END;
}
if ("park" == value) {
parseyImpl->mData.mEvent = StorageFileEvent::END;
}
}
if ("start" == key) {
parseyImpl->mData.mStartIndex = std::stoi(value);
}
if ("end" == key) {
parseyImpl->mData.mStopIndex = std::stoi(value);
}
};
std::shared_ptr<VParseUrl> parse = std::make_shared<ParseUrl<AppGetFileInfo>>();
std::shared_ptr<ParseUrl<AppGetFileInfo>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<AppGetFileInfo>>(parse);
ExtractParamsFromUrl(url, parseFunc, parse);
return parseyImpl->mData;
}
void SixFrameHandle::RequestGetFileList(const std::string &url, ResponseHandle responseHandle, void *context)
{
LogInfo("RequestGetFileList.\n");
std::vector<AppGetFileList> param;
AppGetFileInfo info = RequestGetFileListParse(url);
mAppMonitor->GetStorageFileList(info, param);
cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
if (nullptr == result) {
LogError("MakeResponseResult failed.\n");
responseHandle("Device run out of memory.", context);
return;
}
ResponseGetFileList(result, param);
ResponseJsonString(result, responseHandle, context);
cJSON_Delete(result);
}
void inline SixFrameHandle::ResponseGetFileList(cJSON *result, const std::vector<AppGetFileList> &param)
{
cJSON *info = cJSON_CreateArray();
if (nullptr == info) {
LogError("cJSON_CreateArray failed.\n");
return;
}
cJSON_AddItemToObject(result, CJSON_INFO_STRING, info);
for (const auto &fileInfo : param) {
cJSON *file = nullptr;
file = cJSON_CreateObject();
if (nullptr != file) {
cJSON_AddItemToArray(info, file);
cJSON_AddStringToObject(file, "name", fileInfo.mName.c_str());
cJSON_AddNumberToObject(file, "duration", fileInfo.mDuration);
cJSON_AddNumberToObject(file, "size", fileInfo.mSize);
cJSON_AddNumberToObject(file, "createtime", fileInfo.mCreateTime_s);
cJSON_AddNumberToObject(file, "type", static_cast<int>(fileInfo.mType));
}
}
}
AppSetDateTime inline SixFrameHandle::RequestSetDateTimeParse(const std::string &url)
{
auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
@ -451,6 +546,39 @@ void SixFrameHandle::RequestSetParamValue(const std::string &url, ResponseHandle
ResponseJsonString(result, responseHandle, context);
cJSON_Delete(result);
}
PlayBackEvent inline SixFrameHandle::RequestPlaybackParse(const std::string &url)
{
auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
std::shared_ptr<ParseUrl<PlayBackEvent>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<PlayBackEvent>>(parse);
if ("param" == key) {
if ("enter" == value) {
parseyImpl->mData = PlayBackEvent::START;
}
if ("exit" == value) {
parseyImpl->mData = PlayBackEvent::STOP;
}
}
};
std::shared_ptr<VParseUrl> parse = std::make_shared<ParseUrl<PlayBackEvent>>();
std::shared_ptr<ParseUrl<PlayBackEvent>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<PlayBackEvent>>(parse);
parseyImpl->mData = PlayBackEvent::END;
ExtractParamsFromUrl(url, parseFunc, parse);
return parseyImpl->mData;
}
void SixFrameHandle::RequestPlayback(const std::string &url, ResponseHandle responseHandle, void *context)
{
LogInfo("RequestPlayback.\n");
PlayBackEvent value = RequestPlaybackParse(url);
mAppMonitor->AppPlayback(value);
cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL, SET_REQUEST_RESPONSE);
if (nullptr == result) {
LogError("MakeResponseResult failed.\n");
responseHandle("Device run out of memory.", context);
return;
}
ResponseJsonString(result, responseHandle, context);
cJSON_Delete(result);
}
void SixFrameHandle::RequestEnterRecorder(const std::string &url, ResponseHandle responseHandle, void *context)
{
LogInfo("RequestEnterRecorder.\n");

5
middleware/AppManager/src/Protocol/SixFrame/SixFrameHandle.h
View File

@ -76,12 +76,17 @@ private:
void ResponseGetLockVideoStatus(cJSON *result, const LockVideoStatus &param);
void RequestGetStorageInfo(const std::string &url, ResponseHandle responseHandle, void *context);
void ResponseGetStorageInfo(cJSON *result, const std::vector<AppGetStorageInfo> &param);
AppGetFileInfo RequestGetFileListParse(const std::string &url);
void RequestGetFileList(const std::string &url, ResponseHandle responseHandle, void *context);
void ResponseGetFileList(cJSON *result, const std::vector<AppGetFileList> &param);
AppSetDateTime RequestSetDateTimeParse(const std::string &url);
void RequestSetDateTime(const std::string &url, ResponseHandle responseHandle, void *context);
int RequestSetTimeZoneParse(const std::string &url);
void RequestSetTimeZone(const std::string &url, ResponseHandle responseHandle, void *context);
AppSetParamValue RequestSetParamValueParse(const std::string &url);
void RequestSetParamValue(const std::string &url, ResponseHandle responseHandle, void *context);
PlayBackEvent RequestPlaybackParse(const std::string &url);
void RequestPlayback(const std::string &url, ResponseHandle responseHandle, void *context);
void RequestEnterRecorder(const std::string &url, ResponseHandle responseHandle, void *context);
void RequestUpload(const std::string &url, ResponseHandle responseHandle, void *context);

2
test/application/MissionManager/tool/src/TestMissionStateMock.cpp
View File

@ -60,7 +60,7 @@ StatusCode TestMissionStateTest::GetBatteryInfo(AppGetBatteryInfo &param)
}
return code;
}
StatusCode TestMissionStateTest::SetDateTime(AppSetDateTime &param)
StatusCode TestMissionStateTest::SetDateTime(const AppSetDateTime &param)
{
LogInfo("TestMissionStateTest::SetDateTime\n");
LogInfo("mYear = %u\n", param.mYear);

2
test/application/MissionManager/tool/src/TestMissionStateMock.h
View File

@ -27,7 +27,7 @@ public:
StatusCode GetMediaInfo(AppGetMeidaInfo &param) override;
StatusCode GetSdCardInfo(AppGetSdCardInfo &param) override;
StatusCode GetBatteryInfo(AppGetBatteryInfo &param) override;
StatusCode SetDateTime(AppSetDateTime &param) override;
StatusCode SetDateTime(const AppSetDateTime &param) override;
StatusCode SetTimeZone(const unsigned int &zone) override;
StatusCode UploadFile(AppUploadFile &param) override;
// const StatusCode SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor) override;

2
test/middleware/AppManager/CMakeLists.txt
View File

@ -34,7 +34,7 @@ endif()
set(TARGET_NAME AppManagerTest)
add_executable(${TARGET_NAME} ${SRC_FILES_MAIN} ${SRC_FILES})
target_link_libraries(${TARGET_NAME} AppManagerTestTool gtest gmock pthread)
target_link_libraries(${TARGET_NAME} AppManagerTestTool HalTestTool gtest gmock pthread)
if(${TEST_COVERAGE} MATCHES "true")
target_link_libraries(${TARGET_NAME} gcov)
endif()

103
test/middleware/AppManager/src/AppManager_Test.cpp
View File

@ -13,6 +13,7 @@
* limitations under the License.
*/
#include "AppManagerTestTool.h"
#include "HalTestTool.h"
#include "IAppManager.h"
#include "ILog.h"
#include <gmock/gmock.h>
@ -20,7 +21,7 @@
#include <thread>
namespace AppManagerTest
{
class AppManagerTest : public testing::Test, public AppManagerTestTool
class AppManagerTest : public testing::Test, public AppManagerTestTool, public HalTestTool
{
public:
AppManagerTest() : mAppParam(APP_MANAGER_HTTP_SERVER_IP, APP_MANAGER_HTTP_SERVER_PORT) {}
@ -33,13 +34,17 @@ public:
static void TearDownTestCase() { ILogUnInit(); }
virtual void SetUp()
{
HalTestTool::Init();
AppManagerTestTool::Init();
CreateHalCppModule();
CreateAppManagerModule();
}
virtual void TearDown()
{
AppManagerTestTool::UnInit();
HalTestTool::UnInit();
DestroyAppManagerModule();
DestroyHalCppModule();
}
protected:
@ -145,4 +150,100 @@ TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_SetTimeZone)
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
IAppManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/AppManagerTest
// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetParamValue
TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetParamValue)
{
std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
IAppManager::GetInstance()->Init(mAppParam);
IAppManager::GetInstance()->SetAppMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
MockGetParamValue();
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
IAppManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/AppManagerTest
// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetCapability
TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetCapability)
{
std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
IAppManager::GetInstance()->Init(mAppParam);
IAppManager::GetInstance()->SetAppMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
MockGetCapability();
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
IAppManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/AppManagerTest
// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetLockVideoStatus
TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetLockVideoStatus)
{
std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
IAppManager::GetInstance()->Init(mAppParam);
IAppManager::GetInstance()->SetAppMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
MockGetLockVideoStatus();
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
IAppManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/AppManagerTest
// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetStorageInfo
TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetStorageInfo)
{
std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
IAppManager::GetInstance()->Init(mAppParam);
IAppManager::GetInstance()->SetAppMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
MockGetStorageInfo();
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
IAppManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/AppManagerTest
// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetStorageFileList
TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetStorageFileList)
{
std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
IAppManager::GetInstance()->Init(mAppParam);
IAppManager::GetInstance()->SetAppMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
MockGetStorageFileList();
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
IAppManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/AppManagerTest
// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_SetParamValue
TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_SetParamValue)
{
std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
IAppManager::GetInstance()->Init(mAppParam);
IAppManager::GetInstance()->SetAppMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
MockSetParamValue();
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
IAppManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/AppManagerTest
// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_EnterRecorder
TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_EnterRecorder)
{
std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
IAppManager::GetInstance()->Init(mAppParam);
IAppManager::GetInstance()->SetAppMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
MockEnterRecorder();
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
IAppManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/AppManagerTest
// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_AppPlayback
TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_AppPlayback)
{
std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
IAppManager::GetInstance()->Init(mAppParam);
IAppManager::GetInstance()->SetAppMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
MockAppPlayback();
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
IAppManager::GetInstance()->UnInit();
}
} // namespace AppManagerTest

8
test/middleware/AppManager/tool/include/AppManagerTestTool.h
View File

@ -34,6 +34,14 @@ protected:
void MockSetDateTime(void);
void MockSetTimeZone(void);
void MockUploadFiles(void);
void MockGetParamValue(void);
void MockGetCapability(void);
void MockGetLockVideoStatus(void);
void MockGetStorageInfo(void);
void MockGetStorageFileList(void);
void MockSetParamValue(void);
void MockEnterRecorder(void);
void MockAppPlayback(void);
private:
void AppManagerMockInit(std::shared_ptr<IAppManager> &vMock);

98
test/middleware/AppManager/tool/src/AppManagerTestTool.cpp
View File

@ -114,6 +114,86 @@ void AppManagerTestTool::MockUploadFiles(void)
}
ServersMock::GetInstance()->MockUploadFiles();
}
void AppManagerTestTool::MockGetParamValue(void)
{
std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
if (mock) {
EXPECT_CALL(*mock.get(), GetParamValueTrace(_))
.Times(ONLY_BE_CALLED_ONCE)
.WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
ServersMock::GetInstance()->MockGetParamValue();
}
void AppManagerTestTool::MockGetCapability(void)
{
std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
if (mock) {
EXPECT_CALL(*mock.get(), GetCapabilityTrace(_))
.Times(ONLY_BE_CALLED_ONCE)
.WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
ServersMock::GetInstance()->MockGetCapability();
}
void AppManagerTestTool::MockGetLockVideoStatus(void)
{
std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
if (mock) {
EXPECT_CALL(*mock.get(), GetLockVideoStatusTrace(_))
.Times(ONLY_BE_CALLED_ONCE)
.WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
ServersMock::GetInstance()->MockGetLockVideoStatus();
}
void AppManagerTestTool::MockGetStorageInfo(void)
{
std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
if (mock) {
EXPECT_CALL(*mock.get(), GetStorageInfoTrace(_))
.Times(ONLY_BE_CALLED_ONCE)
.WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
ServersMock::GetInstance()->MockGetStorageInfo();
}
void AppManagerTestTool::MockGetStorageFileList(void)
{
std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
if (mock) {
EXPECT_CALL(*mock.get(), GetStorageFileListTrace(_, _))
.Times(ONLY_BE_CALLED_ONCE)
.WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
ServersMock::GetInstance()->MockGetStorageFileList();
}
void AppManagerTestTool::MockSetParamValue(void)
{
std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
if (mock) {
EXPECT_CALL(*mock.get(), SetParamValueTrace(_))
.Times(ONLY_BE_CALLED_ONCE)
.WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
ServersMock::GetInstance()->MockSetParamValue();
}
void AppManagerTestTool::MockEnterRecorder(void)
{
std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
if (mock) {
EXPECT_CALL(*mock.get(), EnterRecorderTrace())
.Times(ONLY_BE_CALLED_ONCE)
.WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
ServersMock::GetInstance()->MockEnterRecorder();
}
void AppManagerTestTool::MockAppPlayback(void)
{
std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
if (mock) {
EXPECT_CALL(*mock.get(), AppPlaybackTrace(_))
.Times(ONLY_BE_CALLED_ONCE)
.WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
ServersMock::GetInstance()->MockAppPlayback();
}
void AppManagerTestTool::AppManagerMockInit(std::shared_ptr<IAppManager> &vMock)
{
std::shared_ptr<AppManagerMock> mock = std::dynamic_pointer_cast<AppManagerMock>(vMock);
@ -155,10 +235,28 @@ void AppManagerTestTool::AppMonitorInit(std::shared_ptr<VAppMonitor> &vMock)
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), GetSdCardInfoTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), GetParamValueTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), GetCapabilityTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), GetLockVideoStatusTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), GetStorageInfoTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), GetStorageFileListTrace(_, _))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), GetBatteryInfoTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), SetDateTimeTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), SetTimeZoneTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), SetParamValueTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), EnterRecorderTrace())
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), AppPlaybackTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), UploadFileTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}

116
test/middleware/AppManager/tool/src/AppMonitorMock.cpp
View File

@ -84,7 +84,77 @@ StatusCode AppMonitorTrace::GetBatteryInfoTrace(AppGetBatteryInfo &param)
LogInfo("AppMonitorTrace::GetBatteryInfoTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode AppMonitorTest::SetDateTime(AppSetDateTime &param)
StatusCode AppMonitorTest::GetParamValue(AppGetParamValue &param)
{
LogInfo("AppMonitorTest::GetParamValue\n");
StatusCode code = GetParamValueTrace(param);
if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
return VAppMonitor::GetParamValue(param);
}
return code;
}
StatusCode AppMonitorTrace::GetParamValueTrace(AppGetParamValue &param)
{
LogInfo("AppMonitorTrace::GetParamValueTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode AppMonitorTest::GetCapability(AppGetCapability &param)
{
LogInfo("AppMonitorTest::GetCapability\n");
StatusCode code = GetCapabilityTrace(param);
if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
return VAppMonitor::GetCapability(param);
}
return code;
}
StatusCode AppMonitorTrace::GetCapabilityTrace(AppGetCapability &param)
{
LogInfo("AppMonitorTrace::GetCapabilityTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode AppMonitorTest::GetLockVideoStatus(LockVideoStatus &param)
{
LogInfo("AppMonitorTest::GetLockVideoStatus\n");
StatusCode code = GetLockVideoStatusTrace(param);
if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
return VAppMonitor::GetLockVideoStatus(param);
}
return code;
}
StatusCode AppMonitorTrace::GetLockVideoStatusTrace(LockVideoStatus &param)
{
LogInfo("AppMonitorTrace::GetLockVideoStatusTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode AppMonitorTest::GetStorageInfo(std::vector<AppGetStorageInfo> &param)
{
LogInfo("AppMonitorTest::GetStorageInfo\n");
StatusCode code = GetStorageInfoTrace(param);
if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
return VAppMonitor::GetStorageInfo(param);
}
return code;
}
StatusCode AppMonitorTrace::GetStorageInfoTrace(std::vector<AppGetStorageInfo> &param)
{
LogInfo("AppMonitorTrace::GetStorageInfoTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode AppMonitorTest::GetStorageFileList(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param)
{
LogInfo("AppMonitorTest::GetStorageFileList\n");
StatusCode code = GetStorageFileListTrace(fileInfo, param);
if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
return VAppMonitor::GetStorageFileList(fileInfo, param);
}
return code;
}
StatusCode AppMonitorTrace::GetStorageFileListTrace(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param)
{
LogInfo("AppMonitorTrace::GetStorageFileListTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode AppMonitorTest::SetDateTime(const AppSetDateTime &param)
{
LogInfo("AppMonitorTest::SetDateTime\n");
LogInfo("mYear = %u\n", param.mYear);
@ -99,7 +169,7 @@ StatusCode AppMonitorTest::SetDateTime(AppSetDateTime &param)
}
return code;
}
StatusCode AppMonitorTrace::SetDateTimeTrace(AppSetDateTime &param)
StatusCode AppMonitorTrace::SetDateTimeTrace(const AppSetDateTime &param)
{
LogInfo("AppMonitorTrace::SetDateTimeTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
@ -118,6 +188,48 @@ StatusCode AppMonitorTrace::SetTimeZoneTrace(const unsigned int &zone)
LogInfo("AppMonitorTrace::SetTimeZoneTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode AppMonitorTest::SetParamValue(const AppSetParamValue &param)
{
LogInfo("AppMonitorTest::SetParamValue\n");
StatusCode code = SetParamValueTrace(param);
if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
return VAppMonitor::SetParamValue(param);
}
return code;
}
StatusCode AppMonitorTrace::SetParamValueTrace(const AppSetParamValue &param)
{
LogInfo("AppMonitorTrace::SetParamValueTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode AppMonitorTest::EnterRecorder(void)
{
LogInfo("AppMonitorTest::EnterRecorder\n");
StatusCode code = EnterRecorderTrace();
if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
return VAppMonitor::EnterRecorder();
}
return code;
}
StatusCode AppMonitorTrace::EnterRecorderTrace(void)
{
LogInfo("AppMonitorTrace::EnterRecorderTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode AppMonitorTest::AppPlayback(const PlayBackEvent &event)
{
LogInfo("AppMonitorTest::AppPlayback\n");
StatusCode code = AppPlaybackTrace(event);
if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
return VAppMonitor::AppPlayback(event);
}
return code;
}
StatusCode AppMonitorTrace::AppPlaybackTrace(const PlayBackEvent &event)
{
LogInfo("AppMonitorTrace::AppPlaybackTrace\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode AppMonitorTest::UploadFile(AppUploadFile &param)
{
LogInfo("AppMonitorTest::UploadFile\n");

30
test/middleware/AppManager/tool/src/AppMonitorMock.h
View File

@ -28,8 +28,16 @@ protected:
virtual StatusCode GetMediaInfoTrace(AppGetMeidaInfo &param);
virtual StatusCode GetSdCardInfoTrace(AppGetSdCardInfo &param);
virtual StatusCode GetBatteryInfoTrace(AppGetBatteryInfo &param);
virtual StatusCode SetDateTimeTrace(AppSetDateTime &param);
virtual StatusCode GetParamValueTrace(AppGetParamValue &param);
virtual StatusCode GetCapabilityTrace(AppGetCapability &param);
virtual StatusCode GetLockVideoStatusTrace(LockVideoStatus &param);
virtual StatusCode GetStorageInfoTrace(std::vector<AppGetStorageInfo> &param);
virtual StatusCode GetStorageFileListTrace(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param);
virtual StatusCode SetDateTimeTrace(const AppSetDateTime &param);
virtual StatusCode SetTimeZoneTrace(const unsigned int &zone);
virtual StatusCode SetParamValueTrace(const AppSetParamValue &param);
virtual StatusCode EnterRecorderTrace(void);
virtual StatusCode AppPlaybackTrace(const PlayBackEvent &event);
virtual StatusCode UploadFileTrace(AppUploadFile &param);
};
class AppMonitorTest : public VAppMonitor, virtual public AppMonitorTrace
@ -42,8 +50,16 @@ public:
StatusCode GetMediaInfo(AppGetMeidaInfo &param) override;
StatusCode GetSdCardInfo(AppGetSdCardInfo &param) override;
StatusCode GetBatteryInfo(AppGetBatteryInfo &param) override;
StatusCode SetDateTime(AppSetDateTime &param) override;
StatusCode GetParamValue(AppGetParamValue &param) override;
StatusCode GetCapability(AppGetCapability &param) override;
StatusCode GetLockVideoStatus(LockVideoStatus &param) override;
StatusCode GetStorageInfo(std::vector<AppGetStorageInfo> &param) override;
StatusCode GetStorageFileList(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param) override;
StatusCode SetDateTime(const AppSetDateTime &param) override;
StatusCode SetTimeZone(const unsigned int &zone) override;
StatusCode SetParamValue(const AppSetParamValue &param) override;
StatusCode EnterRecorder(void) override;
StatusCode AppPlayback(const PlayBackEvent &event) override;
StatusCode UploadFile(AppUploadFile &param) override;
};
class AppMonitorMock : virtual public AppMonitorTrace
@ -56,8 +72,16 @@ public:
MOCK_METHOD1(GetMediaInfoTrace, StatusCode(AppGetMeidaInfo &));
MOCK_METHOD1(GetSdCardInfoTrace, StatusCode(AppGetSdCardInfo &));
MOCK_METHOD1(GetBatteryInfoTrace, StatusCode(AppGetBatteryInfo &));
MOCK_METHOD1(SetDateTimeTrace, StatusCode(AppSetDateTime &));
MOCK_METHOD1(GetParamValueTrace, StatusCode(AppGetParamValue &));
MOCK_METHOD1(GetCapabilityTrace, StatusCode(AppGetCapability &));
MOCK_METHOD1(GetLockVideoStatusTrace, StatusCode(LockVideoStatus &));
MOCK_METHOD1(GetStorageInfoTrace, StatusCode(std::vector<AppGetStorageInfo> &));
MOCK_METHOD2(GetStorageFileListTrace, StatusCode(const AppGetFileInfo &, std::vector<AppGetFileList> &));
MOCK_METHOD1(SetDateTimeTrace, StatusCode(const AppSetDateTime &));
MOCK_METHOD1(SetTimeZoneTrace, StatusCode(const unsigned int &));
MOCK_METHOD1(SetParamValueTrace, StatusCode(const AppSetParamValue &));
MOCK_METHOD0(EnterRecorderTrace, StatusCode(void));
MOCK_METHOD1(AppPlaybackTrace, StatusCode(const PlayBackEvent &));
MOCK_METHOD1(UploadFileTrace, StatusCode(AppUploadFile &));
};
#endif

146
test/middleware/AppManager/tool/src/ServersMock.cpp
View File

@ -21,8 +21,16 @@ extern const char *APP_GET_DEVICE_ATTR;
extern const char *APP_GET_MEDIA_INFO;
extern const char *APP_GET_SD_CARD_INFO;
extern const char *APP_GET_BATTERY_INFO;
extern const char *APP_GET_PARAM_VALUE;
extern const char *APP_GET_CAPABILITY;
extern const char *APP_GET_LOCK_VIDEO_STATUS;
extern const char *APP_GET_STORAGE_INFO;
extern const char *APP_GET_FILE_LIST;
extern const char *APP_SET_DATE_TIME;
extern const char *APP_SET_TIME_ZONE;
extern const char *APP_SET_PARAM_VALUE;
extern const char *APP_ENTER_RECORDER;
extern const char *APP_PLAYBACK;
extern const char *APP_UPLOAD_FILE;
std::shared_ptr<ServersMock> &ServersMock::GetInstance(std::shared_ptr<ServersMock> *impl)
{
@ -140,9 +148,94 @@ void ServersMock::MockGetBatteryInfo(void)
DeleteServersHttp(http);
}
}
void ServersMock::MockGetParamValue(void)
{
LogInfo("APP_GET_PARAM_VALUE test start.\n");
std::string mockRequest = mServerUrl + APP_GET_PARAM_VALUE;
ServerHttp *http = NewServersHttp(mockRequest.c_str());
if (http) {
HttpGet(http);
if (http->reply) {
char *replyStr = (char *)malloc(http->replyLength + 1);
memset(replyStr, 0, http->replyLength + 1);
memcpy(replyStr, http->reply, http->replyLength);
LogInfo("HttpGet response :\n%s\n", replyStr);
free(replyStr);
}
DeleteServersHttp(http);
}
}
void ServersMock::MockGetCapability(void)
{
LogInfo("APP_GET_CAPABILITY test start.\n");
std::string mockRequest = mServerUrl + APP_GET_CAPABILITY;
ServerHttp *http = NewServersHttp(mockRequest.c_str());
if (http) {
HttpGet(http);
if (http->reply) {
char *replyStr = (char *)malloc(http->replyLength + 1);
memset(replyStr, 0, http->replyLength + 1);
memcpy(replyStr, http->reply, http->replyLength);
LogInfo("HttpGet response :\n%s\n", replyStr);
free(replyStr);
}
DeleteServersHttp(http);
}
}
void ServersMock::MockGetLockVideoStatus(void)
{
LogInfo("APP_GET_LOCK_VIDEO_STATUS test start.\n");
std::string mockRequest = mServerUrl + APP_GET_LOCK_VIDEO_STATUS;
ServerHttp *http = NewServersHttp(mockRequest.c_str());
if (http) {
HttpGet(http);
if (http->reply) {
char *replyStr = (char *)malloc(http->replyLength + 1);
memset(replyStr, 0, http->replyLength + 1);
memcpy(replyStr, http->reply, http->replyLength);
LogInfo("HttpGet response :\n%s\n", replyStr);
free(replyStr);
}
DeleteServersHttp(http);
}
}
void ServersMock::MockGetStorageInfo(void)
{
LogInfo("APP_GET_STORAGE_INFO test start.\n");
std::string mockRequest = mServerUrl + APP_GET_STORAGE_INFO;
ServerHttp *http = NewServersHttp(mockRequest.c_str());
if (http) {
HttpGet(http);
if (http->reply) {
char *replyStr = (char *)malloc(http->replyLength + 1);
memset(replyStr, 0, http->replyLength + 1);
memcpy(replyStr, http->reply, http->replyLength);
LogInfo("HttpGet response :\n%s\n", replyStr);
free(replyStr);
}
DeleteServersHttp(http);
}
}
void ServersMock::MockGetStorageFileList(void)
{
LogInfo("APP_GET_FILE_LIST test start.\n");
std::string mockRequest = mServerUrl + APP_GET_FILE_LIST;
ServerHttp *http = NewServersHttp(mockRequest.c_str());
if (http) {
HttpGet(http);
if (http->reply) {
char *replyStr = (char *)malloc(http->replyLength + 1);
memset(replyStr, 0, http->replyLength + 1);
memcpy(replyStr, http->reply, http->replyLength);
LogInfo("HttpGet response :\n%s\n", replyStr);
free(replyStr);
}
DeleteServersHttp(http);
}
}
void ServersMock::MockSetDateTime(void)
{
LogInfo("APP_GET_BATTERY_INFO test start.\n");
LogInfo("APP_SET_DATE_TIME test start.\n");
std::string mockRequest = mServerUrl + APP_SET_DATE_TIME + "?date=20240101010101";
ServerHttp *http = NewServersHttp(mockRequest.c_str());
if (http) {
@ -174,6 +267,57 @@ void ServersMock::MockSetTimeZone(void)
DeleteServersHttp(http);
}
}
void ServersMock::MockSetParamValue(void)
{
LogInfo("APP_SET_PARAM_VALUE test start.\n");
std::string mockRequest = mServerUrl + APP_SET_PARAM_VALUE + "?timezone=8";
ServerHttp *http = NewServersHttp(mockRequest.c_str());
if (http) {
HttpGet(http);
if (http->reply) {
char *replyStr = (char *)malloc(http->replyLength + 1);
memset(replyStr, 0, http->replyLength + 1);
memcpy(replyStr, http->reply, http->replyLength);
LogInfo("HttpGet response :\n%s\n", replyStr);
free(replyStr);
}
DeleteServersHttp(http);
}
}
void ServersMock::MockEnterRecorder(void)
{
LogInfo("APP_ENTER_RECORDER test start.\n");
std::string mockRequest = mServerUrl + APP_ENTER_RECORDER + "?timezone=8";
ServerHttp *http = NewServersHttp(mockRequest.c_str());
if (http) {
HttpGet(http);
if (http->reply) {
char *replyStr = (char *)malloc(http->replyLength + 1);
memset(replyStr, 0, http->replyLength + 1);
memcpy(replyStr, http->reply, http->replyLength);
LogInfo("HttpGet response :\n%s\n", replyStr);
free(replyStr);
}
DeleteServersHttp(http);
}
}
void ServersMock::MockAppPlayback(void)
{
LogInfo("APP_PLAYBACK test start.\n");
std::string mockRequest = mServerUrl + APP_PLAYBACK + "?timezone=8";
ServerHttp *http = NewServersHttp(mockRequest.c_str());
if (http) {
HttpGet(http);
if (http->reply) {
char *replyStr = (char *)malloc(http->replyLength + 1);
memset(replyStr, 0, http->replyLength + 1);
memcpy(replyStr, http->reply, http->replyLength);
LogInfo("HttpGet response :\n%s\n", replyStr);
free(replyStr);
}
DeleteServersHttp(http);
}
}
#ifndef PLATFORM_PATH
#error Add the code in your linux.toolchain.cmake : add_definitions(-DPLATFORM_PATH="${PLATFORM_PATH}")
#endif

8
test/middleware/AppManager/tool/src/ServersMock.h
View File

@ -28,8 +28,16 @@ public:
virtual void MockGetMediaInfo(void);
virtual void MockGetSdCardInfo(void);
virtual void MockGetBatteryInfo(void);
virtual void MockGetParamValue(void);
virtual void MockGetCapability(void);
virtual void MockGetLockVideoStatus(void);
virtual void MockGetStorageInfo(void);
virtual void MockGetStorageFileList(void);
virtual void MockSetDateTime(void);
virtual void MockSetTimeZone(void);
virtual void MockSetParamValue(void);
virtual void MockEnterRecorder(void);
virtual void MockAppPlayback(void);
virtual void MockUploadFiles(void);
private: