1 /*
2 * Copyright (c) 2022-2024 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 "accesstoken_kit.h"
19 #include "nativetoken_kit.h"
20 #include "token_setproc.h"
21 #include "softbus_common.h"
22 #include "if_system_ability_manager.h"
23 #include "dcamera_source_callback.h"
24 #include "distributed_camera_source_proxy.h"
25 #include "distributed_camera_source_stub.h"
26 #include "distributed_hardware_log.h"
27 #include "mock_distributed_camera_source_stub.h"
28
29
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace DistributedHardware {
34 namespace {
35 static int32_t OHOS_PERMISSION_ENABLE_DISTRIBUTED_HARDWARE_INDEX = 0;
36 static int32_t OHOS_PERMISSION_DISTRIBUTED_DATASYNC_INDEX = 1;
37 static int32_t OHOS_PERMISSION_ACCESS_DISTRIBUTED_HARDWARE_INDEX = 2;
38 }
39 class DcameraSourceStubTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase(void)47 void DcameraSourceStubTest::SetUpTestCase(void)
48 {
49 DHLOGI("DcameraSourceStubTest::SetUpTestCase");
50 }
51
TearDownTestCase(void)52 void DcameraSourceStubTest::TearDownTestCase(void)
53 {
54 DHLOGI("DcameraSourceStubTest::TearDownTestCase");
55 }
56
SetUp(void)57 void DcameraSourceStubTest::SetUp(void)
58 {
59 DHLOGI("DcameraSourceStubTest::SetUp");
60 uint64_t tokenId;
61 int32_t numberOfPermissions = 3;
62 const char *perms[numberOfPermissions];
63 perms[OHOS_PERMISSION_ENABLE_DISTRIBUTED_HARDWARE_INDEX] = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
64 perms[OHOS_PERMISSION_DISTRIBUTED_DATASYNC_INDEX] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
65 perms[OHOS_PERMISSION_ACCESS_DISTRIBUTED_HARDWARE_INDEX] = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
66 NativeTokenInfoParams infoInstance = {
67 .dcapsNum = 0,
68 .permsNum = numberOfPermissions,
69 .aclsNum = 0,
70 .dcaps = NULL,
71 .perms = perms,
72 .acls = NULL,
73 .processName = "dcamera_sink_handler",
74 .aplStr = "system_basic",
75 };
76 tokenId = GetAccessTokenId(&infoInstance);
77 SetSelfTokenID(tokenId);
78 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
79 }
80
TearDown(void)81 void DcameraSourceStubTest::TearDown(void)
82 {
83 DHLOGI("DcameraSourceStubTest::TearDown");
84 }
85
86 /**
87 * @tc.name: dcamera_source_stub_test_001
88 * @tc.desc: Verify the InitSource function.
89 * @tc.type: FUNC
90 * @tc.require: issue
91 */
92 HWTEST_F(DcameraSourceStubTest, dcamera_source_stub_test_001, TestSize.Level1)
93 {
94 DHLOGI("DcameraSourceStubTest::dcamera_source_stub_test_001");
95 sptr<IRemoteObject> sourceStubPtr(new MockDistributedCameraSourceStub());
96 DistributedCameraSourceProxy sourceProxy(sourceStubPtr);
97 std::string params = "params000";
98 sptr<IDCameraSourceCallback> callback(new DCameraSourceCallback());
99 int32_t ret = sourceProxy.InitSource(params, callback);
100 EXPECT_EQ(DCAMERA_OK, ret);
101 }
102
103 /**
104 * @tc.name: dcamera_source_stub_test_002
105 * @tc.desc: Verify the ReleaseSource function.
106 * @tc.type: FUNC
107 * @tc.require: issue
108 */
109 HWTEST_F(DcameraSourceStubTest, dcamera_source_stub_test_002, TestSize.Level1)
110 {
111 DHLOGI("DcameraSourceStubTest::dcamera_source_stub_test_002");
112 sptr<IRemoteObject> sourceStubPtr(new MockDistributedCameraSourceStub());
113 DistributedCameraSourceProxy sourceProxy(sourceStubPtr);
114 int32_t ret = sourceProxy.ReleaseSource();
115 EXPECT_EQ(DCAMERA_OK, ret);
116 }
117
118 /**
119 * @tc.name: dcamera_source_stub_test_003
120 * @tc.desc: Verify the RegisterDistributedHardware function.
121 * @tc.type: FUNC
122 * @tc.require: issue
123 */
124 HWTEST_F(DcameraSourceStubTest, dcamera_source_stub_test_003, TestSize.Level1)
125 {
126 DHLOGI("DcameraSourceStubTest::dcamera_source_stub_test_003");
127 sptr<IRemoteObject> sourceStubPtr(new MockDistributedCameraSourceStub());
128 DistributedCameraSourceProxy sourceProxy(sourceStubPtr);
129 std::string devId = "devId000";
130 std::string dhId = "dhId000";
131 std::string reqId = "reqId000";
132 EnableParam param;
133 param.sourceVersion = "1";
134 param.sourceAttrs = "sourceattrs";
135 param.sinkVersion = "1";
136 param.sinkAttrs = "sinkattrs";
137 int32_t ret = sourceProxy.RegisterDistributedHardware(devId, dhId, reqId, param);
138 EXPECT_EQ(DCAMERA_OK, ret);
139 }
140
141 /**
142 * @tc.name: dcamera_source_stub_test_004
143 * @tc.desc: Verify the UnregisterDistributedHardware function.
144 * @tc.type: FUNC
145 * @tc.require: issue
146 */
147 HWTEST_F(DcameraSourceStubTest, dcamera_source_stub_test_004, TestSize.Level1)
148 {
149 DHLOGI("DcameraSourceStubTest::dcamera_source_stub_test_004");
150 sptr<IRemoteObject> sourceStubPtr(new MockDistributedCameraSourceStub());
151 DistributedCameraSourceProxy sourceProxy(sourceStubPtr);
152 std::string devId = "devId000";
153 std::string dhId = "dhId000";
154 std::string reqId = "reqId000";
155 int32_t ret = sourceProxy.UnregisterDistributedHardware(devId, dhId, reqId);
156 EXPECT_EQ(DCAMERA_OK, ret);
157 }
158
159 /**
160 * @tc.name: dcamera_source_stub_test_005
161 * @tc.desc: Verify the DCameraNotify function.
162 * @tc.type: FUNC
163 * @tc.require: issue
164 */
165 HWTEST_F(DcameraSourceStubTest, dcamera_source_stub_test_005, TestSize.Level1)
166 {
167 DHLOGI("DcameraSourceStubTest::dcamera_source_stub_test_005");
168 sptr<IRemoteObject> sourceStubPtr(new MockDistributedCameraSourceStub());
169 DistributedCameraSourceProxy sourceProxy(sourceStubPtr);
170 std::string devId = "devId000";
171 std::string dhId = "dhId000";
172 std::string events = "events000";
173 int32_t ret = sourceProxy.DCameraNotify(devId, dhId, events);
174 EXPECT_EQ(DCAMERA_OK, ret);
175 }
176
177 /**
178 * @tc.name: dcamera_source_stub_test_006
179 * @tc.desc: Verify the DCameraNotify function.
180 * @tc.type: FUNC
181 * @tc.require: issue
182 */
183 HWTEST_F(DcameraSourceStubTest, dcamera_source_stub_test_006, TestSize.Level1)
184 {
185 DHLOGI("DcameraSourceStubTest::dcamera_source_stub_test_006");
186 sptr<IRemoteObject> sourceStubPtr(new MockDistributedCameraSourceStub());
187 DistributedCameraSourceProxy sourceProxy(sourceStubPtr);
188 std::string devId = "";
189 std::string dhId = "dhId000";
190 std::string events = "events000";
191 int32_t ret = sourceProxy.DCameraNotify(devId, dhId, events);
192 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
193
194 devId = "devId000";
195 events = "";
196 ret = sourceProxy.DCameraNotify(devId, dhId, events);
197 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
198
199 dhId = "";
200 ret = sourceProxy.DCameraNotify(devId, dhId, events);
201 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
202 }
203
204 /**
205 * @tc.name: dcamera_source_stub_test_007
206 * @tc.desc: Verify the UnregisterDistributedHardware function.
207 * @tc.type: FUNC
208 * @tc.require: issue
209 */
210 HWTEST_F(DcameraSourceStubTest, dcamera_source_stub_test_007, TestSize.Level1)
211 {
212 DHLOGI("DcameraSourceStubTest::dcamera_source_stub_test_007");
213 sptr<IRemoteObject> sourceStubPtr(new MockDistributedCameraSourceStub());
214 DistributedCameraSourceProxy sourceProxy(sourceStubPtr);
215 std::string devId = "";
216 std::string dhId = "dhId000";
217 std::string reqId = "reqId000";
218 int32_t ret = sourceProxy.UnregisterDistributedHardware(devId, dhId, reqId);
219 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
220
221 devId = "devId000";
222 reqId = "";
223 ret = sourceProxy.UnregisterDistributedHardware(devId, dhId, reqId);
224 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
225
226 dhId = "";
227 ret = sourceProxy.UnregisterDistributedHardware(devId, dhId, reqId);
228 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
229 }
230
231 /**
232 * @tc.name: dcamera_source_stub_test_008
233 * @tc.desc: Verify the RegisterDistributedHardware function.
234 * @tc.type: FUNC
235 * @tc.require: issue
236 */
237 HWTEST_F(DcameraSourceStubTest, dcamera_source_stub_test_008, TestSize.Level1)
238 {
239 DHLOGI("DcameraSourceStubTest::dcamera_source_stub_test_008");
240 sptr<IRemoteObject> sourceStubPtr(new MockDistributedCameraSourceStub());
241 DistributedCameraSourceProxy sourceProxy(sourceStubPtr);
242 std::string devId = "";
243 std::string dhId = "dhId000";
244 std::string reqId = "reqId000";
245 EnableParam param;
246 param.sourceVersion = "1";
247 param.sourceAttrs = "sourceattrs";
248 param.sinkVersion = "1";
249 param.sinkAttrs = "sinkattrs";
250 int32_t ret = sourceProxy.RegisterDistributedHardware(devId, dhId, reqId, param);
251 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
252
253 devId = "devId000";
254 reqId = "";
255 ret = sourceProxy.RegisterDistributedHardware(devId, dhId, reqId, param);
256 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
257
258 dhId = "";
259 ret = sourceProxy.RegisterDistributedHardware(devId, dhId, reqId, param);
260 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
261
262 dhId = "dhId000";
263 reqId = "reqId000";
264 param.sinkVersion = "";
265 ret = sourceProxy.RegisterDistributedHardware(devId, dhId, reqId, param);
266 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
267
268 param.sinkVersion = "1";
269 param.sinkAttrs = "";
270 ret = sourceProxy.RegisterDistributedHardware(devId, dhId, reqId, param);
271 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
272 }
273 } // namespace DistributedHardware
274 } // namespace OHOS