1 /*
2 * Copyright (c) 2024-2025 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 #include "accesstoken_kit.h"
18 #include "av_cast_controller_callback_stub.h"
19 #include "avsession_descriptor.h"
20 #include "avsession_errors.h"
21 #include "avsession_log.h"
22 #include "token_setproc.h"
23 #include "av_shared_memory_base.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::Security::AccessToken;
27
28 namespace OHOS {
29 namespace AVSession {
30
31 static uint64_t g_selfTokenId = 0;
32 static HapInfoParams g_info = {
33 .userID = 100,
34 .bundleName = "ohos.permission_test.demo",
35 .instIndex = 0,
36 .appIDDesc = "ohos.permission_test.demo",
37 .isSystemApp = true
38 };
39
40 static HapPolicyParams g_policy = {
41 .apl = APL_NORMAL,
42 .domain = "test.domain",
43 .permList = {
44 {
45 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
46 .bundleName = "ohos.permission_test.demo",
47 .grantMode = 1,
48 .availableLevel = APL_NORMAL,
49 .label = "label",
50 .labelId = 1,
51 .description = "test",
52 .descriptionId = 1
53 }
54 },
55 .permStateList = {
56 {
57 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
58 .isGeneral = true,
59 .resDeviceID = {"local"},
60 .grantStatus = {PermissionState::PERMISSION_GRANTED},
61 .grantFlags = {1}
62 }
63 }
64 };
65
66 class AVCastControllerCallbackStubTest : public testing::Test {
67 public:
68 static void SetUpTestCase();
69 static void TearDownTestCase();
70 void SetUp() override;
71 void TearDown() override;
72 };
73
SetUpTestCase()74 void AVCastControllerCallbackStubTest::SetUpTestCase()
75 {
76 g_selfTokenId = GetSelfTokenID();
77 AccessTokenKit::AllocHapToken(g_info, g_policy);
78 AccessTokenIDEx tokenID = AccessTokenKit::GetHapTokenIDEx(g_info.userID, g_info.bundleName, g_info.instIndex);
79 SetSelfTokenID(tokenID.tokenIDEx);
80 }
81
TearDownTestCase()82 void AVCastControllerCallbackStubTest::TearDownTestCase()
83 {
84 SetSelfTokenID(g_selfTokenId);
85 auto tokenId = AccessTokenKit::GetHapTokenID(g_info.userID, g_info.bundleName, g_info.instIndex);
86 AccessTokenKit::DeleteToken(tokenId);
87 }
88
SetUp()89 void AVCastControllerCallbackStubTest::SetUp()
90 {}
91
TearDown()92 void AVCastControllerCallbackStubTest::TearDown()
93 {}
94
95 class AVCastControllerCallbackStubDemo : public AVCastControllerCallbackStub {
96 public:
OnCastPlaybackStateChange(const AVPlaybackState & state)97 ErrCode OnCastPlaybackStateChange(const AVPlaybackState& state) override
98 {
99 return AVSESSION_SUCCESS;
100 }
OnMediaItemChange(const AVQueueItem & avQueueItem)101 ErrCode OnMediaItemChange(const AVQueueItem& avQueueItem) override
102 {
103 return AVSESSION_SUCCESS;
104 }
OnPlayNext()105 ErrCode OnPlayNext() override
106 {
107 return AVSESSION_SUCCESS;
108 }
OnPlayPrevious()109 ErrCode OnPlayPrevious() override
110 {
111 return AVSESSION_SUCCESS;
112 }
OnSeekDone(const int32_t seekNumber)113 ErrCode OnSeekDone(const int32_t seekNumber) override
114 {
115 return AVSESSION_SUCCESS;
116 }
OnVideoSizeChange(const int32_t width,const int32_t height)117 ErrCode OnVideoSizeChange(const int32_t width, const int32_t height) override
118 {
119 return AVSESSION_SUCCESS;
120 }
OnPlayerError(const int32_t errorCode,const std::string & errorMsg)121 ErrCode OnPlayerError(const int32_t errorCode, const std::string& errorMsg) override
122 {
123 return AVSESSION_SUCCESS;
124 }
OnEndOfStream(const int32_t isLooping)125 ErrCode OnEndOfStream(const int32_t isLooping) override
126 {
127 return AVSESSION_SUCCESS;
128 }
OnPlayRequest(const AVQueueItem & avQueueItem)129 ErrCode OnPlayRequest(const AVQueueItem& avQueueItem) override
130 {
131 return AVSESSION_SUCCESS;
132 }
OnKeyRequest(const std::string & assetId,const std::vector<uint8_t> & keyRequestData)133 ErrCode OnKeyRequest(const std::string& assetId, const std::vector<uint8_t>& keyRequestData) override
134 {
135 return AVSESSION_SUCCESS;
136 }
OnCastValidCommandChanged(const std::vector<int32_t> & cmds)137 ErrCode OnCastValidCommandChanged(const std::vector<int32_t> &cmds) override
138 {
139 return AVSESSION_SUCCESS;
140 }
onDataSrcRead(const std::shared_ptr<AVSharedMemoryBase> & mem,uint32_t length,int64_t pos,int32_t & result)141 ErrCode onDataSrcRead(const std::shared_ptr<AVSharedMemoryBase>& mem, uint32_t length,
142 int64_t pos, int32_t& result) override
143 {
144 return AVSESSION_SUCCESS;
145 }
OnCustomData(const OHOS::AAFwk::WantParams & data)146 ErrCode OnCustomData(const OHOS::AAFwk::WantParams& data) override
147 {
148 return AVSESSION_SUCCESS;
149 };
150 };
151
152 /**
153 * @tc.name: OnRemoteRequest001
154 * @tc.desc: test OnRemoteRequest with failed code
155 * @tc.type: FUNC
156 */
157 static HWTEST_F(AVCastControllerCallbackStubTest, OnRemoteRequest001, TestSize.Level0)
158 {
159 uint32_t code = 100;
160 AVCastControllerCallbackStubDemo avCastControllerCallbackStubDemo;
161 OHOS::MessageParcel data;
162 OHOS::MessageParcel reply;
163 OHOS::MessageOption option;
164 auto localDescriptor = IAVCastControllerCallback::GetDescriptor();
165 data.WriteInterfaceToken(localDescriptor);
166 int ret = avCastControllerCallbackStubDemo.OnRemoteRequest(code, data, reply, option);
167 EXPECT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR);
168 }
169
170 /**
171 * @tc.name: OnRemoteRequest002
172 * @tc.desc: test OnRemoteRequest with failed Descriptor
173 * @tc.type: FUNC
174 */
175 static HWTEST_F(AVCastControllerCallbackStubTest, OnRemoteRequest002, TestSize.Level0)
176 {
177 uint32_t code = 100;
178 AVCastControllerCallbackStubDemo avCastControllerCallbackStubDemo;
179 OHOS::MessageParcel data;
180 OHOS::MessageParcel reply;
181 OHOS::MessageOption option;
182 int ret = avCastControllerCallbackStubDemo.OnRemoteRequest(code, data, reply, option);
183 EXPECT_EQ(ret, ERR_TRANSACTION_FAILED);
184 }
185
186 /**
187 * @tc.name: OnRemoteRequest003
188 * @tc.desc: test HandleOnKeyRequest
189 * @tc.type: FUNC
190 */
191 static HWTEST_F(AVCastControllerCallbackStubTest, OnRemoteRequest003, TestSize.Level0)
192 {
193 uint32_t code = 9;
194 AVCastControllerCallbackStubDemo avCastControllerCallbackStubDemo;
195 OHOS::MessageParcel data;
196 OHOS::MessageParcel reply;
197 OHOS::MessageOption option;
198
199 auto localDescriptor = IAVCastControllerCallback::GetDescriptor();
200 data.WriteInterfaceToken(localDescriptor);
201 int ret = avCastControllerCallbackStubDemo.OnRemoteRequest(code, data, reply, option);
202 EXPECT_EQ(ret, ERR_INVALID_DATA);
203 }
204
205 /**
206 * @tc.name: OnRemoteRequest004
207 * @tc.desc: test HandleOnKeyRequest
208 * @tc.type: FUNC
209 */
210 static HWTEST_F(AVCastControllerCallbackStubTest, OnRemoteRequest004, TestSize.Level0)
211 {
212 uint32_t code = 9;
213 AVCastControllerCallbackStubDemo avCastControllerCallbackStubDemo;
214 OHOS::MessageParcel data;
215 OHOS::MessageParcel reply;
216 OHOS::MessageOption option;
217
218 data.WriteString("***");
219 auto localDescriptor = IAVCastControllerCallback::GetDescriptor();
220 data.WriteInterfaceToken(localDescriptor);
221 void* ptr = nullptr;
222 data.WriteBuffer(ptr, 0);
223 data.WriteInt32(1);
224
225 int ret = avCastControllerCallbackStubDemo.OnRemoteRequest(code, data, reply, option);
226 EXPECT_EQ(ret, ERR_TRANSACTION_FAILED);
227 }
228
229 /**
230 * @tc.name: OnRemoteRequest005
231 * @tc.desc: test HandleOnKeyRequest
232 * @tc.type: FUNC
233 */
234 static HWTEST_F(AVCastControllerCallbackStubTest, OnRemoteRequest005, TestSize.Level0)
235 {
236 uint32_t code = 9;
237 AVCastControllerCallbackStubDemo avCastControllerCallbackStubDemo;
238 OHOS::MessageParcel data;
239 OHOS::MessageParcel reply;
240 OHOS::MessageOption option;
241
242 data.WriteString("***");
243 auto localDescriptor = IAVCastControllerCallback::GetDescriptor();
244 data.WriteInterfaceToken(localDescriptor);
245 std::string str{"0000"};
246 data.WriteBuffer(str.c_str(), 4);
247 data.WriteInt32(0);
248
249 int ret = avCastControllerCallbackStubDemo.OnRemoteRequest(code, data, reply, option);
250 EXPECT_EQ(ret, ERR_TRANSACTION_FAILED);
251 }
252
253 /**
254 * @tc.name: OnRemoteRequest006
255 * @tc.desc: test HandleOnKeyRequest
256 * @tc.type: FUNC
257 */
258 static HWTEST_F(AVCastControllerCallbackStubTest, OnRemoteRequest006, TestSize.Level0)
259 {
260 uint32_t code = 9;
261 AVCastControllerCallbackStubDemo avCastControllerCallbackStubDemo;
262 OHOS::MessageParcel data;
263 OHOS::MessageParcel reply;
264 OHOS::MessageOption option;
265
266 data.WriteString("***");
267 auto localDescriptor = IAVCastControllerCallback::GetDescriptor();
268 data.WriteInterfaceToken(localDescriptor);
269 std::string str{"0000"};
270 data.WriteBuffer(str.c_str(), 4);
271 data.WriteInt32(4);
272
273 int ret = avCastControllerCallbackStubDemo.OnRemoteRequest(code, data, reply, option);
274 EXPECT_EQ(ret, ERR_TRANSACTION_FAILED);
275 }
276
277 /**
278 * @tc.name: onDataSrcRead001
279 * @tc.desc: test onDataSrcRead when memory equal nullptr
280 * @tc.type: FUNC
281 */
282 static HWTEST_F(AVCastControllerCallbackStubTest, onDataSrcRead001, TestSize.Level1)
283 {
284 std::shared_ptr<AVSharedMemoryBase> memory = AVSharedMemoryBase::CreateFromRemote(-1, 10, 1, "test");
285 std::string assetId = "";
286 AVCastControllerCallbackStubDemo avCastControllerCallbackStubDemo;
287 int32_t result = 0;
288 auto ret = avCastControllerCallbackStubDemo.onDataSrcRead(memory, 2, 2, result);
289 EXPECT_EQ(ret, AVSESSION_SUCCESS);
290 }
291 } // namespace OHOS
292 } // namespace AVSession
293