1 /*
2 * Copyright (c) 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 "player_service_stub_test.h"
17 #include "media_errors.h"
18
19 namespace OHOS {
20 namespace Media {
21 using namespace std;
22 using namespace testing::ext;
23
SetUpTestCase(void)24 void PlayerServiceStubTest::SetUpTestCase(void)
25 {
26 }
27
TearDownTestCase(void)28 void PlayerServiceStubTest::TearDownTestCase(void)
29 {
30 }
31
SetUp(void)32 void PlayerServiceStubTest::SetUp(void)
33 {
34 }
35
TearDown(void)36 void PlayerServiceStubTest::TearDown(void)
37 {
38 }
39
40 /**
41 * @tc.name : ~PlayerServiceStub
42 * @tc.number: ~PlayerServiceStub
43 * @tc.desc : FUNC
44 */
45 HWTEST_F(PlayerServiceStubTest, CreateReleaseStubObject, TestSize.Level1)
46 {
47 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
48 EXPECT_NE(playerServiceStub, nullptr);
49 playerServiceStub->playerServer_ = nullptr;
50 playerServiceStub = nullptr;
51 }
52
53 /**
54 * @tc.name : DestoyServiceStub
55 * @tc.number: DestoyServiceStub
56 * @tc.desc : FUNC
57 */
58 HWTEST_F(PlayerServiceStubTest, DestoyServiceStub, TestSize.Level1)
59 {
60 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
61 EXPECT_NE(playerServiceStub, nullptr);
62 playerServiceStub->playerServer_ = nullptr;
63 int ret = playerServiceStub->DestroyStub();
64 EXPECT_EQ(ret, 0);
65 playerServiceStub = nullptr;
66 }
67
68 /**
69 * @tc.name : DoIpcRecovery
70 * @tc.number: DoIpcRecovery
71 * @tc.desc : FUNC
72 */
73 HWTEST_F(PlayerServiceStubTest, DoIpcRecovery, TestSize.Level1)
74 {
75 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
76 EXPECT_NE(playerServiceStub, nullptr);
77 int ret = playerServiceStub->DoIpcRecovery(true);
78 EXPECT_EQ(ret, 0);
79 ret = playerServiceStub->DoIpcRecovery(false);
80 EXPECT_EQ(ret, 0);
81 playerServiceStub = nullptr;
82 }
83
84 /**
85 * @tc.name : SetMediaSource_001
86 * @tc.number: SetMediaSource_001
87 * @tc.desc : FUNC
88 */
89 HWTEST_F(PlayerServiceStubTest, SetMediaSource_001, TestSize.Level1)
90 {
91 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
92 EXPECT_NE(playerServiceStub, nullptr);
93
94 MessageParcel data;
95 MessageParcel reply;
96 MessageOption option;
97 std::string url = "fd://abc?d";
98 data.WriteString(url);
99 auto headerSize = 0;
100 data.WriteUint32(headerSize);
101 std::string mimeType = "application/m3u8";
102 data.WriteString(mimeType);
103
104 int ret = playerServiceStub->SetMediaSource(data, reply);
105 EXPECT_EQ(ret, 0);
106 playerServiceStub = nullptr;
107 }
108
109 /**
110 * @tc.name : SetMediaSource_002
111 * @tc.number: SetMediaSource_002
112 * @tc.desc : FUNC
113 */
114 HWTEST_F(PlayerServiceStubTest, SetMediaSource_002, TestSize.Level1)
115 {
116 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
117 EXPECT_NE(playerServiceStub, nullptr);
118
119 MessageParcel data;
120 MessageParcel reply;
121 MessageOption option;
122 std::string url = "abc?d";
123 data.WriteString(url);
124 auto headerSize = 0;
125 data.WriteUint32(headerSize);
126 std::string mimeType = "application/m3u8";
127 data.WriteString(mimeType);
128
129 int ret = playerServiceStub->SetMediaSource(data, reply);
130 EXPECT_EQ(ret, 0);
131 playerServiceStub = nullptr;
132 }
133
134 /**
135 * @tc.name : SetMediaSource_003
136 * @tc.number: SetMediaSource_003
137 * @tc.desc : FUNC
138 */
139 HWTEST_F(PlayerServiceStubTest, SetMediaSource_003, TestSize.Level1)
140 {
141 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
142 EXPECT_NE(playerServiceStub, nullptr);
143
144 MessageParcel data;
145 MessageParcel reply;
146 MessageOption option;
147 std::string url = "fd://abc";
148 data.WriteString(url);
149 auto headerSize = 0;
150 data.WriteUint32(headerSize);
151 std::string mimeType = "application/m3u8";
152 data.WriteString(mimeType);
153
154 int ret = playerServiceStub->SetMediaSource(data, reply);
155 EXPECT_EQ(ret, 0);
156 playerServiceStub = nullptr;
157 }
158
159 /**
160 * @tc.name : SetMediaSource_004
161 * @tc.number: SetMediaSource_004
162 * @tc.desc : FUNC
163 */
164 HWTEST_F(PlayerServiceStubTest, SetMediaSource_004, TestSize.Level1)
165 {
166 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
167 EXPECT_NE(playerServiceStub, nullptr);
168
169 MessageParcel data;
170 MessageParcel reply;
171 MessageOption option;
172 std::string url = "fd://abc";
173 data.WriteString(url);
174 auto headerSize = 0;
175 data.WriteUint32(headerSize);
176 std::string mimeType = "application";
177 data.WriteString(mimeType);
178
179 int ret = playerServiceStub->SetMediaSource(data, reply);
180 EXPECT_EQ(ret, 0);
181 playerServiceStub = nullptr;
182 }
183
184 /**
185 * @tc.name : SetMediaSource_005
186 * @tc.number: SetMediaSource_005
187 * @tc.desc : FUNC
188 */
189 HWTEST_F(PlayerServiceStubTest, SetMediaSource_005, TestSize.Level1)
190 {
191 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
192 EXPECT_NE(playerServiceStub, nullptr);
193
194 MessageParcel data;
195 MessageParcel reply;
196 std::string url = "fd://abc";
197 data.WriteString(url);
198 auto headerSize = 0;
199 data.WriteUint32(headerSize);
200 std::string mimeType = "application";
201 data.WriteString(mimeType);
202 data.WriteUint32(11);
203
204 int ret = playerServiceStub->SetMediaSource(data, reply);
205 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
206 playerServiceStub = nullptr;
207 }
208
209 /**
210 * @tc.name : Freeze_001
211 * @tc.number: Freeze_001
212 * @tc.desc : FUNC
213 */
214 HWTEST_F(PlayerServiceStubTest, Freeze_001, TestSize.Level1)
215 {
216 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
217 ASSERT_NE(playerServiceStub, nullptr);
218
219 int ret = playerServiceStub->Freeze();
220 EXPECT_EQ(ret, 0);
221 playerServiceStub = nullptr;
222 }
223
224 /**
225 * @tc.name : UnFreeze_001
226 * @tc.number: UnFreeze_001
227 * @tc.desc : FUNC
228 */
229 HWTEST_F(PlayerServiceStubTest, UnFreeze_001, TestSize.Level1)
230 {
231 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
232 ASSERT_NE(playerServiceStub, nullptr);
233
234 playerServiceStub->isFrozen_ = true;
235 int ret = playerServiceStub->UnFreeze();
236 EXPECT_EQ(ret, 0);
237 playerServiceStub = nullptr;
238 }
239
240 /**
241 * @tc.name : EnableReportAudioInterrupt_001
242 * @tc.number: EnableReportAudioInterrupt_001
243 * @tc.desc : FUNC
244 */
245 HWTEST_F(PlayerServiceStubTest, EnableReportAudioInterrupt_001, TestSize.Level1)
246 {
247 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
248 ASSERT_NE(playerServiceStub, nullptr);
249
250 MessageParcel data;
251 MessageParcel reply;
252 MessageOption option;
253 data.WriteBool(true);
254
255 int ret = playerServiceStub->EnableReportAudioInterrupt(data, reply);
256 EXPECT_EQ(ret, 0);
257 playerServiceStub = nullptr;
258 }
259
260 /**
261 * @tc.name : EnableReportAudioInterrupt_002
262 * @tc.number: EnableReportAudioInterrupt_002
263 * @tc.desc : FUNC
264 */
265 HWTEST_F(PlayerServiceStubTest, EnableReportAudioInterrupt_002, TestSize.Level1)
266 {
267 sptr<PlayerServiceStub> playerServiceStub = PlayerServiceStub::Create();
268 ASSERT_NE(playerServiceStub, nullptr);
269
270 MessageParcel data;
271 MessageParcel reply;
272 MessageOption option;
273 data.WriteBool(false);
274
275 int ret = playerServiceStub->EnableReportAudioInterrupt(data, reply);
276 EXPECT_EQ(ret, 0);
277 playerServiceStub = nullptr;
278 }
279 }
280 }