1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "dcamera_handler.h"
19 #include "dcamera_sink_handler.h"
20 #include "dcamera_sink_handler_ipc.h"
21 #include "distributed_camera_errno.h"
22 #include "distributed_hardware_log.h"
23 #include "idistributed_camera_sink.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace DistributedHardware {
29 class DistributedCameraSinkServiceTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 };
36
37 static std::string g_dhId;
38 static sptr<IDistributedCameraSink> g_service;
39
40 std::string g_testParams = "TestParams";
41 std::string g_testCameraInfo = "";
42 std::string g_testChannelInfoContinue = R"({
43 "Type": "OPERATION",
44 "dhId": "camrea_0",
45 "Command": "CHANNEL_NEG",
46 "Value": {"SourceDevId": "TestDevId",
47 "Detail": [{"DataSessionFlag": "dataContinue", "StreamType": 0}]}
48 })";
49 std::string g_testOpenInfoService = R"({
50 "Type": "OPERATION",
51 "dhId": "camrea_0",
52 "Command": "OPEN_CHANNEL",
53 "Value": {"SourceDevId": "TestDevId"}
54 })";
55
SetUpTestCase(void)56 void DistributedCameraSinkServiceTest::SetUpTestCase(void)
57 {
58 DHLOGI("DistributedCameraSinkServiceTest::SetUpTestCase");
59 DCameraHandler::GetInstance().Initialize();
60 g_dhId = DCameraHandler::GetInstance().GetCameras().front();
61
62 DCameraSinkHandler::GetInstance().InitSink(g_testParams);
63 g_service = DCameraSinkHandlerIpc::GetInstance().GetSinkLocalCamSrv();
64 }
65
TearDownTestCase(void)66 void DistributedCameraSinkServiceTest::TearDownTestCase(void)
67 {
68 DHLOGI("DistributedCameraSinkServiceTest::TearDownTestCase");
69 g_service = nullptr;
70 DCameraSinkHandler::GetInstance().ReleaseSink();
71 }
72
SetUp(void)73 void DistributedCameraSinkServiceTest::SetUp(void)
74 {
75 DHLOGI("DistributedCameraSinkServiceTest::SetUp");
76 }
77
TearDown(void)78 void DistributedCameraSinkServiceTest::TearDown(void)
79 {
80 DHLOGI("DistributedCameraSinkServiceTest::TearDown");
81 }
82
83 /**
84 * @tc.name: dcamera_sink_service_test_001
85 * @tc.desc: Verify the SubscribeLocalHardware function.
86 * @tc.type: FUNC
87 * @tc.require: AR000GK6MT
88 */
89 HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_001, TestSize.Level1)
90 {
91 DHLOGI("DistributedCameraSinkServiceTest::SubscribeLocalHardware");
92 int32_t ret = g_service->SubscribeLocalHardware(g_dhId, g_testParams);
93 EXPECT_EQ(DCAMERA_OK, ret);
94 }
95
96 /**
97 * @tc.name: dcamera_sink_service_test_002
98 * @tc.desc: Verify the UnSubscribeLocalHardware function.
99 * @tc.type: FUNC
100 * @tc.require: AR000GK6MT
101 */
102 HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_002, TestSize.Level1)
103 {
104 DHLOGI("DistributedCameraSinkServiceTest::UnSubscribeLocalHardware");
105 int32_t ret = g_service->UnsubscribeLocalHardware(g_dhId);
106 EXPECT_EQ(DCAMERA_OK, ret);
107 }
108
109 /**
110 * @tc.name: dcamera_sink_service_test_003
111 * @tc.desc: Verify the StopCapture function.
112 * @tc.type: FUNC
113 * @tc.require: AR000GK6N1
114 */
115 HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_003, TestSize.Level1)
116 {
117 DHLOGI("DistributedCameraSinkServiceTest::StopCapture");
118 int32_t ret = g_service->StopCapture(g_dhId);
119 EXPECT_EQ(DCAMERA_OK, ret);
120 }
121
122 /**
123 * @tc.name: dcamera_sink_service_test_004
124 * @tc.desc: Verify the ChannelNeg function.
125 * @tc.type: FUNC
126 * @tc.require: AR000GK6MT
127 */
128 HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_004, TestSize.Level1)
129 {
130 DHLOGI("DistributedCameraSinkServiceTest::ChannelNeg");
131 int32_t ret = g_service->ChannelNeg(g_dhId, g_testChannelInfoContinue);
132 EXPECT_EQ(DCAMERA_OK, ret);
133 }
134
135 /**
136 * @tc.name: dcamera_sink_service_test_005
137 * @tc.desc: Verify the GetCameraInfo function.
138 * @tc.type: FUNC
139 * @tc.require: AR000GK6MT
140 */
141 HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_005, TestSize.Level1)
142 {
143 DHLOGI("DistributedCameraSinkServiceTest::GetCameraInfo");
144 int32_t ret = g_service->GetCameraInfo(g_dhId, g_testCameraInfo);
145 EXPECT_EQ(DCAMERA_OK, ret);
146 }
147
148 /**
149 * @tc.name: dcamera_sink_service_test_006
150 * @tc.desc: Verify the OpenChannel and CloseChannel function.
151 * @tc.type: FUNC
152 * @tc.require: AR000GK6N1
153 */
154 HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_006, TestSize.Level1)
155 {
156 DHLOGI("DistributedCameraSinkServiceTest::OpenChannel and CloseChannel");
157 int32_t ret = g_service->OpenChannel(g_dhId, g_testOpenInfoService);
158 EXPECT_EQ(DCAMERA_OK, ret);
159
160 ret = g_service->CloseChannel(g_dhId);
161 EXPECT_EQ(DCAMERA_OK, ret);
162 }
163 } // namespace DistributedHardware
164 } // namespace OHOS