From 3cbba601b3a4c9213995b6b87af6c7c9613c075a Mon Sep 17 00:00:00 2001 From: niuhui Date: Wed, 14 Dec 2022 14:14:17 +0800 Subject: [PATCH] fix: add base ut Signed-off-by: niuhui --- .../cameraservice/base/test/unittest/BUILD.gn | 2 +- .../common/{dcameraprotocol => base}/BUILD.gn | 20 +- .../base/dcamera_capture_info_cmd_test.cpp | 440 ++++++++++++++++++ .../base/dcamera_channel_info_cmd_test.cpp | 221 +++++++++ .../common/base/dcamera_event_cmd_test.cpp | 198 ++++++++ .../common/base/dcamera_info_cmd_test.cpp | 151 ++++++ .../dcamera_metadata_setting_cmd_test.cpp | 191 ++++++++ .../base/dcamera_open_info_cmd_test.cpp | 165 +++++++ .../dcamera_protocol_test.cpp | 0 9 files changed, 1381 insertions(+), 7 deletions(-) mode change 100644 => 100755 services/cameraservice/base/test/unittest/BUILD.gn rename services/cameraservice/base/test/unittest/common/{dcameraprotocol => base}/BUILD.gn (79%) mode change 100644 => 100755 create mode 100755 services/cameraservice/base/test/unittest/common/base/dcamera_capture_info_cmd_test.cpp create mode 100755 services/cameraservice/base/test/unittest/common/base/dcamera_channel_info_cmd_test.cpp create mode 100755 services/cameraservice/base/test/unittest/common/base/dcamera_event_cmd_test.cpp create mode 100755 services/cameraservice/base/test/unittest/common/base/dcamera_info_cmd_test.cpp create mode 100755 services/cameraservice/base/test/unittest/common/base/dcamera_metadata_setting_cmd_test.cpp create mode 100755 services/cameraservice/base/test/unittest/common/base/dcamera_open_info_cmd_test.cpp rename services/cameraservice/base/test/unittest/common/{dcameraprotocol => base}/dcamera_protocol_test.cpp (100%) mode change 100644 => 100755 diff --git a/services/cameraservice/base/test/unittest/BUILD.gn b/services/cameraservice/base/test/unittest/BUILD.gn old mode 100644 new mode 100755 index 9015584d..7a2dd4fa --- a/services/cameraservice/base/test/unittest/BUILD.gn +++ b/services/cameraservice/base/test/unittest/BUILD.gn @@ -13,5 +13,5 @@ group("services_base_test") { testonly = true - deps = [ "common/dcameraprotocol:dcamera_protocol_test" ] + deps = [ "common/base:dcamera_services_base_test" ] } diff --git a/services/cameraservice/base/test/unittest/common/dcameraprotocol/BUILD.gn b/services/cameraservice/base/test/unittest/common/base/BUILD.gn old mode 100644 new mode 100755 similarity index 79% rename from services/cameraservice/base/test/unittest/common/dcameraprotocol/BUILD.gn rename to services/cameraservice/base/test/unittest/common/base/BUILD.gn index 6c5de5fc..2e0ed150 --- a/services/cameraservice/base/test/unittest/common/dcameraprotocol/BUILD.gn +++ b/services/cameraservice/base/test/unittest/common/base/BUILD.gn @@ -15,7 +15,7 @@ import("//build/test.gni") import( "//foundation/distributedhardware/distributed_camera/distributedcamera.gni") -module_out_path = "distributed_camera/dcamera_protocol_test" +module_out_path = "distributed_camera/dcamera_services_base_test" config("module_private_config") { visibility = [ ":*" ] @@ -39,10 +39,18 @@ config("module_private_config") { ] } -ohos_unittest("DCameraProtocolTest") { +ohos_unittest("DCameraServicesBaseTest") { module_out_path = module_out_path - sources = [ "dcamera_protocol_test.cpp" ] + sources = [ + "dcamera_protocol_test.cpp", + "dcamera_capture_info_cmd_test.cpp", + "dcamera_channel_info_cmd_test.cpp", + "dcamera_event_cmd_test.cpp", + "dcamera_info_cmd_test.cpp", + "dcamera_metadata_setting_cmd_test.cpp", + "dcamera_open_info_cmd_test.cpp", + ] configs = [ ":module_private_config" ] @@ -64,12 +72,12 @@ ohos_unittest("DCameraProtocolTest") { defines = [ "HI_LOG_ENABLE", - "DH_LOG_TAG=\"DCameraProtocolTest\"", + "DH_LOG_TAG=\"DCameraServicesBaseTest\"", "LOG_DOMAIN=0xD004100", ] } -group("dcamera_protocol_test") { +group("dcamera_services_base_test") { testonly = true - deps = [ ":DCameraProtocolTest" ] + deps = [ ":DCameraServicesBaseTest" ] } diff --git a/services/cameraservice/base/test/unittest/common/base/dcamera_capture_info_cmd_test.cpp b/services/cameraservice/base/test/unittest/common/base/dcamera_capture_info_cmd_test.cpp new file mode 100755 index 00000000..be398410 --- /dev/null +++ b/services/cameraservice/base/test/unittest/common/base/dcamera_capture_info_cmd_test.cpp @@ -0,0 +1,440 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 +#include + +#include "dcamera_capture_info_cmd.h" +#include "distributed_camera_errno.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraCaptureInfoCmdlTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_TYPE = R"({ + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_TYPE_EXCEPTION = R"({ + "Type": 0, + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_DHID = R"({ + "Type": "OPERATION", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_DHID_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": 0, + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_COMMAND = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_COMMAND_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": 0, + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_VALUE_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": "[ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ]" +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_WIDTH = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_WIDTH_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": "1920", "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_HEIGHT = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_HEIGHT_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": "1080", "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_FORMAT = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_FORMAT_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": "1", "DataSpace": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_DATASPACE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_DATASPACE_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": "1", + "IsCapture": true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_ISCAPTURE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_ISCAPTURE_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": "true", "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_ENCODETYPE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_ENCODETYPE_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture": true, "EncodeType": "1", "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_CAPTURESETTINGS = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture":true, "EncodeType": 1, "StreamType": 1} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_CAPTURESETTINGS_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture":true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": "[{"SettingType": 1, "SettingValue": "TestSetting"}]"} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_CAPTURESETTINGS_BODY_TYPE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture":true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_CAPTURESETTINGS_BODY_TYPE_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture":true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": "1", "SettingValue": "TestSetting"}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_LACK_CAPTURESETTINGS_BODY_VALUE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture":true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1}]} + ] +})"; + +static const std::string TEST_CAPTURE_INFO_CMD_JSON_CAPTURESETTINGS_BODY_VALUE_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CAPTURE", + "Value": [ + {"Width": 1920, "Height": 1080, "Format": 1, "DataSpace": 1, + "IsCapture":true, "EncodeType": 1, "StreamType": 1, + "CaptureSettings": [{"SettingType": 1, "SettingValue": 0}]} + ] +})"; + + +void DCameraCaptureInfoCmdlTest::SetUpTestCase(void) +{ +} + +void DCameraCaptureInfoCmdlTest::TearDownTestCase(void) +{ +} + +void DCameraCaptureInfoCmdlTest::SetUp(void) +{ +} + +void DCameraCaptureInfoCmdlTest::TearDown(void) +{ +} + +/** + * @tc.name: Unmarshal_001. + * @tc.desc: Verify CaptureInfoCmd Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraCaptureInfoCmdlTest, Unmarshal_001, TestSize.Level1) +{ + DCameraCaptureInfoCmd cmd; + std::string str = "0"; + int32_t ret = cmd.Unmarshal(str); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_TYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_TYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_DHID); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_DHID_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_COMMAND); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_COMMAND_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_VALUE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: Unmarshal_002. + * @tc.desc: Verify CaptureInfoCmd Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraCaptureInfoCmdlTest, Unmarshal_002, TestSize.Level1) +{ + DCameraCaptureInfoCmd cmd; + int32_t ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_WIDTH); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_WIDTH_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_HEIGHT); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_HEIGHT_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_FORMAT); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_FORMAT_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_DATASPACE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_DATASPACE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_ISCAPTURE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_ISCAPTURE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_ENCODETYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_ENCODETYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_VALUE_BODY_CAPTURESETTINGS); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_VALUE_BODY_CAPTURESETTINGS_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: Unmarshal_003. + * @tc.desc: Verify CaptureInfoCmd Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraCaptureInfoCmdlTest, Unmarshal_003, TestSize.Level1) +{ + DCameraCaptureInfoCmd cmd; + int32_t ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_CAPTURESETTINGS_BODY_TYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_CAPTURESETTINGS_BODY_TYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_LACK_CAPTURESETTINGS_BODY_VALUE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_CAPTURESETTINGS_BODY_VALUE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/cameraservice/base/test/unittest/common/base/dcamera_channel_info_cmd_test.cpp b/services/cameraservice/base/test/unittest/common/base/dcamera_channel_info_cmd_test.cpp new file mode 100755 index 00000000..af6ffc46 --- /dev/null +++ b/services/cameraservice/base/test/unittest/common/base/dcamera_channel_info_cmd_test.cpp @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 +#include + +#include "dcamera_channel_info_cmd.h" +#include "distributed_camera_errno.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraChannelInfoCmdlTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_LACK_TYPE = R"({ + "dhId": "camrea_0", + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": "TestDevId", "Detail": [{"DataSessionFlag": "TestFlag", "StreamType": 1}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_TYPE_EXCEPTION = R"({ + "Type": 0, + "dhId": "camrea_0", + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": "TestDevId", "Detail": [{"DataSessionFlag": "TestFlag", "StreamType": 1}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_LACK_DHID = R"({ + "Type": "OPERATION", + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": "TestDevId", "Detail": [{"DataSessionFlag": "TestFlag", "StreamType": 1}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_DHID_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": 0, + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": "TestDevId", "Detail": [{"DataSessionFlag": "TestFlag", "StreamType": 1}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_LACK_COMMAND = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Value": {"SourceDevId": "TestDevId", "Detail": [{"DataSessionFlag": "TestFlag", "StreamType": 1}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_COMMAND_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": 0, + "Value": {"SourceDevId": "TestDevId", "Detail": [{"DataSessionFlag": "TestFlag", "StreamType": 1}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_LACK_VALUE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CHANNEL_NEG" +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_LACK_VALUE_BODY_DEVID = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CHANNEL_NEG", + "Value": {Detail": [{"DataSessionFlag": "TestFlag", "StreamType": 1}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_VALUE_BODY_DEVID_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": 0, "Detail": [{"DataSessionFlag": "TestFlag", "StreamType": 1}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_LACK_VALUE_BODY_DETAIL = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": "TestDevId"} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_VALUE_BODY_DETAIL_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": "TestDevId", "Detail": "[{"DataSessionFlag": "TestFlag", "StreamType": 1}]"} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_LACK_DETAIL_BODY_FLAG = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": "TestDevId", "Detail": [{"StreamType": 1}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_DETAIL_BODY_FLAG_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": "TestDevId", "Detail": [{"DataSessionFlag": 0, "StreamType": 1}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_LACK_DETAIL_BODY_TYPE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": "TestDevId", "Detail": [{"DataSessionFlag": "TestFlag"}]} +})"; + +static const std::string TEST_CHANNEL_INFO_CMD_JSON_DETAIL_BODY_TYPE_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "CHANNEL_NEG", + "Value": {"SourceDevId": "TestDevId", "Detail": [{"DataSessionFlag": "TestFlag", "StreamType": "1"}]} +})"; + + +void DCameraChannelInfoCmdlTest::SetUpTestCase(void) +{ +} + +void DCameraChannelInfoCmdlTest::TearDownTestCase(void) +{ +} + +void DCameraChannelInfoCmdlTest::SetUp(void) +{ +} + +void DCameraChannelInfoCmdlTest::TearDown(void) +{ +} + +/** + * @tc.name: Unmarshal_001. + * @tc.desc: Verify ChannelInfoCmd Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraChannelInfoCmdlTest, Unmarshal_001, TestSize.Level1) +{ + DCameraChannelInfoCmd cmd; + std::string str = "0"; + int32_t ret = cmd.Unmarshal(str); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_LACK_TYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_TYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_LACK_DHID); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_DHID_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_LACK_COMMAND); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_COMMAND_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_LACK_VALUE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: Unmarshal_002. + * @tc.desc: Verify ChannelInfoCmd Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraChannelInfoCmdlTest, Unmarshal_002, TestSize.Level1) +{ + DCameraChannelInfoCmd cmd; + int32_t ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_LACK_VALUE_BODY_DEVID); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_VALUE_BODY_DEVID_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_LACK_VALUE_BODY_DETAIL); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_VALUE_BODY_DETAIL_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_LACK_DETAIL_BODY_FLAG); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_DETAIL_BODY_FLAG_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_LACK_DETAIL_BODY_TYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_JSON_DETAIL_BODY_TYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/base/test/unittest/common/base/dcamera_event_cmd_test.cpp b/services/cameraservice/base/test/unittest/common/base/dcamera_event_cmd_test.cpp new file mode 100755 index 00000000..2f118779 --- /dev/null +++ b/services/cameraservice/base/test/unittest/common/base/dcamera_event_cmd_test.cpp @@ -0,0 +1,198 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 +#include + +#include "dcamera_event_cmd.h" +#include "distributed_camera_errno.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraEventCmdlTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +static const std::string TEST_EVENT_CMD_JSON_LACK_TYPE = R"({ + "dhId": "camrea_0", + "Command": "STATE_NOTIFY", + "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"} +})"; + +static const std::string TEST_EVENT_CMD_JSON_TYPE_EXCEPTION = R"({ + "Type": 0, + "dhId": "camrea_0", + "Command": "STATE_NOTIFY", + "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"} +})"; + +static const std::string TEST_EVENT_CMD_JSON_LACK_DHID = R"({ + "Type": "MESSAGE", + "Command": "STATE_NOTIFY", + "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"} +})"; + +static const std::string TEST_EVENT_CMD_JSON_DHID_EXCEPTION = R"({ + "Type": "MESSAGE", + "dhId": 0, + "Command": "STATE_NOTIFY", + "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"} +})"; + +static const std::string TEST_EVENT_CMD_JSON_LACK_COMMAND = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"} +})"; + +static const std::string TEST_EVENT_CMD_JSON_COMMAND_EXCEPTION = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": 0, + "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"} +})"; + +static const std::string TEST_EVENT_CMD_JSON_LACK_VALUE = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "STATE_NOTIFY" +})"; + +static const std::string TEST_EVENT_CMD_JSON_LACK_VALUE_BODY_TYPE = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "STATE_NOTIFY", + "Value": {"EventResult": 1, "EventContent": "TestContent"} +})"; + +static const std::string TEST_EVENT_CMD_JSON_VALUE_BODY_TYPE_EXCEPTION = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "STATE_NOTIFY", + "Value": {"EventType": "1", "EventResult": 1, "EventContent": "TestContent"} +})"; + +static const std::string TEST_EVENT_CMD_JSON_LACK_VALUE_BODY_RESULT = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "STATE_NOTIFY", + "Value": {"EventType": 1, "EventContent": "TestContent"} +})"; + +static const std::string TEST_EVENT_CMD_JSON_VALUE_BODY_RESULT_EXCEPTION = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "STATE_NOTIFY", + "Value": {"EventType": 1, "EventResult": "1", "EventContent": "TestContent"} +})"; + +static const std::string TEST_EVENT_CMD_JSON_LACK_VALUE_BODY_CONTENT = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "STATE_NOTIFY", + "Value": {"EventType": 1, "EventResult": 1} +})"; + +static const std::string TEST_EVENT_CMD_JSON_VALUE_BODY_CONTENT_EXCEPTION = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "STATE_NOTIFY", + "Value": {"EventType": 1, "EventResult": 1, "EventContent": 0} +})"; + + +void DCameraEventCmdlTest::SetUpTestCase(void) +{ +} + +void DCameraEventCmdlTest::TearDownTestCase(void) +{ +} + +void DCameraEventCmdlTest::SetUp(void) +{ +} + +void DCameraEventCmdlTest::TearDown(void) +{ +} + +/** + * @tc.name: Unmarshal_001. + * @tc.desc: Verify EventCmdlTest Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraEventCmdlTest, Unmarshal_001, TestSize.Level1) +{ + DCameraEventCmd cmd; + std::string str = "0"; + int32_t ret = cmd.Unmarshal(str); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_LACK_TYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_TYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_LACK_DHID); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_DHID_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_LACK_COMMAND); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_COMMAND_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_LACK_VALUE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: Unmarshal_002. + * @tc.desc: Verify EventCmdlTest Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraEventCmdlTest, Unmarshal_002, TestSize.Level1) +{ + DCameraEventCmd cmd; + int32_t ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_LACK_VALUE_BODY_TYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_VALUE_BODY_TYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_LACK_VALUE_BODY_RESULT); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_VALUE_BODY_RESULT_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_EVENT_CMD_JSON_LACK_VALUE_BODY_CONTENT); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/base/test/unittest/common/base/dcamera_info_cmd_test.cpp b/services/cameraservice/base/test/unittest/common/base/dcamera_info_cmd_test.cpp new file mode 100755 index 00000000..fe8a42b4 --- /dev/null +++ b/services/cameraservice/base/test/unittest/common/base/dcamera_info_cmd_test.cpp @@ -0,0 +1,151 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 +#include + +#include "dcamera_info_cmd.h" +#include "distributed_camera_errno.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraInfoCmdTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +static const std::string TEST_INFO_CMD_JSON_LACK_TYPE = R"({ + "dhId": "camrea_0", + "Command": "GET_INFO", + "Value": {"State": 1} +})"; + +static const std::string TEST_INFO_CMD_JSON_TYPE_EXCEPTION = R"({ + "Type": 0, + "dhId": "camrea_0", + "Command": "GET_INFO", + "Value": {"State": 1} +})"; + +static const std::string TEST_INFO_CMD_JSON_LACK_DHID = R"({ + "Type": "OPERATION", + "Command": "GET_INFO", + "Value": {"State": 1} +})"; + +static const std::string TEST_INFO_CMD_JSON_DHID_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": 0, + "Command": "GET_INFO", + "Value": {"State": 1} +})"; + +static const std::string TEST_INFO_CMD_JSON_LACK_COMMAND = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Value": {"State": 1} +})"; + +static const std::string TEST_INFO_CMD_JSON_COMMAND_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": 0, + "Value": {"State": 1} +})"; + +static const std::string TEST_INFO_CMD_JSON_LACK_VALUE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "GET_INFO" +})"; + +static const std::string TEST_INFO_CMD_JSON_LACK_VALUE_BODY_STATE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "GET_INFO", + "Value": {} +})"; + +static const std::string TEST_INFO_CMD_JSON_VALUE_BODY_STATE_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "GET_INFO", + "Value": {"State": "1"} +})"; + + +void DCameraInfoCmdTest::SetUpTestCase(void) +{ +} + +void DCameraInfoCmdTest::TearDownTestCase(void) +{ +} + +void DCameraInfoCmdTest::SetUp(void) +{ +} + +void DCameraInfoCmdTest::TearDown(void) +{ +} + +/** + * @tc.name: Unmarshal_001. + * @tc.desc: Verify InfoCmdTest Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraInfoCmdTest, Unmarshal_001, TestSize.Level1) +{ + DCameraInfoCmd cmd; + std::string str = "0"; + int32_t ret = cmd.Unmarshal(str); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_INFO_CMD_JSON_LACK_TYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_INFO_CMD_JSON_TYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_INFO_CMD_JSON_LACK_DHID); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_INFO_CMD_JSON_DHID_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_INFO_CMD_JSON_LACK_COMMAND); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_INFO_CMD_JSON_COMMAND_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_INFO_CMD_JSON_LACK_VALUE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_INFO_CMD_JSON_LACK_VALUE_BODY_STATE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_INFO_CMD_JSON_VALUE_BODY_STATE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/base/test/unittest/common/base/dcamera_metadata_setting_cmd_test.cpp b/services/cameraservice/base/test/unittest/common/base/dcamera_metadata_setting_cmd_test.cpp new file mode 100755 index 00000000..1de5e231 --- /dev/null +++ b/services/cameraservice/base/test/unittest/common/base/dcamera_metadata_setting_cmd_test.cpp @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 +#include + +#include "dcamera_metadata_setting_cmd.h" +#include "distributed_camera_errno.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraMetadataSettingCmdTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_LACK_TYPE = R"({ + "dhId": "camrea_0", + "Command": "UPDATE_METADATA", + "Value": [{"SettingType": 1, "SettingValue": "TestSetting"}] +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_TYPE_EXCEPTION = R"({ + "Type": 0, + "dhId": "camrea_0", + "Command": "UPDATE_METADATA", + "Value": [{"SettingType": 1, "SettingValue": "TestSetting"}] +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_LACK_DHID = R"({ + "Type": "MESSAGE", + "Command": "UPDATE_METADATA", + "Value": [{"SettingType": 1, "SettingValue": "TestSetting"}] +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_DHID_EXCEPTION = R"({ + "Type": "MESSAGE", + "dhId": 0, + "Command": "UPDATE_METADATA", + "Value": [{"SettingType": 1, "SettingValue": "TestSetting"}] +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_LACK_COMMAND = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Value": [{"SettingType": 1, "SettingValue": "TestSetting"}] +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_COMMAND_EXCEPTION = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": 0, + "Value": [{"SettingType": 1, "SettingValue": "TestSetting"}] +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_LACK_VALUE = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "UPDATE_METADATA" +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_VALUE_EXCEPTION = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "UPDATE_METADATA", + "Value": "[{"SettingType": 1, "SettingValue": "TestSetting"}]" +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_LACK_VALUE_BODY_TYPE = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "UPDATE_METADATA", + "Value": [{"SettingValue": "TestSetting"}] +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_VALUE_BODY_TYPE_EXCEPTION = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "UPDATE_METADATA", + "Value": [{"SettingType": "1", "SettingValue": "TestSetting"}] +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_LACK_VALUE_BODY_VALUE = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "UPDATE_METADATA", + "Value": [{"SettingType": 1}] +})"; + +static const std::string TEST_METADATA_SETTING_CMD_JSON_VALUE_BODY_VALUE_EXCEPTION = R"({ + "Type": "MESSAGE", + "dhId": "camrea_0", + "Command": "UPDATE_METADATA", + "Value": [{"SettingType": 1, "SettingValue": 0}] +})"; + + +void DCameraMetadataSettingCmdTest::SetUpTestCase(void) +{ +} + +void DCameraMetadataSettingCmdTest::TearDownTestCase(void) +{ +} + +void DCameraMetadataSettingCmdTest::SetUp(void) +{ +} + +void DCameraMetadataSettingCmdTest::TearDown(void) +{ +} + +/** + * @tc.name: Unmarshal_001. + * @tc.desc: Verify MetadataSettingCmd Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraMetadataSettingCmdTest, Unmarshal_001, TestSize.Level1) +{ + DCameraMetadataSettingCmd cmd; + std::string str = "0"; + int32_t ret = cmd.Unmarshal(str); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_LACK_TYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_TYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_LACK_DHID); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_DHID_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_LACK_COMMAND); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_COMMAND_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_LACK_VALUE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_VALUE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: Unmarshal_002. + * @tc.desc: Verify MetadataSettingCmd Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraMetadataSettingCmdTest, Unmarshal_002, TestSize.Level1) +{ + DCameraMetadataSettingCmd cmd; + int32_t ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_LACK_VALUE_BODY_TYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_VALUE_BODY_TYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_LACK_VALUE_BODY_VALUE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_METADATA_SETTING_CMD_JSON_VALUE_BODY_VALUE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/base/test/unittest/common/base/dcamera_open_info_cmd_test.cpp b/services/cameraservice/base/test/unittest/common/base/dcamera_open_info_cmd_test.cpp new file mode 100755 index 00000000..e2245355 --- /dev/null +++ b/services/cameraservice/base/test/unittest/common/base/dcamera_open_info_cmd_test.cpp @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 +#include + +#include "dcamera_open_info_cmd.h" +#include "distributed_camera_errno.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraOpenInfoCmdTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + + +void DCameraOpenInfoCmdTest::SetUpTestCase(void) +{ +} + +void DCameraOpenInfoCmdTest::TearDownTestCase(void) +{ +} + +void DCameraOpenInfoCmdTest::SetUp(void) +{ +} + +void DCameraOpenInfoCmdTest::TearDown(void) +{ +} + +static const std::string TEST_OPEN_INFO_CMD_JSON = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "OPEN_CHANNEL", + "Value": {"SourceDevId": "TestDevId"} +})"; + +static const std::string TEST_OPEN_INFO_CMD_JSON_LACK_TYPE = R"({ + "dhId": "camrea_0", + "Command": "OPEN_CHANNEL", + "Value": {"SourceDevId": "TestDevId"} +})"; + +static const std::string TEST_OPEN_INFO_CMD_JSON_TYPE_EXCEPTION = R"({ + "Type": 0, + "dhId": "camrea_0", + "Command": "OPEN_CHANNEL", + "Value": {"SourceDevId": "TestDevId"} +})"; + +static const std::string TEST_OPEN_INFO_CMD_JSON_LACK_DHID = R"({ + "Type": "OPERATION", + "Command": "OPEN_CHANNEL", + "Value": {"SourceDevId": "TestDevId"} +})"; + +static const std::string TEST_OPEN_INFO_CMD_JSON_DHID_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": 0, + "Command": "OPEN_CHANNEL", + "Value": {"SourceDevId": "TestDevId"} +})"; + +static const std::string TEST_OPEN_INFO_CMD_JSON_LACK_COMMAND = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Value": {"SourceDevId": "TestDevId"} +})"; + +static const std::string TEST_OPEN_INFO_CMD_JSON_COMMAND_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": 0, + "Value": {"SourceDevId": "TestDevId"} +})"; + +static const std::string TEST_OPEN_INFO_CMD_JSON_LACK_VALUE = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "OPEN_CHANNEL" +})"; + +static const std::string TEST_OPEN_INFO_CMD_JSON_LACK_VALUE_BODY_DEVID = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "OPEN_CHANNEL", + "Value": {} +})"; + +static const std::string TEST_OPEN_INFO_CMD_JSON_VALUE_BODY_DEVID_EXCEPTION = R"({ + "Type": "OPERATION", + "dhId": "camrea_0", + "Command": "OPEN_CHANNEL", + "Value": {"SourceDevId": 0} +})"; + +/** + * @tc.name: dcamera_open_info_cmd_001. + * @tc.desc: Verify OpenInfoCmd Json. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraOpenInfoCmdTest, dcamera_open_info_cmd_001, TestSize.Level1) +{ + DCameraOpenInfoCmd cmd; + int32_t ret = cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON); + EXPECT_EQ(DCAMERA_OK, ret); + + std::string jsonStr; + ret = cmd.Marshal(jsonStr); + EXPECT_EQ(DCAMERA_OK, ret); + + std::string str = "0"; + ret = cmd.Unmarshal(str); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON_LACK_TYPE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON_TYPE_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON_LACK_DHID); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON_DHID_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON_LACK_COMMAND); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON_COMMAND_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON_LACK_VALUE); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON_LACK_VALUE_BODY_DEVID); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON_VALUE_BODY_DEVID_EXCEPTION); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/base/test/unittest/common/dcameraprotocol/dcamera_protocol_test.cpp b/services/cameraservice/base/test/unittest/common/base/dcamera_protocol_test.cpp old mode 100644 new mode 100755 similarity index 100% rename from services/cameraservice/base/test/unittest/common/dcameraprotocol/dcamera_protocol_test.cpp rename to services/cameraservice/base/test/unittest/common/base/dcamera_protocol_test.cpp -- Gitee