1 /*
2 * Copyright (c) 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 "player_server_unit_test.h"
17 #include <unistd.h>
18 #include <securec.h>
19 #include "media_errors.h"
20 #include "audio_effect.h"
21 #include "av_common.h"
22 #include "meta/video_types.h"
23
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS::Media::PlayerTestParam;
27
28 namespace OHOS {
29 namespace Media {
30 namespace {
31 using ErrorMessageFunc = std::function<std::string(const std::string& param1, const std::string& param2)>;
32 const std::map<MediaServiceErrCode, std::string> MSERRCODE_INFOS = {
33 {MSERR_OK, "success"},
34 {MSERR_NO_MEMORY, "no memory"},
35 {MSERR_INVALID_OPERATION, "operation not be permitted"},
36 {MSERR_INVALID_VAL, "invalid argument"},
37 {MSERR_UNKNOWN, "unkown error"},
38 {MSERR_MANDATORY_PARAMETER_UNSPECIFIED, "mandatory parameters are left unspecified"},
39 {MSERR_INCORRECT_PARAMETER_TYPE, "Incorrect parameter types"},
40 {MSERR_PARAMETER_VERIFICATION_FAILED, "Parameter verification failed"},
41 {MSERR_SERVICE_DIED, "media service died"},
42 {MSERR_CREATE_REC_ENGINE_FAILED, "create recorder engine failed"},
43 {MSERR_CREATE_PLAYER_ENGINE_FAILED, "create player engine failed"},
44 {MSERR_CREATE_AVMETADATAHELPER_ENGINE_FAILED, "create avmetadatahelper engine failed"},
45 {MSERR_INVALID_STATE, "the state is not support this operation"},
46 {MSERR_UNSUPPORT, "unsupport interface"},
47 {MSERR_UNSUPPORT_AUD_SRC_TYPE, "unsupport audio source type"},
48 {MSERR_UNSUPPORT_AUD_SAMPLE_RATE, "unsupport audio sample rate"},
49 {MSERR_UNSUPPORT_AUD_CHANNEL_NUM, "unsupport audio channel"},
50 {MSERR_UNSUPPORT_AUD_ENC_TYPE, "unsupport audio encoder type"},
51 {MSERR_UNSUPPORT_AUD_PARAMS, "unsupport audio params(other params)"},
52 {MSERR_UNSUPPORT_VID_SRC_TYPE, "unsupport video source type"},
53 {MSERR_UNSUPPORT_VID_ENC_TYPE, "unsupport video encoder type"},
54 {MSERR_UNSUPPORT_VID_PARAMS, "unsupport video params(other params)"},
55 {MSERR_UNSUPPORT_CONTAINER_TYPE, "unsupport container format type"},
56 {MSERR_UNSUPPORT_PROTOCOL_TYPE, "unsupport protocol type"},
57 {MSERR_UNSUPPORT_VID_DEC_TYPE, "unsupport video decoder type"},
58 {MSERR_UNSUPPORT_AUD_DEC_TYPE, "unsupport audio decoder type"},
59 {MSERR_UNSUPPORT_STREAM, "internal data stream error"},
60 {MSERR_UNSUPPORT_FILE, "this appears to be a text file"},
61 {MSERR_UNSUPPORT_SOURCE, "unsupport source type"},
62 {MSERR_AUD_ENC_FAILED, "audio encode failed"},
63 {MSERR_AUD_RENDER_FAILED, "audio render failed"},
64 {MSERR_VID_ENC_FAILED, "video encode failed"},
65 {MSERR_AUD_DEC_FAILED, "audio decode failed"},
66 {MSERR_VID_DEC_FAILED, "video decode failed"},
67 {MSERR_MUXER_FAILED, "stream avmuxer failed"},
68 {MSERR_DEMUXER_FAILED, "stream demuxer or parser failed"},
69 {MSERR_OPEN_FILE_FAILED, "open file failed"},
70 {MSERR_FILE_ACCESS_FAILED, "read or write file failed"},
71 {MSERR_START_FAILED, "audio or video start failed"},
72 {MSERR_PAUSE_FAILED, "audio or video pause failed"},
73 {MSERR_STOP_FAILED, "audio or video stop failed"},
74 {MSERR_SEEK_FAILED, "audio or video seek failed"},
75 {MSERR_NETWORK_TIMEOUT, "network timeout"},
76 {MSERR_NOT_FIND_CONTAINER, "not find a demuxer"},
77 {MSERR_EXTEND_START, "extend start error code"},
78 {MSERR_AUD_INTERRUPT, "audio interrupted"},
79 {MSERR_USER_NO_PERMISSION, "user no permission"},
80 {MSERR_DATA_SOURCE_ERROR_UNKNOWN, "media data source error unknow"},
81 {MSERR_DATA_SOURCE_IO_ERROR, "media data source IO failed"},
82 {MSERR_DRM_VERIFICATION_FAILED, "DRM verification failed"},
83 {MSERR_UNSUPPORT_WATER_MARK, "unsupported water mark"},
84 {MSERR_DEMUXER_BUFFER_NO_MEMORY, "demuxer cache data reached its limit"},
85 {MSERR_IO_CANNOT_FIND_HOST, "IO can not find host"},
86 {MSERR_IO_CONNECTION_TIMEOUT, "IO connection timeout"},
87 {MSERR_IO_NETWORK_ABNORMAL, "IO network abnormal"},
88 {MSERR_IO_NETWORK_UNAVAILABLE, "IO network unavailable"},
89 {MSERR_IO_NO_PERMISSION, "IO no permission"},
90 {MSERR_IO_NETWORK_ACCESS_DENIED, "IO request denied"},
91 {MSERR_IO_RESOURE_NOT_FOUND, "IO resource not found"},
92 {MSERR_IO_SSL_CLIENT_CERT_NEEDED, "IO SSL client cert needed"},
93 {MSERR_IO_SSL_CONNECT_FAIL, "IO SSL connect fail"},
94 {MSERR_IO_SSL_SERVER_CERT_UNTRUSTED, "IO SSL server cert untrusted"},
95 {MSERR_IO_UNSUPPORTTED_REQUEST, "IO unsupported request"},
96 {MSERR_SEEK_CONTINUOUS_UNSUPPORTED, "seek continonous is unsupported for this source"},
97 {MSERR_SUPER_RESOLUTION_UNSUPPORTED, "super resolution not supported"},
98 {MSERR_SUPER_RESOLUTION_NOT_ENABLED, "super resolution not enabled"},
99 };
100
101 const std::map<MediaServiceErrCode, MediaServiceExtErrCode> MSERRCODE_TO_EXTERRORCODE = {
102 {MSERR_OK, MSERR_EXT_OK},
103 {MSERR_NO_MEMORY, MSERR_EXT_NO_MEMORY},
104 {MSERR_DEMUXER_BUFFER_NO_MEMORY, MSERR_EXT_IO},
105 {MSERR_INVALID_OPERATION, MSERR_EXT_OPERATE_NOT_PERMIT},
106 {MSERR_INVALID_VAL, MSERR_EXT_INVALID_VAL},
107 {MSERR_UNKNOWN, MSERR_EXT_UNKNOWN},
108 {MSERR_SERVICE_DIED, MSERR_EXT_SERVICE_DIED},
109 {MSERR_CREATE_REC_ENGINE_FAILED, MSERR_EXT_UNKNOWN},
110 {MSERR_CREATE_PLAYER_ENGINE_FAILED, MSERR_EXT_UNKNOWN},
111 {MSERR_INVALID_STATE, MSERR_EXT_INVALID_STATE},
112 {MSERR_UNSUPPORT, MSERR_EXT_UNSUPPORT},
113 {MSERR_UNSUPPORT_AUD_SRC_TYPE, MSERR_EXT_UNSUPPORT},
114 {MSERR_UNSUPPORT_AUD_SAMPLE_RATE, MSERR_EXT_UNSUPPORT},
115 {MSERR_UNSUPPORT_AUD_CHANNEL_NUM, MSERR_EXT_UNSUPPORT},
116 {MSERR_UNSUPPORT_AUD_ENC_TYPE, MSERR_EXT_UNSUPPORT},
117 {MSERR_UNSUPPORT_AUD_PARAMS, MSERR_EXT_UNSUPPORT},
118 {MSERR_UNSUPPORT_VID_SRC_TYPE, MSERR_EXT_UNSUPPORT},
119 {MSERR_UNSUPPORT_VID_ENC_TYPE, MSERR_EXT_UNSUPPORT},
120 {MSERR_UNSUPPORT_VID_PARAMS, MSERR_EXT_UNSUPPORT},
121 {MSERR_UNSUPPORT_CONTAINER_TYPE, MSERR_EXT_UNSUPPORT},
122 {MSERR_UNSUPPORT_PROTOCOL_TYPE, MSERR_EXT_UNSUPPORT},
123 {MSERR_UNSUPPORT_VID_DEC_TYPE, MSERR_EXT_UNSUPPORT},
124 {MSERR_UNSUPPORT_AUD_DEC_TYPE, MSERR_EXT_UNSUPPORT},
125 {MSERR_UNSUPPORT_STREAM, MSERR_EXT_UNSUPPORT},
126 {MSERR_UNSUPPORT_FILE, MSERR_EXT_UNSUPPORT},
127 {MSERR_UNSUPPORT_SOURCE, MSERR_EXT_UNSUPPORT},
128 {MSERR_AUD_RENDER_FAILED, MSERR_EXT_UNSUPPORT},
129 {MSERR_AUD_ENC_FAILED, MSERR_EXT_UNKNOWN},
130 {MSERR_VID_ENC_FAILED, MSERR_EXT_UNKNOWN},
131 {MSERR_AUD_DEC_FAILED, MSERR_EXT_UNKNOWN},
132 {MSERR_VID_DEC_FAILED, MSERR_EXT_UNKNOWN},
133 {MSERR_MUXER_FAILED, MSERR_EXT_UNKNOWN},
134 {MSERR_DEMUXER_FAILED, MSERR_EXT_UNKNOWN},
135 {MSERR_OPEN_FILE_FAILED, MSERR_EXT_UNKNOWN},
136 {MSERR_FILE_ACCESS_FAILED, MSERR_EXT_UNKNOWN},
137 {MSERR_START_FAILED, MSERR_EXT_UNKNOWN},
138 {MSERR_PAUSE_FAILED, MSERR_EXT_UNKNOWN},
139 {MSERR_STOP_FAILED, MSERR_EXT_UNKNOWN},
140 {MSERR_SEEK_FAILED, MSERR_EXT_UNKNOWN},
141 {MSERR_NETWORK_TIMEOUT, MSERR_EXT_TIMEOUT},
142 {MSERR_NOT_FIND_CONTAINER, MSERR_EXT_UNSUPPORT},
143 {MSERR_EXTEND_START, MSERR_EXT_EXTEND_START},
144 {MSERR_IO_CANNOT_FIND_HOST, MSERR_EXT_IO},
145 {MSERR_IO_CONNECTION_TIMEOUT, MSERR_EXT_IO},
146 {MSERR_IO_NETWORK_ABNORMAL, MSERR_EXT_IO},
147 {MSERR_IO_NETWORK_UNAVAILABLE, MSERR_EXT_IO},
148 {MSERR_IO_NO_PERMISSION, MSERR_EXT_IO},
149 {MSERR_IO_NETWORK_ACCESS_DENIED, MSERR_EXT_IO},
150 {MSERR_IO_RESOURE_NOT_FOUND, MSERR_EXT_IO},
151 {MSERR_IO_SSL_CLIENT_CERT_NEEDED, MSERR_EXT_IO},
152 {MSERR_IO_SSL_CONNECT_FAIL, MSERR_EXT_IO},
153 {MSERR_IO_SSL_SERVER_CERT_UNTRUSTED, MSERR_EXT_IO},
154 {MSERR_IO_UNSUPPORTTED_REQUEST, MSERR_EXT_IO},
155 {MSERR_SUPER_RESOLUTION_UNSUPPORTED, MSERR_EXT_UNSUPPORT},
156 {MSERR_SUPER_RESOLUTION_NOT_ENABLED, MSERR_EXT_UNKNOWN},
157 };
158
159 const std::map<MediaServiceExtErrCode, std::string> MSEXTERRCODE_INFOS = {
160 {MSERR_EXT_OK, "success"},
161 {MSERR_EXT_NO_MEMORY, "no memory"},
162 {MSERR_EXT_OPERATE_NOT_PERMIT, "operation not be permitted"},
163 {MSERR_EXT_INVALID_VAL, "invalid argument"},
164 {MSERR_EXT_IO, "IO error"},
165 {MSERR_EXT_TIMEOUT, "network timeout"},
166 {MSERR_EXT_UNKNOWN, "unkown error"},
167 {MSERR_EXT_SERVICE_DIED, "media service died"},
168 {MSERR_EXT_INVALID_STATE, "the state is not support this operation"},
169 {MSERR_EXT_UNSUPPORT, "unsupport interface"},
170 {MSERR_EXT_EXTEND_START, "extend err start"},
171 };
172
173 const std::map<MediaServiceErrCode, MediaServiceExtErrCodeAPI9> MSERRCODE_TO_EXTERRORCODEAPI9 = {
174 {MSERR_OK, MSERR_EXT_API9_OK},
175 {MSERR_NO_MEMORY, MSERR_EXT_API9_NO_MEMORY},
176 {MSERR_INVALID_OPERATION, MSERR_EXT_API9_OPERATE_NOT_PERMIT},
177 {MSERR_INVALID_VAL, MSERR_EXT_API9_INVALID_PARAMETER},
178 {MSERR_MANDATORY_PARAMETER_UNSPECIFIED, MSERR_EXT_API9_INVALID_PARAMETER},
179 {MSERR_INCORRECT_PARAMETER_TYPE, MSERR_EXT_API9_INVALID_PARAMETER},
180 {MSERR_PARAMETER_VERIFICATION_FAILED, MSERR_EXT_API9_INVALID_PARAMETER},
181 {MSERR_SERVICE_DIED, MSERR_EXT_API9_SERVICE_DIED},
182 {MSERR_CREATE_REC_ENGINE_FAILED, MSERR_EXT_API9_NO_MEMORY},
183 {MSERR_CREATE_PLAYER_ENGINE_FAILED, MSERR_EXT_API9_NO_MEMORY},
184 {MSERR_INVALID_STATE, MSERR_EXT_API9_OPERATE_NOT_PERMIT},
185 {MSERR_UNSUPPORT, MSERR_EXT_API9_UNSUPPORT_FORMAT},
186 {MSERR_UNSUPPORT_AUD_SRC_TYPE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
187 {MSERR_UNSUPPORT_AUD_SAMPLE_RATE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
188 {MSERR_UNSUPPORT_AUD_CHANNEL_NUM, MSERR_EXT_API9_UNSUPPORT_FORMAT},
189 {MSERR_UNSUPPORT_AUD_ENC_TYPE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
190 {MSERR_UNSUPPORT_AUD_PARAMS, MSERR_EXT_API9_UNSUPPORT_FORMAT},
191 {MSERR_UNSUPPORT_VID_SRC_TYPE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
192 {MSERR_UNSUPPORT_VID_ENC_TYPE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
193 {MSERR_UNSUPPORT_VID_PARAMS, MSERR_EXT_API9_UNSUPPORT_FORMAT},
194 {MSERR_UNSUPPORT_CONTAINER_TYPE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
195 {MSERR_UNSUPPORT_PROTOCOL_TYPE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
196 {MSERR_UNSUPPORT_VID_DEC_TYPE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
197 {MSERR_UNSUPPORT_AUD_DEC_TYPE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
198 {MSERR_UNSUPPORT_STREAM, MSERR_EXT_API9_UNSUPPORT_FORMAT},
199 {MSERR_UNSUPPORT_FILE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
200 {MSERR_UNSUPPORT_SOURCE, MSERR_EXT_API9_UNSUPPORT_FORMAT},
201 {MSERR_AUD_RENDER_FAILED, MSERR_EXT_API9_IO},
202 {MSERR_AUD_ENC_FAILED, MSERR_EXT_API9_IO},
203 {MSERR_VID_ENC_FAILED, MSERR_EXT_API9_IO},
204 {MSERR_AUD_DEC_FAILED, MSERR_EXT_API9_IO},
205 {MSERR_VID_DEC_FAILED, MSERR_EXT_API9_IO},
206 {MSERR_MUXER_FAILED, MSERR_EXT_API9_UNSUPPORT_FORMAT},
207 {MSERR_DEMUXER_FAILED, MSERR_EXT_API9_UNSUPPORT_FORMAT},
208 {MSERR_OPEN_FILE_FAILED, MSERR_EXT_API9_IO},
209 {MSERR_FILE_ACCESS_FAILED, MSERR_EXT_API9_IO},
210 {MSERR_START_FAILED, MSERR_EXT_API9_OPERATE_NOT_PERMIT},
211 {MSERR_PAUSE_FAILED, MSERR_EXT_API9_OPERATE_NOT_PERMIT},
212 {MSERR_STOP_FAILED, MSERR_EXT_API9_OPERATE_NOT_PERMIT},
213 {MSERR_SEEK_FAILED, MSERR_EXT_API9_OPERATE_NOT_PERMIT},
214 {MSERR_DRM_VERIFICATION_FAILED, MSERR_EXT_API9_OPERATE_NOT_PERMIT},
215 {MSERR_NETWORK_TIMEOUT, MSERR_EXT_API9_TIMEOUT},
216 {MSERR_NOT_FIND_CONTAINER, MSERR_EXT_API9_UNSUPPORT_FORMAT},
217 {MSERR_UNKNOWN, MSERR_EXT_API9_IO},
218 {MSERR_DATA_SOURCE_IO_ERROR, MSERR_EXT_API9_IO},
219 {MSERR_DATA_SOURCE_ERROR_UNKNOWN, MSERR_EXT_API9_IO},
220 {MSERR_AUD_INTERRUPT, MSERR_EXT_API9_AUDIO_INTERRUPTED},
221 {MSERR_USER_NO_PERMISSION, MSERR_EXT_API9_NO_PERMISSION},
222 {MSERR_UNSUPPORT_WATER_MARK, MSERR_EXT_API9_UNSUPPORT_CAPABILITY},
223 {MSERR_DEMUXER_BUFFER_NO_MEMORY, MSERR_EXT_API9_IO},
224 {MSERR_IO_CANNOT_FIND_HOST, MSERR_EXT_API14_IO_CANNOT_FIND_HOST},
225 {MSERR_IO_CONNECTION_TIMEOUT, MSERR_EXT_API14_IO_CONNECTION_TIMEOUT},
226 {MSERR_IO_NETWORK_ABNORMAL, MSERR_EXT_API14_IO_NETWORK_ABNORMAL},
227 {MSERR_IO_NETWORK_UNAVAILABLE, MSERR_EXT_API14_IO_NETWORK_UNAVAILABLE},
228 {MSERR_IO_NO_PERMISSION, MSERR_EXT_API14_IO_NO_PERMISSION},
229 {MSERR_IO_NETWORK_ACCESS_DENIED, MSERR_EXT_API14_IO_NETWORK_ACCESS_DENIED},
230 {MSERR_IO_RESOURE_NOT_FOUND, MSERR_EXT_API14_IO_RESOURE_NOT_FOUND},
231 {MSERR_IO_SSL_CLIENT_CERT_NEEDED, MSERR_EXT_API14_IO_SSL_CLIENT_CERT_NEEDED},
232 {MSERR_IO_SSL_CONNECT_FAIL, MSERR_EXT_API14_IO_SSL_CONNECT_FAIL},
233 {MSERR_IO_SSL_SERVER_CERT_UNTRUSTED, MSERR_EXT_API14_IO_SSL_SERVER_CERT_UNTRUSTED},
234 {MSERR_IO_UNSUPPORTTED_REQUEST, MSERR_EXT_API14_IO_UNSUPPORTTED_REQUEST},
235 {MSERR_SEEK_CONTINUOUS_UNSUPPORTED, MSERR_EXT_API16_SEEK_CONTINUOUS_UNSUPPORTED},
236 {MSERR_SUPER_RESOLUTION_UNSUPPORTED, MSERR_EXT_API16_SUPER_RESOLUTION_UNSUPPORTED},
237 {MSERR_SUPER_RESOLUTION_NOT_ENABLED, MSERR_EXT_API16_SUPER_RESOLUTION_NOT_ENABLED},
238 };
239
240 const std::map<MediaServiceExtErrCodeAPI9, std::string> MSEXTERRCODE_API9_INFOS = {
241 {MSERR_EXT_API9_OK, "Success: "},
242 {MSERR_EXT_API9_NO_PERMISSION, "No Permission: "},
243 {MSERR_EXT_API9_PERMISSION_DENIED, "Permission Denied"},
244 {MSERR_EXT_API9_INVALID_PARAMETER, "Invalid Parameter: "},
245 {MSERR_EXT_API9_UNSUPPORT_CAPABILITY, "Unsupport Capability: "},
246 {MSERR_EXT_API9_NO_MEMORY, "No Memory: "},
247 {MSERR_EXT_API9_OPERATE_NOT_PERMIT, "Operate Not Permit: "},
248 {MSERR_EXT_API9_IO, "IO Error: "},
249 {MSERR_EXT_API9_TIMEOUT, "Network Timeout: "},
250 {MSERR_EXT_API9_SERVICE_DIED, "Service Died: "},
251 {MSERR_EXT_API9_UNSUPPORT_FORMAT, "Unsupported Format: "},
252 {MSERR_EXT_API9_AUDIO_INTERRUPTED, "Audio Interruped: "},
253 {MSERR_EXT_API14_IO_CANNOT_FIND_HOST, "IO Cannot Find Host: "},
254 {MSERR_EXT_API14_IO_CONNECTION_TIMEOUT, "IO Connection Timeout: "},
255 {MSERR_EXT_API14_IO_NETWORK_ABNORMAL, "IO Network Abnormal: "},
256 {MSERR_EXT_API14_IO_NETWORK_UNAVAILABLE, "IO Network Unavailable: "},
257 {MSERR_EXT_API14_IO_NO_PERMISSION, "IO No Permission: "},
258 {MSERR_EXT_API14_IO_NETWORK_ACCESS_DENIED, "IO Request Denied: "},
259 {MSERR_EXT_API14_IO_RESOURE_NOT_FOUND, "IO Resource Not Found: "},
260 {MSERR_EXT_API14_IO_SSL_CLIENT_CERT_NEEDED, "IO SSL Client Cert Needed: "},
261 {MSERR_EXT_API14_IO_SSL_CONNECT_FAIL, "IO SSL Connect Fail: "},
262 {MSERR_EXT_API14_IO_SSL_SERVER_CERT_UNTRUSTED, "IO SSL Server Cert Untrusted: "},
263 {MSERR_EXT_API14_IO_UNSUPPORTTED_REQUEST, "IO Unsupported Request: "},
264 };
265
ErrorMessageOk(const std::string & param1,const std::string & param2)266 std::string ErrorMessageOk(const std::string& param1, const std::string& param2)
267 {
268 (void)param1;
269 (void)param2;
270 return "success";
271 }
272
ErrorMessageNoPermission(const std::string & param1,const std::string & param2)273 std::string ErrorMessageNoPermission(const std::string& param1, const std::string& param2)
274 {
275 std::string message = "Try to do " + param1 + " failed. User should request permission " + param2 +" first.";
276 return message;
277 }
278
ErrorMessageInvalidParameter(const std::string & param1,const std::string & param2)279 std::string ErrorMessageInvalidParameter(const std::string& param1, const std::string& param2)
280 {
281 (void)param2;
282 std::string message = "The Parameter " + param1 + " is invalid. Please check the type and range.";
283 return message;
284 }
285
ErrorMessageUnsupportCapability(const std::string & param1,const std::string & param2)286 std::string ErrorMessageUnsupportCapability(const std::string& param1, const std::string& param2)
287 {
288 (void)param2;
289 std::string message = "Function " + param1 + " can not work correctly due to limited device capability.";
290 return message;
291 }
292
ErrorMessageNoMemory(const std::string & param1,const std::string & param2)293 std::string ErrorMessageNoMemory(const std::string& param1, const std::string& param2)
294 {
295 (void)param2;
296 std::string message = "Create " + param1 + " failed due to system memory.";
297 return message;
298 }
299
ErrorMessageOperateNotPermit(const std::string & param1,const std::string & param2)300 std::string ErrorMessageOperateNotPermit(const std::string& param1, const std::string& param2)
301 {
302 (void)param2;
303 std::string message = "The operate " + param1 + " failed due to not permit in current state.";
304 return message;
305 }
306
ErrorMessageIO(const std::string & param1,const std::string & param2)307 std::string ErrorMessageIO(const std::string& param1, const std::string& param2)
308 {
309 (void)param2;
310 std::string message = "IO error happened due to " + param1 + ".";
311 return message;
312 }
313
ErrorMessageTimeout(const std::string & param1,const std::string & param2)314 std::string ErrorMessageTimeout(const std::string& param1, const std::string& param2)
315 {
316 std::string message = "Timeout happend when " + param1 + " due to " + param2 + ".";
317 return message;
318 }
319
ErrorMessageServiceDied(const std::string & param1,const std::string & param2)320 std::string ErrorMessageServiceDied(const std::string& param1, const std::string& param2)
321 {
322 (void)param1;
323 (void)param2;
324 std::string message = "Media Serviced Died.";
325 return message;
326 }
327
ErrorMessageUnsupportFormat(const std::string & param1,const std::string & param2)328 std::string ErrorMessageUnsupportFormat(const std::string& param1, const std::string& param2)
329 {
330 (void)param2;
331 std::string message = "The format " + param1 + " is not support.";
332 return message;
333 }
334
ErrorMessageAudioInterruped(const std::string & param1,const std::string & param2)335 std::string ErrorMessageAudioInterruped(const std::string & param1, const std::string& param2)
336 {
337 (void)param1;
338 (void)param2;
339 std::string message = "Audio Interrupted by other process.";
340 return message;
341 }
342
343 const std::map<MediaServiceExtErrCodeAPI9, ErrorMessageFunc> MSEXTERRAPI9CODE_FUNCS = {
344 {MSERR_EXT_API9_OK, &ErrorMessageOk},
345 {MSERR_EXT_API9_NO_PERMISSION, &ErrorMessageNoPermission},
346 {MSERR_EXT_API9_INVALID_PARAMETER, &ErrorMessageInvalidParameter},
347 {MSERR_EXT_API9_UNSUPPORT_CAPABILITY, &ErrorMessageUnsupportCapability},
348 {MSERR_EXT_API9_NO_MEMORY, &ErrorMessageNoMemory},
349 {MSERR_EXT_API9_OPERATE_NOT_PERMIT, &ErrorMessageOperateNotPermit},
350 {MSERR_EXT_API9_IO, &ErrorMessageIO},
351 {MSERR_EXT_API9_TIMEOUT, &ErrorMessageTimeout},
352 {MSERR_EXT_API9_SERVICE_DIED, &ErrorMessageServiceDied},
353 {MSERR_EXT_API9_UNSUPPORT_FORMAT, &ErrorMessageUnsupportFormat},
354 {MSERR_EXT_API9_AUDIO_INTERRUPTED, &ErrorMessageAudioInterruped},
355 };
356 }
357
SetUpTestCase(void)358 void PlayerServerUnitTest::SetUpTestCase(void)
359 {
360 }
361
TearDownTestCase(void)362 void PlayerServerUnitTest::TearDownTestCase(void)
363 {
364 std::cout << "sleep one second to protect PlayerEngine safely exit." << endl;
365 sleep(1); //let PlayEngine safe exit.
366 }
367
SetUp(void)368 void PlayerServerUnitTest::SetUp(void)
369 {
370 callback_ = std::make_shared<PlayerCallbackTest>();
371 ASSERT_NE(nullptr, callback_);
372 player_ = std::make_shared<PlayerServerMock>(callback_);
373 ASSERT_NE(nullptr, player_);
374 EXPECT_TRUE(player_->CreatePlayer());
375 EXPECT_EQ(MSERR_OK, player_->SetPlayerCallback(callback_));
376 }
377
TearDown(void)378 void PlayerServerUnitTest::TearDown(void)
379 {
380 if (player_ != nullptr) {
381 player_->Release();
382 }
383 }
384
PlayFunTest(const std::string & protocol)385 void PlayerServerUnitTest::PlayFunTest(const std::string &protocol)
386 {
387 int32_t duration = 0;
388 if (player_ != nullptr) {
389 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
390 EXPECT_EQ(MSERR_OK, player_->Play());
391 EXPECT_TRUE(player_->IsPlaying());
392 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
393 EXPECT_EQ(MSERR_OK, player_->Pause());
394 int32_t time;
395 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
396 std::vector<Format> videoTrack;
397 std::vector<Format> audioTrack;
398 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
399 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
400 PlaybackRateMode mode;
401 player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X);
402 player_->GetPlaybackSpeed(mode);
403 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
404 EXPECT_EQ(true, player_->IsLooping());
405 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_NEXT_SYNC));
406 EXPECT_EQ(MSERR_OK, player_->Play());
407 sleep(PLAYING_TIME_2_SEC);
408 if (protocol == PlayerTestParam::HLS_PLAY) {
409 EXPECT_EQ(MSERR_OK, player_->SelectBitRate(200000)); // 200000:bitrate
410 sleep(PLAYING_TIME_2_SEC);
411 }
412 EXPECT_EQ(MSERR_OK, player_->SetLooping(false));
413 EXPECT_EQ(false, player_->IsLooping());
414 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
415 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
416 EXPECT_EQ(MSERR_OK, player_->Stop());
417 EXPECT_EQ(MSERR_OK, player_->Reset());
418 }
419 }
420
GetSetParaFunTest()421 void PlayerServerUnitTest::GetSetParaFunTest()
422 {
423 if (player_ != nullptr) {
424 int32_t duration = 0;
425 int32_t time = 0;
426 PlaybackRateMode mode;
427 std::vector<Format> videoTrack;
428 std::vector<Format> audioTrack;
429 player_->GetVideoTrackInfo(videoTrack);
430 player_->GetAudioTrackInfo(audioTrack);
431 player_->GetCurrentTime(time);
432 player_->GetDuration(duration);
433 player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X);
434 player_->GetPlaybackSpeed(mode);
435 player_->SetLooping(true);
436 player_->IsLooping();
437 player_->SetVolume(1, 1);
438 }
439 }
440
MediaServiceErrCodeTest(MediaServiceErrCode code)441 void PlayerServerUnitTest::MediaServiceErrCodeTest(MediaServiceErrCode code)
442 {
443 if (MSERRCODE_INFOS.count(code) != 0) {
444 EXPECT_EQ(MSERRCODE_INFOS.at(code), MSErrorToString(code));
445 } else if (code > MSERR_EXTEND_START) {
446 EXPECT_EQ("extend error:" + std::to_string(static_cast<int32_t>(code - MSERR_EXTEND_START)),
447 MSErrorToString(code));
448 } else {
449 EXPECT_EQ("invalid error code:" + std::to_string(static_cast<int32_t>(code)), MSErrorToString(code));
450 }
451
452 if (MSERRCODE_INFOS.count(code) != 0 && MSERRCODE_TO_EXTERRORCODE.count(code) != 0 &&
453 MSEXTERRCODE_INFOS.count(MSERRCODE_TO_EXTERRORCODE.at(code)) != 0) {
454 EXPECT_EQ(MSEXTERRCODE_INFOS.at(MSERRCODE_TO_EXTERRORCODE.at(code)), MSErrorToExtErrorString(code));
455 } else {
456 EXPECT_EQ("unkown error", MSErrorToExtErrorString(code));
457 }
458
459 if (MSERRCODE_INFOS.count(code) != 0 && MSERRCODE_TO_EXTERRORCODE.count(code) != 0) {
460 EXPECT_EQ(MSERRCODE_TO_EXTERRORCODE.at(code), MSErrorToExtError(code));
461 } else {
462 EXPECT_EQ(MSERR_EXT_UNKNOWN, MSErrorToExtError(code));
463 }
464
465 if (MSERRCODE_INFOS.count(code) != 0 && MSERRCODE_TO_EXTERRORCODEAPI9.count(code) != 0 &&
466 MSEXTERRAPI9CODE_FUNCS.count(MSERRCODE_TO_EXTERRORCODEAPI9.at(code)) != 0) {
467 EXPECT_EQ(MSEXTERRAPI9CODE_FUNCS.at(MSERRCODE_TO_EXTERRORCODEAPI9.at(code))("test1", "test2"),
468 MSErrorToExtErrorAPI9String(code, "test1", "test2"));
469 } else {
470 EXPECT_EQ("unkown error", MSErrorToExtErrorAPI9String(code, "test1", "test2"));
471 }
472
473 if (MSERRCODE_INFOS.count(code) != 0 && MSERRCODE_TO_EXTERRORCODEAPI9.count(code) != 0) {
474 EXPECT_EQ(MSERRCODE_TO_EXTERRORCODEAPI9.at(code), MSErrorToExtErrorAPI9(code));
475 } else {
476 EXPECT_EQ(MSERR_EXT_API9_IO, MSErrorToExtErrorAPI9(code));
477 }
478 }
479
MediaServiceExtErrCodeAPI9Test(MediaServiceExtErrCodeAPI9 code)480 void PlayerServerUnitTest::MediaServiceExtErrCodeAPI9Test(MediaServiceExtErrCodeAPI9 code)
481 {
482 if (MSEXTERRAPI9CODE_FUNCS.count(code) != 0) {
483 EXPECT_EQ(MSEXTERRAPI9CODE_FUNCS.at(code)("test1", "test2"),
484 MSExtErrorAPI9ToString(code, "test1", "test2"));
485 } else {
486 EXPECT_EQ("invalid error code:" + std::to_string(code), MSExtErrorAPI9ToString(code, "test1", "test2"));
487 }
488
489 if (MSEXTERRCODE_API9_INFOS.count(code) != 0) {
490 EXPECT_EQ(MSEXTERRCODE_API9_INFOS.at(code), MSExtAVErrorToString(code));
491 } else {
492 EXPECT_EQ("invalid error code:", MSExtAVErrorToString(code));
493 }
494 }
495
496 /**
497 * @tc.name : Test Player SetMediaSource API
498 * @tc.number: Player_SetMediaSource_001
499 * @tc.desc : Test Player SetMediaSource interface
500 */
501 HWTEST_F(PlayerServerUnitTest, Player_SetMediaSource_001, TestSize.Level0)
502 {
503 std::map<std::string, std::string> header = {
504 {"key1", "value1"},
505 {"key2", "value2"},
506 };
507 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
508 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>(VIDEO_FILE1, header);
509 int32_t ret = player_->SetMediaSource(mediaSource, strategy);
510 EXPECT_EQ(MSERR_OK, ret);
511 }
512
513 /**
514 * @tc.name : Test Player SetMediaSource API
515 * @tc.number: Player_SetMediaSource_002
516 * @tc.desc : Test Player SetMediaSource interface
517 */
518 HWTEST_F(PlayerServerUnitTest, Player_SetMediaSource_002, TestSize.Level0)
519 {
520 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
521 int32_t ret = player_->SetMediaSource(nullptr, strategy);
522 EXPECT_NE(MSERR_OK, ret);
523 }
524
525 /**
526 * @tc.name : Test Player SetMediaSource API
527 * @tc.number: Player_SetMediaSource_003
528 * @tc.desc : Test Player SetMediaSource interface
529 */
530 HWTEST_F(PlayerServerUnitTest, Player_SetMediaSource_003, TestSize.Level0)
531 {
532 std::map<std::string, std::string> header = {
533 {"key1", "value1"},
534 {"key2", "value2"},
535 };
536 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
537 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>(MEDIA_ROOT + "error.mp4", header);
538 int32_t ret = player_->SetMediaSource(mediaSource, strategy);
539 EXPECT_EQ(MSERR_OK, ret);
540 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
541 }
542
543 /**
544 * @tc.name : Test Player SetMediaSource API
545 * @tc.number: Player_SetMediaSource_004
546 * @tc.desc : Test Player SetMediaSource interface
547 */
548 HWTEST_F(PlayerServerUnitTest, Player_SetMediaSource_004, TestSize.Level0)
549 {
550 std::map<std::string, std::string> header = {
551 {"key1", "value1"},
552 {"key2", "value2"},
553 };
554 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
555 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>(MEDIA_ROOT + "error.mp4", header);
556 int32_t ret = player_->SetMediaSource(mediaSource, strategy);
557 EXPECT_EQ(MSERR_OK, ret);
558 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
559 EXPECT_NE(MSERR_OK, player_->Prepare());
560 }
561
562 /**
563 * @tc.name : Test Player SetMediaSource API
564 * @tc.number: Player_SetMediaSource_005
565 * @tc.desc : Test Player SetMediaSource interface
566 */
567 HWTEST_F(PlayerServerUnitTest, Player_SetMediaSource_005, TestSize.Level0)
568 {
569 std::map<std::string, std::string> header = {
570 {"key1", "value1"},
571 {"key2", "value2"},
572 };
573 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
574 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>(MEDIA_ROOT + "error.mp4", header);
575 int32_t ret = player_->SetMediaSource(mediaSource, strategy);
576 EXPECT_EQ(MSERR_OK, ret);
577 EXPECT_NE(MSERR_OK, player_->Play());
578 EXPECT_EQ(false, player_->IsPlaying());
579 }
580
581 /**
582 * @tc.name : Test Player SetMediaSource API
583 * @tc.number: Player_SetMediaSource_006
584 * @tc.desc : Test Player SetMediaSource interface
585 */
586 HWTEST_F(PlayerServerUnitTest, Player_SetMediaSource_006, TestSize.Level0)
587 {
588 std::map<std::string, std::string> header = {
589 };
590 struct AVPlayStrategy strategy = {1080, 920, 10000, false};
591 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>(MEDIA_ROOT + "error.mp4", header);
592 int32_t ret = player_->SetMediaSource(mediaSource, strategy);
593 EXPECT_EQ(MSERR_OK, ret);
594 EXPECT_NE(MSERR_OK, player_->Play());
595 EXPECT_EQ(false, player_->IsPlaying());
596 }
597
598 /**
599 * @tc.name : Test Player StrToInt API
600 * @tc.number: Player_StrToInt_001
601 * @tc.desc : Test Player StrToInt interface
602 */
603 HWTEST_F(PlayerServerUnitTest, Player_StrToInt_001, TestSize.Level0)
604 {
605 std::string str = "123";
606 int32_t fd = -1;
607 int32_t num = 123;
608 auto res = StrToInt(str, fd);
609 EXPECT_EQ(res, true);
610 EXPECT_EQ(fd, num);
611 }
612
613 /**
614 * @tc.name : Test Player StrToInt API
615 * @tc.number: Player_StrToInt_002
616 * @tc.desc : Test Player StrToInt interface
617 */
618 HWTEST_F(PlayerServerUnitTest, Player_StrToInt_002, TestSize.Level0)
619 {
620 std::string str = "12a3";
621 int32_t fd = -1;
622 auto res = StrToInt(str, fd);
623 EXPECT_EQ(res, false);
624 }
625
626 /**
627 * @tc.name : Test Player StrToInt API
628 * @tc.number: Player_StrToInt_003
629 * @tc.desc : Test Player StrToInt interface
630 */
631 HWTEST_F(PlayerServerUnitTest, Player_StrToInt_003, TestSize.Level0)
632 {
633 std::string str = "9223372036854775809";
634 int32_t fd = -1;
635 auto res = StrToInt(str, fd);
636 EXPECT_EQ(res, false);
637 }
638
639 /**
640 * @tc.name : Test Player SetSource API
641 * @tc.number: Player_SetSource_001
642 * @tc.desc : Test Player SetSource interface
643 */
644 HWTEST_F(PlayerServerUnitTest, Player_SetSource_001, TestSize.Level0)
645 {
646 int32_t ret = player_->SetSource(VIDEO_FILE1);
647 EXPECT_EQ(MSERR_OK, ret);
648 }
649
650 /**
651 * @tc.name : Test Player SetSource API
652 * @tc.number: Player_SetSource_002
653 * @tc.desc : Test Player SetSource interface with invalid path
654 */
655 HWTEST_F(PlayerServerUnitTest, Player_SetSource_002, TestSize.Level1)
656 {
657 int32_t ret = player_->SetSource(MEDIA_ROOT + "kong.mp4");
658 EXPECT_NE(MSERR_OK, ret);
659 }
660
661 /**
662 * @tc.name : Test Player SetSource API
663 * @tc.number: Player_SetSource_003
664 * @tc.desc : Test Player SetSource interface with wrong mp3
665 */
666 HWTEST_F(PlayerServerUnitTest, Player_SetSource_003, TestSize.Level2)
667 {
668 system("param set sys.media.player.buffering.enable TRUE");
669 PlaybackRateMode mode;
670 int32_t time = 0;
671 int32_t duration = 0;
672 std::vector<Format> videoTrack;
673 std::vector<Format> audioTrack;
674 int32_t ret = player_->SetSource(MEDIA_ROOT + "1kb.mp3");
675 EXPECT_EQ(MSERR_OK, ret);
676 sptr<Surface> videoSurface = player_->GetVideoSurface();
677 ASSERT_NE(nullptr, videoSurface);
678 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
679 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
680 EXPECT_NE(MSERR_OK, player_->Prepare());
681 Format format;
682 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE,
683 static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT));
684 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
685 EXPECT_NE(MSERR_OK, player_->SetVolume(1, 1));
686 EXPECT_NE(MSERR_OK, player_->Play());
687 EXPECT_EQ(false, player_->IsPlaying());
688 EXPECT_NE(MSERR_OK, player_->Pause());
689 EXPECT_NE(MSERR_OK, player_->Seek(0, SEEK_CLOSEST));
690 EXPECT_NE(MSERR_OK, player_->SetLooping(true));
691 EXPECT_EQ(false, player_->IsLooping());
692 EXPECT_NE(MSERR_OK, player_->SetVolume(1, 1));
693 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
694 EXPECT_NE(MSERR_OK, player_->GetPlaybackSpeed(mode));
695 EXPECT_NE(MSERR_OK, player_->GetCurrentTime(time));
696 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
697 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
698 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
699 EXPECT_NE(480, player_->GetVideoHeight());
700 EXPECT_NE(720, player_->GetVideoWidth());
701 EXPECT_NE(MSERR_OK, player_->Stop());
702 EXPECT_EQ(MSERR_OK, player_->Reset());
703 system("param set sys.media.player.buffering.enable FALSE");
704 }
705
706 /**
707 * @tc.name : Test Player SetSource API
708 * @tc.number: Player_SetSource_004
709 * @tc.desc : Test Player SetSource interface with txt
710 */
711 HWTEST_F(PlayerServerUnitTest, Player_SetSource_004, TestSize.Level2)
712 {
713 int32_t ret = player_->SetSource(MEDIA_ROOT + "error.mp4");
714 EXPECT_EQ(MSERR_OK, ret);
715 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
716 }
717
718 /**
719 * @tc.name : Test Player SetSource
720 * @tc.number: Player_SetSource_005
721 * @tc.desc : Test Player SetSource interface
722 */
723 HWTEST_F(PlayerServerUnitTest, Player_SetSource_005, TestSize.Level3)
724 {
725 PlaybackRateMode mode;
726 int32_t duration = 0;
727 std::vector<Format> videoTrack;
728 std::vector<Format> audioTrack;
729 Format format;
730 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE,
731 static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT));
732 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
733 sptr<Surface> videoSurface = player_->GetVideoSurface();
734 ASSERT_NE(nullptr, videoSurface);
735 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
736 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
737 EXPECT_NE(MSERR_OK, player_->Prepare());
738 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
739 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
740 EXPECT_NE(MSERR_OK, player_->Play());
741 EXPECT_NE(MSERR_OK, player_->Pause());
742 EXPECT_NE(MSERR_OK, player_->Seek(0, SEEK_CLOSEST));
743 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
744 EXPECT_EQ(true, player_->IsLooping());
745 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
746 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
747 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
748 EXPECT_EQ(SPEED_FORWARD_1_00_X, mode);
749 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
750 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
751 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
752 EXPECT_NE(480, player_->GetVideoHeight());
753 EXPECT_NE(720, player_->GetVideoWidth());
754 EXPECT_NE(MSERR_OK, player_->Stop());
755 EXPECT_NE(MSERR_OK, player_->Reset());
756 }
757
758 /**
759 * @tc.name : Test Player SetSource API
760 * @tc.number: Player_SetSource_006
761 * @tc.desc : Test Player SetSource interface
762 */
763 HWTEST_F(PlayerServerUnitTest, Player_SetSource_006, TestSize.Level2)
764 {
765 int32_t ret = player_->SetSource(VIDEO_FILE1);
766 EXPECT_EQ(MSERR_OK, ret);
767 EXPECT_EQ(MSERR_OK, player_->Reset());
768 EXPECT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
769 }
770
771 /**
772 * @tc.name : Test Player SetSource API
773 * @tc.number: Player_SetSource_007
774 * @tc.desc : Test Player SetSource interface
775 */
776 HWTEST_F(PlayerServerUnitTest, Player_SetSource_007, TestSize.Level2)
777 {
778 EXPECT_NE(MSERR_OK, player_->SetSource(INVALID_FILE));
779 }
780
781 /**
782 * @tc.name : Test Player SetSource API
783 * @tc.number: Player_SetSource_009
784 * @tc.desc : Test Player SetSource interface
785 */
786 HWTEST_F(PlayerServerUnitTest, Player_SetSource_009, TestSize.Level2)
787 {
788 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
789 sptr<Surface> videoSurface = player_->GetVideoSurface();
790 ASSERT_NE(nullptr, videoSurface);
791 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
792 int32_t ret = player_->PrepareAsync();
793 ASSERT_NE(MSERR_OK, player_->SetSource(MEDIA_ROOT + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4"));
794 if (ret == MSERR_OK) {
795 PlayFunTest(LOCAL_PLAY);
796 }
797 }
798
799 /**
800 * @tc.name : Test Player SetSource API
801 * @tc.number: Player_SetSource_012
802 * @tc.desc : Test Player SetSource interface
803 */
804 HWTEST_F(PlayerServerUnitTest, Player_SetSource_012, TestSize.Level2)
805 {
806 int32_t ret = player_->SetSource(VIDEO_FILE1, 0, 0);
807 ASSERT_EQ(MSERR_OK, ret);
808 }
809
810 /**
811 * @tc.name : Test Player Local
812 * @tc.number: Player_Local_001
813 * @tc.desc : Test Player Local source
814 */
815 HWTEST_F(PlayerServerUnitTest, Player_Local_001, TestSize.Level2)
816 {
817 int32_t ret = player_->SetSource(MEDIA_ROOT + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4");
818 EXPECT_EQ(MSERR_OK, ret);
819 sptr<Surface> videoSurface = player_->GetVideoSurface();
820 ASSERT_NE(nullptr, videoSurface);
821 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
822 ret = player_->PrepareAsync();
823 if (ret == MSERR_OK) {
824 PlayFunTest(LOCAL_PLAY);
825 }
826 }
827
828 /**
829 * @tc.name : Test Player Local
830 * @tc.number: Player_Local_003
831 * @tc.desc : Test Player Local source
832 */
833 HWTEST_F(PlayerServerUnitTest, Player_Local_003, TestSize.Level2)
834 {
835 int32_t ret = player_->SetSource(MEDIA_ROOT + "H264_MP3.mp4");
836 EXPECT_EQ(MSERR_OK, ret);
837 sptr<Surface> videoSurface = player_->GetVideoSurface();
838 ASSERT_NE(nullptr, videoSurface);
839 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
840 ret = player_->PrepareAsync();
841 if (ret == MSERR_OK) {
842 PlayFunTest(LOCAL_PLAY);
843 }
844 }
845
846 /**
847 * @tc.name : Test Player Local
848 * @tc.number: Player_Local_008
849 * @tc.desc : Test Player Local source
850 */
851 HWTEST_F(PlayerServerUnitTest, Player_Local_008, TestSize.Level2)
852 {
853 int32_t ret = player_->SetSource(MEDIA_ROOT + "out_170_170.mp4");
854 EXPECT_EQ(MSERR_OK, ret);
855 sptr<Surface> videoSurface = player_->GetVideoSurface();
856 ASSERT_NE(nullptr, videoSurface);
857 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
858 ret = player_->PrepareAsync();
859 if (ret == MSERR_OK) {
860 PlayFunTest(LOCAL_PLAY);
861 }
862 }
863
864 /**
865 * @tc.name : Test Player Local
866 * @tc.number: Player_Local_009
867 * @tc.desc : Test Player Local source
868 */
869 HWTEST_F(PlayerServerUnitTest, Player_Local_009, TestSize.Level2)
870 {
871 int32_t ret = player_->SetSource(MEDIA_ROOT + "H264_AAC_320x240.mp4");
872 EXPECT_EQ(MSERR_OK, ret);
873 sptr<Surface> videoSurface = player_->GetVideoSurface();
874 ASSERT_NE(nullptr, videoSurface);
875 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
876 ret = player_->PrepareAsync();
877 if (ret == MSERR_OK) {
878 PlayFunTest(LOCAL_PLAY);
879 }
880 }
881
882 /**
883 * @tc.name : Test Player Local
884 * @tc.number: Player_Local_010
885 * @tc.desc : Test Player Local source
886 */
887 HWTEST_F(PlayerServerUnitTest, Player_Local_010, TestSize.Level2)
888 {
889 int32_t ret = player_->SetSource(MEDIA_ROOT + "aac_44100Hz_143kbs_stereo.aac");
890 EXPECT_EQ(MSERR_OK, ret);
891 sptr<Surface> videoSurface = player_->GetVideoSurface();
892 ASSERT_NE(nullptr, videoSurface);
893 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
894 ret = player_->PrepareAsync();
895 if (ret == MSERR_OK) {
896 PlayFunTest(LOCAL_PLAY);
897 }
898 }
899
900 /**
901 * @tc.name : Test Player Local
902 * @tc.number: Player_Local_011
903 * @tc.desc : Test Player Local source
904 */
905 HWTEST_F(PlayerServerUnitTest, Player_Local_011, TestSize.Level2)
906 {
907 int32_t ret = player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3");
908 EXPECT_EQ(MSERR_OK, ret);
909 sptr<Surface> videoSurface = player_->GetVideoSurface();
910 ASSERT_NE(nullptr, videoSurface);
911 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
912 ret = player_->PrepareAsync();
913 if (ret == MSERR_OK) {
914 PlayFunTest(LOCAL_PLAY);
915 }
916 }
917
918 /**
919 * @tc.name : Test Player Local
920 * @tc.number: Player_Local_013
921 * @tc.desc : Test Player Local source
922 */
923 HWTEST_F(PlayerServerUnitTest, Player_Local_013, TestSize.Level2)
924 {
925 int32_t ret = player_->SetSource(MEDIA_ROOT + "pcm_s16le_48000Hz_768kbs_mono.wav");
926 EXPECT_EQ(MSERR_OK, ret);
927 sptr<Surface> videoSurface = player_->GetVideoSurface();
928 ASSERT_NE(nullptr, videoSurface);
929 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
930 ret = player_->PrepareAsync();
931 if (ret == MSERR_OK) {
932 PlayFunTest(LOCAL_PLAY);
933 }
934 }
935
936 /**
937 * @tc.name : Test Player Local
938 * @tc.number: Player_Local_014
939 * @tc.desc : Test Player Local source
940 */
941 HWTEST_F(PlayerServerUnitTest, Player_Local_014, TestSize.Level2)
942 {
943 int32_t ret = player_->SetSource(MEDIA_ROOT + "vorbis_48000Hz_80kbs_mono.ogg");
944 EXPECT_EQ(MSERR_OK, ret);
945 sptr<Surface> videoSurface = player_->GetVideoSurface();
946 ASSERT_NE(nullptr, videoSurface);
947 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
948 ret = player_->PrepareAsync();
949 if (ret == MSERR_OK) {
950 PlayFunTest(LOCAL_PLAY);
951 }
952 }
953
954 /**
955 * @tc.name : Test Player Local
956 * @tc.number: Player_Local_015
957 * @tc.desc : Test Player Local source
958 */
959 HWTEST_F(PlayerServerUnitTest, Player_Local_015, TestSize.Level2)
960 {
961 int32_t ret = player_->SetSource(MEDIA_ROOT + "aac_48000Hz_70kbs_mono.m4a");
962 EXPECT_EQ(MSERR_OK, ret);
963 sptr<Surface> videoSurface = player_->GetVideoSurface();
964 ASSERT_NE(nullptr, videoSurface);
965 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
966 ret = player_->PrepareAsync();
967 if (ret == MSERR_OK) {
968 PlayFunTest(LOCAL_PLAY);
969 }
970 }
971
972 #ifdef SUBSCRIBE_HISTREAMER_EXT
973 /**
974 * @tc.name : Test Player Local
975 * @tc.number: Player_Local_016
976 * @tc.desc : Test Player Local source
977 */
978 HWTEST_F(PlayerServerUnitTest, Player_Local_016, TestSize.Level2)
979 {
980 int32_t ret = player_->SetSource(MEDIA_ROOT + "H265_AAC.mp4");
981 EXPECT_EQ(MSERR_OK, ret);
982 sptr<Surface> videoSurface = player_->GetVideoSurface();
983 ASSERT_NE(nullptr, videoSurface);
984 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
985 ret = player_->PrepareAsync();
986 if (ret == MSERR_OK) {
987 PlayFunTest(LOCAL_PLAY);
988 }
989 }
990 #endif
991
992 /**
993 * @tc.name : Test Player Local
994 * @tc.number: Player_Local_017
995 * @tc.desc : Test Player Local source
996 */
997 HWTEST_F(PlayerServerUnitTest, Player_Local_017, TestSize.Level2)
998 {
999 int32_t ret = player_->SetSource(MEDIA_ROOT + "amr_nb_8ksr_7400kbr_1ch.amr");
1000 EXPECT_EQ(MSERR_OK, ret);
1001 sptr<Surface> videoSurface = player_->GetVideoSurface();
1002 ASSERT_NE(nullptr, videoSurface);
1003 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1004 ret = player_->PrepareAsync();
1005 if (ret == MSERR_OK) {
1006 PlayFunTest(LOCAL_PLAY);
1007 }
1008 }
1009
1010 /**
1011 * @tc.name : Test Player SetPlayerCallback API
1012 * @tc.number: Player_SetPlayerCallback_001
1013 * @tc.desc : Test Player SetPlayerCallback interface
1014 */
1015 HWTEST_F(PlayerServerUnitTest, Player_SetPlayerCallback_001, TestSize.Level0)
1016 {
1017 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1018 sptr<Surface> videoSurface = player_->GetVideoSurface();
1019 ASSERT_NE(nullptr, videoSurface);
1020 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1021 EXPECT_EQ(MSERR_OK, player_->Prepare());
1022 std::shared_ptr<PlayerCallbackTest> callback = std::make_shared<PlayerCallbackTest>();
1023 ASSERT_NE(nullptr, callback);
1024 EXPECT_NE(MSERR_OK, player_->SetPlayerCallback(callback));
1025 player_->Reset();
1026 player_->SetPlayerCallback(callback);
1027 }
1028
1029 /**
1030 * @tc.name : Test Player Prepare API
1031 * @tc.number: Player_Prepare_001
1032 * @tc.desc : Test Player Prepare interface
1033 */
1034 HWTEST_F(PlayerServerUnitTest, Player_Prepare_001, TestSize.Level0)
1035 {
1036 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1037 sptr<Surface> videoSurface = player_->GetVideoSurface();
1038 ASSERT_NE(nullptr, videoSurface);
1039 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1040 EXPECT_EQ(MSERR_OK, player_->Prepare());
1041 }
1042
1043 /**
1044 * @tc.name : Test Player Prepare API
1045 * @tc.number: Player_Prepare_002
1046 * @tc.desc : Test Player Prepare->Prepare
1047 */
1048 HWTEST_F(PlayerServerUnitTest, Player_Prepare_002, TestSize.Level2)
1049 {
1050 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1051 sptr<Surface> videoSurface = player_->GetVideoSurface();
1052 ASSERT_NE(nullptr, videoSurface);
1053 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1054 EXPECT_EQ(MSERR_OK, player_->Prepare());
1055 EXPECT_NE(MSERR_OK, player_->Prepare());
1056 }
1057
1058 /**
1059 * @tc.name : Test Player Prepare API
1060 * @tc.number: Player_Prepare_003
1061 * @tc.desc : Test Player SetVolume/SetLooping/SetPlaybackSpeed->Prepare
1062 */
1063 HWTEST_F(PlayerServerUnitTest, Player_Prepare_003, TestSize.Level2)
1064 {
1065 PlaybackRateMode rateMode;
1066 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1067 sptr<Surface> renderSurface = player_->GetVideoSurface();
1068 ASSERT_NE(nullptr, renderSurface);
1069 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(renderSurface));
1070 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
1071 bool ret = player_->IsLooping();
1072 EXPECT_EQ(true, ret);
1073 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1074 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1075 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(rateMode));
1076 EXPECT_NE(SPEED_FORWARD_2_00_X, rateMode);
1077 EXPECT_EQ(MSERR_OK, player_->Prepare());
1078 EXPECT_EQ(true, player_->IsLooping());
1079 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(rateMode));
1080 EXPECT_NE(SPEED_FORWARD_2_00_X, rateMode);
1081 }
1082
1083 /**
1084 * @tc.name : Test Player Prepare API
1085 * @tc.number: Player_Prepare_004
1086 * @tc.desc : Test Player Stop->Prepare
1087 */
1088 HWTEST_F(PlayerServerUnitTest, Player_Prepare_004, TestSize.Level2)
1089 {
1090 PlaybackRateMode mode;
1091 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1092 sptr<Surface> videoSurface = player_->GetVideoSurface();
1093 ASSERT_NE(nullptr, videoSurface);
1094 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1095 EXPECT_EQ(MSERR_OK, player_->Prepare());
1096 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
1097 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1098 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1099 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1100 EXPECT_EQ(mode, SPEED_FORWARD_2_00_X);
1101 EXPECT_EQ(MSERR_OK, player_->Stop());
1102 EXPECT_EQ(MSERR_OK, player_->Prepare());
1103 EXPECT_EQ(true, player_->IsLooping());
1104 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1105 EXPECT_EQ(mode, SPEED_FORWARD_2_00_X);
1106 }
1107
1108 /**
1109 * @tc.name : Test Player Prepare API
1110 * @tc.number: Player_Prepare_005
1111 * @tc.desc : Test Player Play->Prepare
1112 */
1113 HWTEST_F(PlayerServerUnitTest, Player_Prepare_005, TestSize.Level2)
1114 {
1115 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1116 sptr<Surface> videoSurface = player_->GetVideoSurface();
1117 ASSERT_NE(nullptr, videoSurface);
1118 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1119 EXPECT_EQ(MSERR_OK, player_->Prepare());
1120 EXPECT_EQ(MSERR_OK, player_->Play());
1121 EXPECT_NE(MSERR_OK, player_->Prepare());
1122 }
1123
1124 /**
1125 * @tc.name : Test Player PrepareAsync API
1126 * @tc.number: Player_PrepareAsync_001
1127 * @tc.desc : Test Player PrepareAsync interface
1128 */
1129 HWTEST_F(PlayerServerUnitTest, Player_PrepareAsync_001, TestSize.Level0)
1130 {
1131 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1132 sptr<Surface> videoSurface = player_->GetVideoSurface();
1133 ASSERT_NE(nullptr, videoSurface);
1134 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1135 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1136 }
1137
1138 /**
1139 * @tc.name : Test Player PrepareAsync API
1140 * @tc.number: Player_PrepareAsync_002
1141 * @tc.desc : Test Player PrepareAsync->PrepareAsync
1142 */
1143 HWTEST_F(PlayerServerUnitTest, Player_PrepareAsync_002, TestSize.Level2)
1144 {
1145 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1146 sptr<Surface> videoSurface = player_->GetVideoSurface();
1147 ASSERT_NE(nullptr, videoSurface);
1148 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1149 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1150 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
1151 }
1152
1153 /**
1154 * @tc.name : Test Player PrepareAsync API
1155 * @tc.number: Player_PrepareAsync_003
1156 * @tc.desc : Test Player SetVolume/SetLooping/SetPlaybackSpeed->PrepareAsync
1157 */
1158 HWTEST_F(PlayerServerUnitTest, Player_PrepareAsync_003, TestSize.Level2)
1159 {
1160 PlaybackRateMode mode;
1161 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1162 sptr<Surface> videoSurface = player_->GetVideoSurface();
1163 ASSERT_NE(nullptr, videoSurface);
1164 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1165 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
1166 EXPECT_EQ(true, player_->IsLooping());
1167 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1168 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1169 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1170 EXPECT_NE(SPEED_FORWARD_2_00_X, mode);
1171 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1172 EXPECT_EQ(true, player_->IsLooping());
1173 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1174 EXPECT_NE(SPEED_FORWARD_2_00_X, mode);
1175 }
1176
1177 /**
1178 * @tc.name : Test Player PrepareAsync API
1179 * @tc.number: Player_PrepareAsync_004
1180 * @tc.desc : Test Player Stop->PrepareAsync
1181 */
1182 HWTEST_F(PlayerServerUnitTest, Player_PrepareAsync_004, TestSize.Level2)
1183 {
1184 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1185 sptr<Surface> videoSurface = player_->GetVideoSurface();
1186 ASSERT_NE(nullptr, videoSurface);
1187 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1188 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1189 EXPECT_EQ(MSERR_OK, player_->Stop());
1190 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1191 }
1192
1193 /**
1194 * @tc.name : Test Player PrepareAsync API
1195 * @tc.number: Player_PrepareAsync_005
1196 * @tc.desc : Test Player Play->PrepareAsync
1197 */
1198 HWTEST_F(PlayerServerUnitTest, Player_PrepareAsync_005, TestSize.Level2)
1199 {
1200 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1201 sptr<Surface> videoSurface = player_->GetVideoSurface();
1202 ASSERT_NE(nullptr, videoSurface);
1203 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1204 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1205 EXPECT_EQ(MSERR_OK, player_->Play());
1206 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
1207 }
1208
1209 /**
1210 * @tc.name : Test Player PrepareAsync API
1211 * @tc.number: Player_PrepareAsync_006
1212 * @tc.desc : Test Player Play->PrepareAsync
1213 */
1214 HWTEST_F(PlayerServerUnitTest, Player_PrepareAsync_006, TestSize.Level2)
1215 {
1216 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC_DRM.ts"));
1217 sptr<Surface> videoSurface = player_->GetVideoSurface();
1218 ASSERT_NE(nullptr, videoSurface);
1219 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1220 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
1221 }
1222
1223 /**
1224 * @tc.name : Test Player SetVideoSurface API
1225 * @tc.number: Player_SetVideoSurface_001
1226 * @tc.desc : Test Player SetVideoSurface interface
1227 */
1228 HWTEST_F(PlayerServerUnitTest, Player_SetVideoSurface_001, TestSize.Level0)
1229 {
1230 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1231 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(player_->GetVideoSurface()));
1232 }
1233
1234 /**
1235 * @tc.name : Test Player SetVideoSurface API
1236 * @tc.number: Player_SetVideoSurface_002
1237 * @tc.desc : Test Player PrepareAsync->SetVideoSurface
1238 */
1239 HWTEST_F(PlayerServerUnitTest, Player_SetVideoSurface_002, TestSize.Level2)
1240 {
1241 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1242 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1243 sptr<Surface> videoSurface = player_->GetVideoSurface();
1244 ASSERT_NE(nullptr, videoSurface);
1245 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
1246 }
1247
1248 /**
1249 * @tc.name : Test Player SetVideoSurface API
1250 * @tc.number: Player_SetVideoSurface_003
1251 * @tc.desc : Test Player SetVideoSurface interface
1252 */
1253 HWTEST_F(PlayerServerUnitTest, Player_SetVideoSurface_003, TestSize.Level0)
1254 {
1255 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1256 EXPECT_EQ(MSERR_OK, player_->Prepare());
1257 sptr<Surface> videoSurface = player_->GetVideoSurface();
1258 ASSERT_NE(nullptr, videoSurface);
1259 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
1260 }
1261
1262 /**
1263 * @tc.name : Test Player Play API
1264 * @tc.number: Player_Play_001
1265 * @tc.desc : Test Player Play interface
1266 */
1267 HWTEST_F(PlayerServerUnitTest, Player_Play_001, TestSize.Level0)
1268 {
1269 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1270 sptr<Surface> videoSurface = player_->GetVideoSurface();
1271 ASSERT_NE(nullptr, videoSurface);
1272 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1273 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1274 EXPECT_EQ(MSERR_OK, player_->Play());
1275 EXPECT_TRUE(player_->IsPlaying());
1276 EXPECT_EQ(MSERR_OK, player_->Pause());
1277 EXPECT_EQ(MSERR_OK, player_->Play());
1278 }
1279
1280 /**
1281 * @tc.name : Test Player Play API
1282 * @tc.number: Player_Play_002
1283 * @tc.desc : Test Player Reset->Play
1284 */
1285 HWTEST_F(PlayerServerUnitTest, Player_Play_002, TestSize.Level2)
1286 {
1287 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1288 sptr<Surface> videoSurface = player_->GetVideoSurface();
1289 ASSERT_NE(nullptr, videoSurface);
1290 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1291 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1292 EXPECT_EQ(MSERR_OK, player_->Play());
1293 EXPECT_TRUE(player_->IsPlaying());
1294 EXPECT_EQ(MSERR_OK, player_->Reset());
1295 EXPECT_NE(MSERR_OK, player_->Play());
1296 }
1297
1298 /**
1299 * @tc.name : Test Player Play API
1300 * @tc.number: Player_Play_003
1301 * @tc.desc : Test Player complete->Play
1302 */
1303 HWTEST_F(PlayerServerUnitTest, Player_Play_003, TestSize.Level2)
1304 {
1305 int32_t duration = 0;
1306 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1307 sptr<Surface> videoSurface = player_->GetVideoSurface();
1308 ASSERT_NE(nullptr, videoSurface);
1309 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1310 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1311 EXPECT_EQ(MSERR_OK, player_->Play());
1312 EXPECT_TRUE(player_->IsPlaying());
1313 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1314 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1315 sleep(PLAYING_TIME_2_SEC);
1316 EXPECT_EQ(MSERR_OK, player_->Play());
1317 }
1318
1319 /**
1320 * @tc.name : Test Player Play API
1321 * @tc.number: Player_Play_004
1322 * @tc.desc : Test Player Play->Play
1323 */
1324 HWTEST_F(PlayerServerUnitTest, Player_Play_004, TestSize.Level2)
1325 {
1326 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1327 sptr<Surface> videoSurface = player_->GetVideoSurface();
1328 ASSERT_NE(nullptr, videoSurface);
1329 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1330 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1331 EXPECT_EQ(MSERR_OK, player_->Play());
1332 EXPECT_TRUE(player_->IsPlaying());
1333 EXPECT_NE(MSERR_OK, player_->Play());
1334 }
1335
1336 /**
1337 * @tc.name : Test Player Stop API
1338 * @tc.number: Player_Stop_001
1339 * @tc.desc : Test Player Stop Play->Stop
1340 */
1341 HWTEST_F(PlayerServerUnitTest, Player_Stop_001, TestSize.Level0)
1342 {
1343 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
1344 sptr<Surface> videoSurface = player_->GetVideoSurface();
1345 ASSERT_NE(nullptr, videoSurface);
1346 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1347 EXPECT_EQ(MSERR_OK, player_->Prepare());
1348 EXPECT_EQ(MSERR_OK, player_->Play());
1349 EXPECT_TRUE(player_->IsPlaying());
1350 EXPECT_EQ(MSERR_OK, player_->Stop());
1351 }
1352
1353 /**
1354 * @tc.name : Test Player Stop API
1355 * @tc.number: Player_Stop_002
1356 * @tc.desc : Test Player Stop Prepare->Stop
1357 */
1358 HWTEST_F(PlayerServerUnitTest, Player_Stop_002, TestSize.Level2)
1359 {
1360 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
1361 sptr<Surface> videoSurface = player_->GetVideoSurface();
1362 ASSERT_NE(nullptr, videoSurface);
1363 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1364 EXPECT_EQ(MSERR_OK, player_->Prepare());
1365 EXPECT_EQ(MSERR_OK, player_->Stop());
1366 }
1367
1368 /**
1369 * @tc.name : Test Player Stop API
1370 * @tc.number: Player_Stop_003
1371 * @tc.desc : Test Player Stop complete/stop->Stop
1372 */
1373 HWTEST_F(PlayerServerUnitTest, Player_Stop_003, TestSize.Level2)
1374 {
1375 int32_t duration = 0;
1376 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
1377 sptr<Surface> videoSurface = player_->GetVideoSurface();
1378 ASSERT_NE(nullptr, videoSurface);
1379 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1380 EXPECT_EQ(MSERR_OK, player_->Prepare());
1381 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1382 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1383 sleep(PLAYING_TIME_2_SEC);
1384 EXPECT_EQ(MSERR_OK, player_->Stop());
1385 EXPECT_NE(MSERR_OK, player_->Stop());
1386 }
1387
1388 /**
1389 * @tc.name : Test Player Stop API
1390 * @tc.number: Player_Stop_004
1391 * @tc.desc : Test Player Stop Reset->Stop
1392 */
1393 HWTEST_F(PlayerServerUnitTest, Player_Stop_004, TestSize.Level2)
1394 {
1395 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
1396 sptr<Surface> videoSurface = player_->GetVideoSurface();
1397 ASSERT_NE(nullptr, videoSurface);
1398 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1399 EXPECT_EQ(MSERR_OK, player_->Prepare());
1400 EXPECT_EQ(MSERR_OK, player_->Play());
1401 EXPECT_EQ(MSERR_OK, player_->Reset());
1402 EXPECT_NE(MSERR_OK, player_->Stop());
1403 }
1404
1405 /**
1406 * @tc.name : Test Player Stop API
1407 * @tc.number: Player_Stop_005
1408 * @tc.desc : Test Player Reset->Stop
1409 */
1410 HWTEST_F(PlayerServerUnitTest, Player_Stop_005, TestSize.Level2)
1411 {
1412 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
1413 sptr<Surface> videoSurface = player_->GetVideoSurface();
1414 ASSERT_NE(nullptr, videoSurface);
1415 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1416 EXPECT_EQ(MSERR_OK, player_->Prepare());
1417 EXPECT_EQ(MSERR_OK, player_->Play());
1418 EXPECT_TRUE(player_->IsPlaying());
1419 EXPECT_EQ(MSERR_OK, player_->Reset());
1420 EXPECT_NE(MSERR_OK, player_->Stop());
1421 }
1422
1423 /**
1424 * @tc.name : Test Player Pause API
1425 * @tc.number: Player_Pause_001
1426 * @tc.desc : Test Player Pause interface
1427 */
1428 HWTEST_F(PlayerServerUnitTest, Player_Pause_001, TestSize.Level0)
1429 {
1430 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1431 sptr<Surface> videoSurface = player_->GetVideoSurface();
1432 ASSERT_NE(nullptr, videoSurface);
1433 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1434 EXPECT_EQ(MSERR_OK, player_->Prepare());
1435 EXPECT_EQ(MSERR_OK, player_->Play());
1436 EXPECT_TRUE(player_->IsPlaying());
1437 EXPECT_EQ(MSERR_OK, player_->Pause());
1438 EXPECT_FALSE(player_->IsPlaying());
1439 EXPECT_EQ(MSERR_OK, player_->Pause());
1440 }
1441
1442 /**
1443 * @tc.name : Test Player Pause API
1444 * @tc.number: Player_Pause_002
1445 * @tc.desc : Test Player Pause interface
1446 */
1447 HWTEST_F(PlayerServerUnitTest, Player_Pause_002, TestSize.Level2)
1448 {
1449 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1450 sptr<Surface> videoSurface = player_->GetVideoSurface();
1451 ASSERT_NE(nullptr, videoSurface);
1452 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1453 EXPECT_EQ(MSERR_OK, player_->Prepare());
1454 EXPECT_NE(MSERR_OK, player_->Pause());
1455 }
1456
1457 /**
1458 * @tc.name : Test Player Pause API
1459 * @tc.number: Player_Pause_003
1460 * @tc.desc : Test Player Pause interface, Stop -> Pause
1461 */
1462 HWTEST_F(PlayerServerUnitTest, Player_Pause_003, TestSize.Level2)
1463 {
1464 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1465 sptr<Surface> videoSurface = player_->GetVideoSurface();
1466 ASSERT_NE(nullptr, videoSurface);
1467 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1468 EXPECT_EQ(MSERR_OK, player_->Prepare());
1469 EXPECT_EQ(MSERR_OK, player_->Stop());
1470 EXPECT_NE(MSERR_OK, player_->Pause());
1471 }
1472
1473 /**
1474 * @tc.name : Test Player Reset API
1475 * @tc.number: Player_Reset_001
1476 * @tc.desc : Test Player Reset interface
1477 */
1478 HWTEST_F(PlayerServerUnitTest, Player_Reset_001, TestSize.Level0)
1479 {
1480 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1481 sptr<Surface> videoSurface = player_->GetVideoSurface();
1482 ASSERT_NE(nullptr, videoSurface);
1483 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1484 EXPECT_EQ(MSERR_OK, player_->Prepare());
1485 EXPECT_EQ(MSERR_OK, player_->Reset());
1486 EXPECT_NE(MSERR_OK, player_->Reset());
1487 }
1488
1489 /**
1490 * @tc.name : Test Player Seek API
1491 * @tc.number: Player_Seek_001
1492 * @tc.desc : Test Player Seek interface with valid parameters
1493 */
1494 HWTEST_F(PlayerServerUnitTest, Player_Seek_001, TestSize.Level0)
1495 {
1496 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1497 sptr<Surface> videoSurface = player_->GetVideoSurface();
1498 ASSERT_NE(nullptr, videoSurface);
1499 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1500 EXPECT_EQ(MSERR_OK, player_->Prepare());
1501 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_4_SEC, SEEK_NEXT_SYNC));
1502 EXPECT_EQ(MSERR_OK, player_->Play());
1503 EXPECT_TRUE(player_->IsPlaying());
1504 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_4_SEC, SEEK_CLOSEST));
1505 int32_t time = 0;
1506 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
1507 EXPECT_NEAR(SEEK_TIME_4_SEC, time, DELTA_TIME);
1508 EXPECT_EQ(MSERR_OK, player_->Pause());
1509 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_4_SEC, SEEK_NEXT_SYNC));
1510 }
1511
1512 /**
1513 * @tc.name : Test Player Seek API
1514 * @tc.number: Player_Seek_002
1515 * @tc.desc : Test Player Seek interface with seek mode
1516 */
1517 HWTEST_F(PlayerServerUnitTest, Player_Seek_002, TestSize.Level1)
1518 {
1519 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1520 sptr<Surface> videoSurface = player_->GetVideoSurface();
1521 ASSERT_NE(nullptr, videoSurface);
1522 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1523 EXPECT_EQ(MSERR_OK, player_->Prepare());
1524 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_NEXT_SYNC));
1525 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_PREVIOUS_SYNC));
1526 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_CLOSEST_SYNC));
1527 EXPECT_EQ(MSERR_OK, player_->Play());
1528 EXPECT_TRUE(player_->IsPlaying());
1529 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1530 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC));
1531 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST_SYNC));
1532 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, (PlayerSeekMode)5));
1533 }
1534
1535 /**
1536 * @tc.name : Test Player Seek API
1537 * @tc.number: Player_Seek_002
1538 * @tc.desc : Test Player Seek out of duration
1539 */
1540 HWTEST_F(PlayerServerUnitTest, Player_Seek_003, TestSize.Level2)
1541 {
1542 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1543 sptr<Surface> videoSurface = player_->GetVideoSurface();
1544 ASSERT_NE(nullptr, videoSurface);
1545 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1546 EXPECT_EQ(MSERR_OK, player_->Prepare());
1547 EXPECT_EQ(MSERR_OK, player_->Play());
1548 EXPECT_TRUE(player_->IsPlaying());
1549 EXPECT_EQ(MSERR_OK, player_->Seek(1000000, SEEK_NEXT_SYNC));
1550 }
1551
1552 /**
1553 * @tc.name : Test Seek API
1554 * @tc.number: Player_Seek_004
1555 * @tc.desc : Test Player Seek
1556 */
1557 HWTEST_F(PlayerServerUnitTest, Player_Seek_004, TestSize.Level2)
1558 {
1559 int32_t duration = 0;
1560 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1561 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1562 sptr<Surface> videoSurface = player_->GetVideoSurface();
1563 ASSERT_NE(nullptr, videoSurface);
1564 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1565 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1566 EXPECT_EQ(MSERR_OK, player_->Prepare());
1567 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1568 EXPECT_EQ(MSERR_OK, player_->Play());
1569 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1570 EXPECT_EQ(MSERR_OK, player_->Pause());
1571 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1572 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1573 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1574 EXPECT_EQ(MSERR_OK, player_->Play());
1575 sleep(PLAYING_TIME_2_SEC);
1576 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1577 EXPECT_EQ(MSERR_OK, player_->Stop());
1578 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1579 EXPECT_EQ(MSERR_OK, player_->Reset());
1580 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1581 }
1582
1583 /**
1584 * @tc.name : Test Player Seek API
1585 * @tc.number: Player_Seek_005
1586 * @tc.desc : Test Player Seek interface
1587 */
1588 HWTEST_F(PlayerServerUnitTest, Player_Seek_005, TestSize.Level0)
1589 {
1590 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1591 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC));
1592 sptr<Surface> videoSurface = player_->GetVideoSurface();
1593 ASSERT_NE(nullptr, videoSurface);
1594 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1595 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC));
1596 EXPECT_EQ(MSERR_OK, player_->Prepare());
1597 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC));
1598 }
1599
1600 /**
1601 * @tc.name : Test Player Seek API
1602 * @tc.number: Player_Seek_006
1603 * @tc.desc : Test Player Seek interface
1604 */
1605 HWTEST_F(PlayerServerUnitTest, Player_Seek_006, TestSize.Level0)
1606 {
1607 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1608 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST));
1609 sptr<Surface> videoSurface = player_->GetVideoSurface();
1610 ASSERT_NE(nullptr, videoSurface);
1611 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1612 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST));
1613 EXPECT_EQ(MSERR_OK, player_->Prepare());
1614 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST));
1615 }
1616
1617 /**
1618 * @tc.name : Test Player Seek API
1619 * @tc.number: Player_Seek_007
1620 * @tc.desc : Test Player Seek interface
1621 */
1622 HWTEST_F(PlayerServerUnitTest, Player_Seek_007, TestSize.Level0)
1623 {
1624 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1625 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1626 sptr<Surface> videoSurface = player_->GetVideoSurface();
1627 ASSERT_NE(nullptr, videoSurface);
1628 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1629 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1630 EXPECT_EQ(MSERR_OK, player_->Prepare());
1631 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1632 }
1633
1634 /**
1635 * @tc.name : Test Player Seek API
1636 * @tc.number: Player_Seek_008
1637 * @tc.desc : Test Player Seek interface
1638 */
1639 HWTEST_F(PlayerServerUnitTest, Player_Seek_008, TestSize.Level0)
1640 {
1641 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1642 sptr<Surface> videoSurface = player_->GetVideoSurface();
1643 ASSERT_NE(nullptr, videoSurface);
1644 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1645 EXPECT_EQ(MSERR_OK, player_->Prepare());
1646 EXPECT_EQ(MSERR_OK, player_->Play());
1647 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_CLOSEST));
1648 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST));
1649 int32_t duration = 0;
1650 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1651 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1652 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST));
1653 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_CLOSEST));
1654 }
1655
1656 /**
1657 * @tc.name : Test Player Seek API
1658 * @tc.number: Player_Seek_009
1659 * @tc.desc : Test Player Seek interface
1660 */
1661 HWTEST_F(PlayerServerUnitTest, Player_Seek_009, TestSize.Level0)
1662 {
1663 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1664 sptr<Surface> videoSurface = player_->GetVideoSurface();
1665 ASSERT_NE(nullptr, videoSurface);
1666 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1667 EXPECT_EQ(MSERR_OK, player_->Prepare());
1668 EXPECT_EQ(MSERR_OK, player_->Play());
1669 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_PREVIOUS_SYNC));
1670 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC));
1671 int32_t duration = 0;
1672 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1673 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_PREVIOUS_SYNC));
1674 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC));
1675 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_PREVIOUS_SYNC));
1676 }
1677
1678 /**
1679 * @tc.name : Test Player Seek API
1680 * @tc.number: Player_Seek_010
1681 * @tc.desc : Test Player Seek interface
1682 */
1683 HWTEST_F(PlayerServerUnitTest, Player_Seek_010, TestSize.Level0)
1684 {
1685 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1686 sptr<Surface> videoSurface = player_->GetVideoSurface();
1687 ASSERT_NE(nullptr, videoSurface);
1688 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1689 EXPECT_EQ(MSERR_OK, player_->Prepare());
1690 EXPECT_EQ(MSERR_OK, player_->Play());
1691 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_NEXT_SYNC));
1692 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1693 int32_t duration = 0;
1694 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1695 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_NEXT_SYNC));
1696 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1697 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_NEXT_SYNC));
1698 }
1699
1700 /**
1701 * @tc.name : Test GetVideoTrackInfo API
1702 * @tc.number: Player_GetVideoTrackInfo_001
1703 * @tc.desc : Test Player GetVideoTrackInfo
1704 */
1705 HWTEST_F(PlayerServerUnitTest, Player_GetVideoTrackInfo_001, TestSize.Level0)
1706 {
1707 std::vector<Format> videoTrack;
1708 std::vector<Format> audioTrack;
1709 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1710 sptr<Surface> videoSurface = player_->GetVideoSurface();
1711 ASSERT_NE(nullptr, videoSurface);
1712 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1713 EXPECT_EQ(MSERR_OK, player_->Prepare());
1714 EXPECT_EQ(MSERR_OK, player_->Play());
1715 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1716 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1717 }
1718
1719 /**
1720 * @tc.name : Test GetVideoTrackInfo API
1721 * @tc.number: Player_GetVideoTrackInfo_002
1722 * @tc.desc : Test Player GetVideoTrackInfo
1723 */
1724 HWTEST_F(PlayerServerUnitTest, Player_GetVideoTrackInfo_002, TestSize.Level2)
1725 {
1726 std::vector<Format> videoTrack;
1727 std::vector<Format> audioTrack;
1728 int32_t duration = 0;
1729 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1730 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1731 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1732 sptr<Surface> videoSurface = player_->GetVideoSurface();
1733 ASSERT_NE(nullptr, videoSurface);
1734 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1735 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1736 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1737 EXPECT_EQ(MSERR_OK, player_->Prepare());
1738 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1739 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1740 EXPECT_EQ(MSERR_OK, player_->Play());
1741 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1742 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1743 EXPECT_EQ(MSERR_OK, player_->Pause());
1744 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1745 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1746 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1747 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1748 EXPECT_EQ(MSERR_OK, player_->Play());
1749 sleep(PLAYING_TIME_2_SEC);
1750 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1751 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1752 EXPECT_EQ(MSERR_OK, player_->Stop());
1753 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1754 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1755 EXPECT_EQ(MSERR_OK, player_->Reset());
1756 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1757 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1758 }
1759
1760 /**
1761 * @tc.name : Test GetAudioTrackInfo API
1762 * @tc.number: Player_GetAudioTrackInfo_001
1763 * @tc.desc : Test Player GetAudioTrackInfo
1764 */
1765 HWTEST_F(PlayerServerUnitTest, Player_GetAudioTrackInfo_001, TestSize.Level2)
1766 {
1767 std::vector<Format> audioTrack;
1768 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1769 EXPECT_EQ(MSERR_OK, player_->Prepare());
1770 EXPECT_EQ(MSERR_OK, player_->Play());
1771 sleep(PLAYING_TIME_2_SEC);
1772 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1773 EXPECT_EQ(1, audioTrack.size());
1774 Format audioTrackFormat = audioTrack.front();
1775 int32_t sampleDepth;
1776 audioTrackFormat.GetIntValue("sample_depth", sampleDepth);
1777 EXPECT_EQ(16, sampleDepth);
1778 }
1779
1780 /**
1781 * @tc.name : Test SelectTrack and DeselectTrack API
1782 * @tc.number: Player_SelectTrack_001
1783 * @tc.desc : Test Player SelectTrack and DeselectTrack
1784 */
1785 HWTEST_F(PlayerServerUnitTest, Player_SelectTrack_001, TestSize.Level0)
1786 {
1787 bool trackChange = false;
1788 std::vector<Format> audioTrack;
1789 std::vector<int32_t> audioTrackIds;
1790 int32_t currentAudioTrackIndex = -1;
1791 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE2));
1792 EXPECT_EQ(MSERR_OK, player_->Prepare());
1793 EXPECT_EQ(MSERR_OK, player_->Play());
1794 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1795 sleep(PLAYING_TIME_2_SEC);
1796 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, currentAudioTrackIndex));
1797 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1798 for (Format audioTrackFormat: audioTrack) {
1799 int32_t trackIndex = -1;
1800 audioTrackFormat.GetIntValue("track_index", trackIndex);
1801 audioTrackIds.push_back(trackIndex);
1802 }
1803 for (int32_t trackIndex: audioTrackIds) {
1804 if (trackIndex != currentAudioTrackIndex) {
1805 trackChange = false;
1806 EXPECT_EQ(MSERR_OK, player_->SelectTrack(trackIndex, trackChange));
1807 EXPECT_EQ(trackChange, true);
1808 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, currentAudioTrackIndex));
1809 sleep(PLAYING_TIME_2_SEC);
1810 trackChange = false;
1811 EXPECT_EQ(MSERR_OK, player_->DeselectTrack(currentAudioTrackIndex, trackChange));
1812 EXPECT_EQ(trackChange, true);
1813 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, currentAudioTrackIndex));
1814 sleep(PLAYING_TIME_2_SEC);
1815 }
1816 }
1817 EXPECT_EQ(MSERR_OK, player_->Stop());
1818 }
1819
1820 /**
1821 * @tc.name : Test SelectTrack API
1822 * @tc.number: Player_SelectTrack_002
1823 * @tc.desc : Test Player SelectTrack invalid trackId
1824 */
1825 HWTEST_F(PlayerServerUnitTest, Player_SelectTrack_002, TestSize.Level0)
1826 {
1827 bool trackChange = false;
1828 int32_t currentAudioTrackIndex = -1;
1829 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE2));
1830 EXPECT_EQ(MSERR_OK, player_->Prepare());
1831 EXPECT_EQ(MSERR_OK, player_->Play());
1832 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1833 sleep(PLAYING_TIME_2_SEC);
1834 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, currentAudioTrackIndex));
1835 EXPECT_NE(MSERR_OK, player_->SelectTrack(currentAudioTrackIndex, trackChange));
1836 EXPECT_EQ(trackChange, false);
1837 sleep(PLAYING_TIME_2_SEC);
1838 EXPECT_EQ(MSERR_OK, player_->Stop());
1839 }
1840
1841 /**
1842 * @tc.name : Test DeselectTrack API
1843 * @tc.number: Player_DeselectTrack_001
1844 * @tc.desc : Test Player DeselectTrack invalid trackId
1845 */
1846 HWTEST_F(PlayerServerUnitTest, Player_DeselectTrack_001, TestSize.Level0)
1847 {
1848 std::vector<Format> audioTrack;
1849 std::vector<int32_t> audioTrackIds;
1850 int32_t defaultAudioTrackIndex = -1;
1851 bool trackChange = false;
1852 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE2));
1853 EXPECT_EQ(MSERR_OK, player_->Prepare());
1854 EXPECT_EQ(MSERR_OK, player_->Play());
1855 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1856 sleep(PLAYING_TIME_2_SEC);
1857 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1858 EXPECT_GT(audioTrack.size(), 0);
1859 audioTrack[0].GetIntValue("track_index", defaultAudioTrackIndex);
1860 EXPECT_GT(defaultAudioTrackIndex, -1);
1861 EXPECT_NE(MSERR_OK, player_->DeselectTrack(defaultAudioTrackIndex, trackChange));
1862 EXPECT_EQ(trackChange, false);
1863 sleep(PLAYING_TIME_2_SEC);
1864 EXPECT_EQ(MSERR_OK, player_->Stop());
1865 }
1866
1867 /**
1868 * @tc.name : Test GetVideoHeight API
1869 * @tc.number: Player_GetVideoHeight_001
1870 * @tc.desc : Test Player GetVideoHeight
1871 */
1872 HWTEST_F(PlayerServerUnitTest, Player_GetVideoHeight_001, TestSize.Level0)
1873 {
1874 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1875 sptr<Surface> videoSurface = player_->GetVideoSurface();
1876 ASSERT_NE(nullptr, videoSurface);
1877 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1878 EXPECT_EQ(MSERR_OK, player_->Prepare());
1879 EXPECT_EQ(MSERR_OK, player_->Play());
1880 EXPECT_EQ(480, player_->GetVideoHeight());
1881 EXPECT_EQ(720, player_->GetVideoWidth());
1882 }
1883
1884 /**
1885 * @tc.name : Test GetVideoHeight API
1886 * @tc.number: Player_GetVideoHeight_002
1887 * @tc.desc : Test Player GetVideoHeight
1888 */
1889 HWTEST_F(PlayerServerUnitTest, Player_GetVideoHeight_002, TestSize.Level2)
1890 {
1891 int32_t duration = 0;
1892 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1893 EXPECT_NE(480, player_->GetVideoHeight());
1894 EXPECT_NE(720, player_->GetVideoWidth());
1895 sptr<Surface> videoSurface = player_->GetVideoSurface();
1896 ASSERT_NE(nullptr, videoSurface);
1897 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1898 EXPECT_NE(480, player_->GetVideoHeight());
1899 EXPECT_NE(720, player_->GetVideoWidth());
1900 EXPECT_EQ(MSERR_OK, player_->Prepare());
1901 EXPECT_EQ(480, player_->GetVideoHeight());
1902 EXPECT_EQ(720, player_->GetVideoWidth());
1903 EXPECT_EQ(MSERR_OK, player_->Play());
1904 EXPECT_EQ(480, player_->GetVideoHeight());
1905 EXPECT_EQ(720, player_->GetVideoWidth());
1906 EXPECT_EQ(MSERR_OK, player_->Pause());
1907 EXPECT_EQ(480, player_->GetVideoHeight());
1908 EXPECT_EQ(720, player_->GetVideoWidth());
1909 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1910 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1911 EXPECT_EQ(MSERR_OK, player_->Play());
1912 sleep(PLAYING_TIME_2_SEC);
1913 EXPECT_EQ(480, player_->GetVideoHeight());
1914 EXPECT_EQ(720, player_->GetVideoWidth());
1915 EXPECT_EQ(MSERR_OK, player_->Stop());
1916 EXPECT_EQ(480, player_->GetVideoHeight());
1917 EXPECT_EQ(720, player_->GetVideoWidth());
1918 EXPECT_EQ(MSERR_OK, player_->Reset());
1919 EXPECT_NE(480, player_->GetVideoHeight());
1920 EXPECT_NE(720, player_->GetVideoWidth());
1921 }
1922
1923 /**
1924 * @tc.name : Test GetDuration API
1925 * @tc.number: Player_GetDuration_001
1926 * @tc.desc : Test Player GetDuration
1927 */
1928 HWTEST_F(PlayerServerUnitTest, Player_GetDuration_001, TestSize.Level0)
1929 {
1930 int32_t duration = 0;
1931 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1932 sptr<Surface> videoSurface = player_->GetVideoSurface();
1933 ASSERT_NE(nullptr, videoSurface);
1934 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1935 EXPECT_EQ(MSERR_OK, player_->Prepare());
1936 EXPECT_EQ(MSERR_OK, player_->Play());
1937 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1938 EXPECT_NEAR(10000, duration, DELTA_TIME); // duration 10000ms
1939 }
1940
1941 /**
1942 * @tc.name : Test GetDuration API
1943 * @tc.number: Player_GetDuration_002
1944 * @tc.desc : Test Player GetDuration
1945 */
1946 HWTEST_F(PlayerServerUnitTest, Player_GetDuration_002, TestSize.Level2)
1947 {
1948 int32_t duration = 0;
1949 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1950 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
1951 sptr<Surface> videoSurface = player_->GetVideoSurface();
1952 ASSERT_NE(nullptr, videoSurface);
1953 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1954 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
1955 EXPECT_EQ(MSERR_OK, player_->Prepare());
1956 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1957 EXPECT_EQ(MSERR_OK, player_->Play());
1958 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1959 EXPECT_EQ(MSERR_OK, player_->Pause());
1960 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1961 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1962 EXPECT_EQ(MSERR_OK, player_->Play());
1963 sleep(PLAYING_TIME_2_SEC);
1964 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1965 EXPECT_EQ(MSERR_OK, player_->Stop());
1966 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1967 EXPECT_EQ(MSERR_OK, player_->Reset());
1968 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
1969 }
1970
1971 /**
1972 * @tc.name : Test SetPlaybackSpeed API
1973 * @tc.number: Player_SetPlaybackSpeed_001
1974 * @tc.desc : Test Player SetPlaybackSpeed
1975 */
1976 HWTEST_F(PlayerServerUnitTest, Player_SetPlaybackSpeed_001, TestSize.Level0)
1977 {
1978 PlaybackRateMode mode;
1979 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1980 sptr<Surface> videoSurface = player_->GetVideoSurface();
1981 ASSERT_NE(nullptr, videoSurface);
1982 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1983 EXPECT_EQ(MSERR_OK, player_->Prepare());
1984 EXPECT_EQ(MSERR_OK, player_->Play());
1985 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1986 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1987 EXPECT_EQ(SPEED_FORWARD_2_00_X, mode);
1988 }
1989
1990 /**
1991 * @tc.name : Test SetPlaybackSpeed API
1992 * @tc.number: Player_SetPlaybackSpeed_002
1993 * @tc.desc : Test Player SetPlaybackSpeed
1994 */
1995 HWTEST_F(PlayerServerUnitTest, Player_SetPlaybackSpeed_002, TestSize.Level2)
1996 {
1997 int32_t duration = 0;
1998 PlaybackRateMode mode;
1999 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2000 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
2001 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2002 sptr<Surface> videoSurface = player_->GetVideoSurface();
2003 ASSERT_NE(nullptr, videoSurface);
2004 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2005 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
2006 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2007 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2008 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
2009 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2010 EXPECT_EQ(MSERR_OK, player_->Play());
2011 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
2012 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2013 EXPECT_EQ(MSERR_OK, player_->Pause());
2014 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_1_75_X));
2015 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2016 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
2017 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
2018 EXPECT_EQ(MSERR_OK, player_->Play());
2019 sleep(PLAYING_TIME_2_SEC);
2020 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_0_75_X));
2021 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2022 EXPECT_EQ(MSERR_OK, player_->Stop());
2023 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_1_25_X));
2024 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2025 EXPECT_EQ(MSERR_OK, player_->Reset());
2026 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
2027 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2028 }
2029
2030 /**
2031 * @tc.name : Test SetLooping API
2032 * @tc.number: Player_SetLooping_001
2033 * @tc.desc : Test Player SetLooping
2034 */
2035 HWTEST_F(PlayerServerUnitTest, Player_SetLooping_001, TestSize.Level0)
2036 {
2037 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2038 sptr<Surface> videoSurface = player_->GetVideoSurface();
2039 ASSERT_NE(nullptr, videoSurface);
2040 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2041 EXPECT_EQ(MSERR_OK, player_->Prepare());
2042 EXPECT_EQ(MSERR_OK, player_->Play());
2043 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
2044 EXPECT_EQ(true, player_->IsLooping());
2045 EXPECT_EQ(MSERR_OK, player_->SetLooping(false));
2046 EXPECT_EQ(false, player_->IsLooping());
2047 }
2048
2049 /**
2050 * @tc.name : Test SetLooping API
2051 * @tc.number: Player_SetLooping_002
2052 * @tc.desc : Test Player SetLooping liveStream
2053 */
2054 HWTEST_F(PlayerServerUnitTest, Player_SetLooping_002, TestSize.Level0)
2055 {
2056 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
2057 server->isLiveStream_ = true;
2058 EXPECT_EQ(MSERR_INVALID_OPERATION, server->SetLooping(true));
2059 }
2060
2061 /**
2062 * @tc.name : Test SetLooping API
2063 * @tc.number: Player_SetLooping_003
2064 * @tc.desc : Test Player SetLooping invalid playerEngine
2065 */
2066 HWTEST_F(PlayerServerUnitTest, Player_SetLooping_003, TestSize.Level0)
2067 {
2068 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
2069 server->lastOpStatus_ = PLAYER_STARTED;
2070 EXPECT_EQ(MSERR_OK, server->SetLooping(true));
2071 }
2072
2073 /**
2074 * @tc.name : Test SetVolume API
2075 * @tc.number: Player_SetVolume_001
2076 * @tc.desc : Test Player SetVolume
2077 */
2078 HWTEST_F(PlayerServerUnitTest, Player_SetVolume_001, TestSize.Level0)
2079 {
2080 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2081 sptr<Surface> videoSurface = player_->GetVideoSurface();
2082 ASSERT_NE(nullptr, videoSurface);
2083 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2084 EXPECT_EQ(MSERR_OK, player_->Prepare());
2085 EXPECT_EQ(MSERR_OK, player_->Play());
2086 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
2087 }
2088
2089 /**
2090 * @tc.name : Test SetVolume API
2091 * @tc.number: Player_SetVolume_002
2092 * @tc.desc : Test Player SetVolume
2093 */
2094 HWTEST_F(PlayerServerUnitTest, Player_SetVolume_002, TestSize.Level0)
2095 {
2096 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2097 sptr<Surface> videoSurface = player_->GetVideoSurface();
2098 ASSERT_NE(nullptr, videoSurface);
2099 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2100 EXPECT_EQ(MSERR_OK, player_->Prepare());
2101 EXPECT_EQ(MSERR_OK, player_->Play());
2102 EXPECT_NE(MSERR_OK, player_->SetVolume(1.1, 0.1));
2103 EXPECT_NE(MSERR_OK, player_->SetVolume(0.1, 1.1));
2104 EXPECT_NE(MSERR_OK, player_->SetVolume(1.1, 1.1));
2105 EXPECT_NE(MSERR_OK, player_->SetVolume(-0.1, 0.1));
2106 EXPECT_NE(MSERR_OK, player_->SetVolume(0.1, -0.1));
2107 EXPECT_NE(MSERR_OK, player_->SetVolume(-0.1, -0.1));
2108 }
2109
2110 /**
2111 * @tc.name : Test SetVolume API
2112 * @tc.number: Player_SetVolume_003
2113 * @tc.desc : Test Player SetVolume
2114 */
2115 HWTEST_F(PlayerServerUnitTest, Player_SetVolume_003, TestSize.Level2)
2116 {
2117 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2118 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
2119 sptr<Surface> videoSurface = player_->GetVideoSurface();
2120 ASSERT_NE(nullptr, videoSurface);
2121 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2122 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
2123 EXPECT_EQ(MSERR_OK, player_->Prepare());
2124 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
2125 EXPECT_EQ(MSERR_OK, player_->Play());
2126 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
2127 EXPECT_EQ(MSERR_OK, player_->Pause());
2128 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
2129 EXPECT_EQ(MSERR_OK, player_->Stop());
2130 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
2131 EXPECT_EQ(MSERR_OK, player_->Reset());
2132 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
2133 }
2134
2135 /**
2136 * @tc.name : Test SetVolume API
2137 * @tc.number: Player_SetVolume_004
2138 * @tc.desc : Test Player SetVolume
2139 */
2140 HWTEST_F(PlayerServerUnitTest, Player_SetVolume_004, TestSize.Level2)
2141 {
2142 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2143 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
2144 sptr<Surface> videoSurface = player_->GetVideoSurface();
2145 ASSERT_NE(nullptr, videoSurface);
2146 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2147 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2148 EXPECT_EQ(MSERR_OK, player_->Play());
2149 EXPECT_EQ(MSERR_OK, player_->SetVolume(1e-7, 1));
2150 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1e-7));
2151 EXPECT_EQ(MSERR_OK, player_->SetVolume(1e-7, 1e-7));
2152 }
2153
2154 /**
2155 * @tc.name : Test SetVideoScaleType API
2156 * @tc.number: Player_SetVideoScaleType_001
2157 * @tc.desc : Test Player SetVideoScaleType
2158 */
2159 HWTEST_F(PlayerServerUnitTest, Player_SetVideoScaleType_001, TestSize.Level0)
2160 {
2161 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2162 sptr<Surface> videoSurface = player_->GetVideoSurface();
2163 ASSERT_NE(nullptr, videoSurface);
2164 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2165 EXPECT_EQ(MSERR_OK, player_->Prepare());
2166 EXPECT_EQ(MSERR_OK, player_->Play());
2167 Format format;
2168 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE,
2169 static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT));
2170 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
2171 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE,
2172 static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT_CROP));
2173 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
2174 }
2175
2176 /**
2177 * @tc.name : Test SetRendererInfo API
2178 * @tc.number: Player_SetRendererInfo_001
2179 * @tc.desc : Test Player SetRendererInfo
2180 */
2181 HWTEST_F(PlayerServerUnitTest, Player_SetRendererInfo_001, TestSize.Level0)
2182 {
2183 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2184 Format format;
2185 sptr<Surface> videoSurface = player_->GetVideoSurface();
2186 ASSERT_NE(nullptr, videoSurface);
2187 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2188 int32_t contentType = 1;
2189 int32_t streamUsage = 1;
2190 int32_t rendererFlags = 0;
2191 (void)format.PutIntValue(PlayerKeys::CONTENT_TYPE, contentType);
2192 (void)format.PutIntValue(PlayerKeys::STREAM_USAGE, streamUsage);
2193 (void)format.PutIntValue(PlayerKeys::RENDERER_FLAG, rendererFlags);
2194 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
2195 EXPECT_EQ(MSERR_OK, player_->Prepare());
2196 EXPECT_EQ(MSERR_OK, player_->Play());
2197 }
2198
2199 /**
2200 * @tc.name : Test SetVolumeMode API
2201 * @tc.number: Player_SetVolumeMode_001
2202 * @tc.desc : Test Player SetVolumeMode
2203 */
2204 HWTEST_F(PlayerServerUnitTest, Player_SetVolumeMode_001, TestSize.Level0)
2205 {
2206 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2207 Format format;
2208 sptr<Surface> videoSurface = player_->GetVideoSurface();
2209 ASSERT_NE(nullptr, videoSurface);
2210 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2211 int32_t contentType = 1;
2212 int32_t streamUsage = 1;
2213 int32_t rendererFlags = 0;
2214 int32_t mode = 1;
2215 (void)format.PutIntValue(PlayerKeys::CONTENT_TYPE, contentType);
2216 (void)format.PutIntValue(PlayerKeys::STREAM_USAGE, streamUsage);
2217 (void)format.PutIntValue(PlayerKeys::RENDERER_FLAG, rendererFlags);
2218 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
2219 EXPECT_EQ(MSERR_OK, player_->SetVolumeMode(mode));
2220 EXPECT_EQ(MSERR_OK, player_->Prepare());
2221 EXPECT_EQ(MSERR_OK, player_->Play());
2222 }
2223
2224 /**
2225 * @tc.name : Test SetInterrupt API
2226 * @tc.number: Player_SetInterrupt_001
2227 * @tc.desc : Test Player SetInterrupt
2228 */
2229 HWTEST_F(PlayerServerUnitTest, Player_SetInterrupt_001, TestSize.Level0)
2230 {
2231 Format format;
2232 int32_t mode = 1;
2233 int32_t type = 1;
2234 std::shared_ptr<PlayerServerMock> player = nullptr;
2235 std::shared_ptr<PlayerCallbackTest> callback = nullptr;
2236 callback = std::make_shared<PlayerCallbackTest>();
2237 ASSERT_NE(nullptr, callback);
2238 player = std::make_shared<PlayerServerMock>(callback);
2239 ASSERT_NE(nullptr, player);
2240 EXPECT_TRUE(player->CreatePlayer());
2241 EXPECT_EQ(MSERR_OK, player->SetPlayerCallback(callback));
2242 ASSERT_EQ(MSERR_OK, player->SetSource(MEDIA_ROOT + "01.mp3"));
2243 EXPECT_EQ(MSERR_OK, player->Prepare());
2244
2245 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2246 EXPECT_EQ(MSERR_OK, player_->Prepare());
2247 (void)format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_MODE, mode);
2248 (void)format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_TYPE, type);
2249 EXPECT_EQ(MSERR_OK, player->SetParameter(format));
2250 EXPECT_EQ(MSERR_OK, player->Play());
2251 sleep(PLAYING_TIME_2_SEC);
2252 EXPECT_EQ(MSERR_OK, player_->Play());
2253 sleep(PLAYING_TIME_2_SEC);
2254 EXPECT_EQ(MSERR_OK, player->ReleaseSync());
2255 }
2256
2257 /**
2258 * @tc.name : Test Player SelectBitRate API
2259 * @tc.number: Player_SelectBitRate_001
2260 * @tc.desc : Test Player SelectBitRate interface
2261 */
2262 HWTEST_F(PlayerServerUnitTest, Player_SelectBitRate_001, TestSize.Level0)
2263 {
2264 EXPECT_EQ(MSERR_OK, player_->SelectBitRate(0));
2265 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2266 sptr<Surface> videoSurface = player_->GetVideoSurface();
2267 ASSERT_NE(nullptr, videoSurface);
2268 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2269 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2270 EXPECT_EQ(MSERR_OK, player_->Play());
2271 EXPECT_EQ(MSERR_OK, player_->SelectBitRate(0));
2272 }
2273
2274 /**
2275 * @tc.name: Player_Performance_Prepared_001
2276 * @tc.desc: test player start
2277 * @tc.type: PERFORMANCE
2278 * @tc.require: issueI5NYBJ
2279 */
2280 HWTEST_F(PlayerServerUnitTest, Player_Performance_Prepared_001, TestSize.Level0)
2281 {
2282 struct timeval startTime = {};
2283 struct timeval finishTime = {};
2284 int32_t runTimes = 10;
2285 float timeConv = 1000;
2286 float deltaTime = 0;
2287 sptr<Surface> videoSurface = player_->GetVideoSurface();
2288 ASSERT_NE(nullptr, videoSurface);
2289 for (int32_t i = 0; i < runTimes; i++) {
2290 EXPECT_EQ(MSERR_OK, gettimeofday(&startTime, nullptr));
2291 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2292 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2293 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2294 EXPECT_EQ(MSERR_OK, gettimeofday(&finishTime, nullptr));
2295 EXPECT_EQ(MSERR_OK, player_->Play());
2296 deltaTime += (finishTime.tv_sec - startTime.tv_sec) * timeConv +
2297 (finishTime.tv_usec - startTime.tv_usec) / timeConv;
2298 EXPECT_EQ(MSERR_OK, player_->Reset());
2299 }
2300 EXPECT_LE(deltaTime / runTimes, 1000); // less than 1000 ms
2301 }
2302
2303 /**
2304 * @tc.name : Test Player Play mp4 with rotation
2305 * @tc.number: Player_Rotate_001
2306 * @tc.desc : Test Player Play interface
2307 */
2308 HWTEST_F(PlayerServerUnitTest, Player_Rotate_001, TestSize.Level0)
2309 {
2310 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
2311 sptr<Surface> videoSurface = player_->GetVideoSurface();
2312 ASSERT_NE(nullptr, videoSurface);
2313 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2314 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2315 EXPECT_EQ(MSERR_OK, player_->Play());
2316 EXPECT_TRUE(player_->IsPlaying());
2317 }
2318
2319 /**
2320 * @tc.name : Test Player Dump Dot
2321 * @tc.number: Player_Dump_Dot_001
2322 * @tc.desc : Test Player Dump Dot
2323 */
2324 HWTEST_F(PlayerServerUnitTest, Player_Dump_Dot_001, TestSize.Level0)
2325 {
2326 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
2327 sptr<Surface> videoSurface = player_->GetVideoSurface();
2328 ASSERT_NE(nullptr, videoSurface);
2329 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2330 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2331 EXPECT_EQ(MSERR_OK, player_->Play());
2332 system("param set sys.media.dump.dot.path /data/test/media");
2333 EXPECT_TRUE(player_->IsPlaying());
2334 EXPECT_EQ(MSERR_OK, player_->Pause());
2335 EXPECT_EQ(MSERR_OK, player_->Play());
2336 }
2337
2338 /**
2339 * @tc.name : Test Player Dump Dot
2340 * @tc.number: Player_Dump_Dot_002
2341 * @tc.desc : Test Player Dump Dot
2342 */
2343 HWTEST_F(PlayerServerUnitTest, Player_Dump_Dot_002, TestSize.Level0)
2344 {
2345 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
2346 sptr<Surface> videoSurface = player_->GetVideoSurface();
2347 ASSERT_NE(nullptr, videoSurface);
2348 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2349 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2350 EXPECT_EQ(MSERR_OK, player_->Play());
2351 system("param set sys.media.dump.dot.path /xx");
2352 EXPECT_TRUE(player_->IsPlaying());
2353 EXPECT_EQ(MSERR_OK, player_->Pause());
2354 EXPECT_EQ(MSERR_OK, player_->Play());
2355 }
2356
2357 /**
2358 * @tc.name : Test Player Dump GlibMem
2359 * @tc.number: Player_Dump_GlibMem_001
2360 * @tc.desc : Test Player Dump GlibMem
2361 */
2362 HWTEST_F(PlayerServerUnitTest, Player_Dump_GlibMem_001, TestSize.Level0)
2363 {
2364 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
2365 sptr<Surface> videoSurface = player_->GetVideoSurface();
2366 ASSERT_NE(nullptr, videoSurface);
2367 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2368 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2369 EXPECT_EQ(MSERR_OK, player_->Play());
2370 system("hidumper -s 3002 -a glibmem");
2371 system("param set sys.media.dump.codec.vdec ALL");
2372 EXPECT_TRUE(player_->IsPlaying());
2373 EXPECT_EQ(MSERR_OK, player_->Pause());
2374 }
2375
2376 /**
2377 * @tc.name : Test Player Dump GlibPool
2378 * @tc.number: Player_Dump_GlibPool_001
2379 * @tc.desc : Test Player Dump GlibPool
2380 */
2381 HWTEST_F(PlayerServerUnitTest, Player_Dump_GlibPool_001, TestSize.Level0)
2382 {
2383 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
2384 sptr<Surface> videoSurface = player_->GetVideoSurface();
2385 ASSERT_NE(nullptr, videoSurface);
2386 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2387 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2388 system("param set sys.media.dump.frame.enable true");
2389 system("param set sys.media.set.mute TRUE");
2390 system("param set sys.media.kpi.avsync.log.enable true");
2391 system("param set sys.media.kpi.opt.renderdelay.enable true");
2392 EXPECT_EQ(MSERR_OK, player_->Play());
2393 system("hidumper -s 3002 -a glibpool");
2394 system("param set sys.media.dump.codec.vdec ALL");
2395 EXPECT_TRUE(player_->IsPlaying());
2396 EXPECT_EQ(MSERR_OK, player_->Pause());
2397 }
2398
2399 /**
2400 * @tc.name : Test Player Dump Log
2401 * @tc.number: Player_Dump_Log_001
2402 * @tc.desc : Test Player Dump Log
2403 */
2404 HWTEST_F(PlayerServerUnitTest, Player_Dump_Log_001, TestSize.Level0)
2405 {
2406 system("mkdir /data/media/log");
2407 system("chmod 777 -R /data/media");
2408 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2409 sptr<Surface> videoSurface = player_->GetVideoSurface();
2410 ASSERT_NE(nullptr, videoSurface);
2411 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2412 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2413 system("param set sys.media.log.level *:l,multiqueue,decodecbin:,tsdemux:D,multiqueue:D,hlsdemux:D,souphttpsrc:W");
2414 system("param set sys.media.log.level *:l,basesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmm" \
2415 "basesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmm:D");
2416 system("param set sys.media.dump.frame.enable false");
2417 system("param set sys.media.set.mute FALSE");
2418 system("param set sys.media.kpi.avsync.log.enable false");
2419 system("param set sys.media.kpi.opt.renderdelay.enable false");
2420 EXPECT_EQ(MSERR_OK, player_->Play());
2421 system("param set sys.media.dump.codec.vdec NULL");
2422 EXPECT_TRUE(player_->IsPlaying());
2423 EXPECT_EQ(MSERR_OK, player_->Pause());
2424 system("rm -rf /data/media/log");
2425 }
2426
2427 /**
2428 * @tc.name : Test Player Dump gstbuffer
2429 * @tc.number: Player_Dump_GstBuffer_001
2430 * @tc.desc : Test Player Dump gstbuffer
2431 */
2432 HWTEST_F(PlayerServerUnitTest, Player_Dump_GstBuffer_001, TestSize.Level0)
2433 {
2434 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2435 sptr<Surface> videoSurface = player_->GetVideoSurface();
2436 ASSERT_NE(nullptr, videoSurface);
2437 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2438 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2439 system("param set sys.media.dump.gstbuffer 1");
2440 system("param set sys.media.set.mute null");
2441 EXPECT_EQ(MSERR_OK, player_->Play());
2442 EXPECT_TRUE(player_->IsPlaying());
2443 EXPECT_EQ(MSERR_OK, player_->Pause());
2444 system("param set sys.media.dump.gstbuffer 0");
2445 }
2446
2447 /**
2448 * @tc.name : Test Player With Not Performance
2449 * @tc.number: Player_Not_Performance_001
2450 * @tc.desc : Test Player Not Performance
2451 */
2452 HWTEST_F(PlayerServerUnitTest, Player_Not_Performance_001, TestSize.Level2)
2453 {
2454 system("param set sys.media.player.performance.enable FALSE");
2455 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
2456 sptr<Surface> videoSurface = player_->GetVideoSurface();
2457 ASSERT_NE(nullptr, videoSurface);
2458 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2459 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2460 system("param set sys.media.player.performance.enable TRUE");
2461 }
2462
2463 /**
2464 * @tc.name : Test Player Mem Recycle
2465 * @tc.number: Player_Mem_Recycle_001
2466 * @tc.desc : Test Player Mem Recycle
2467 */
2468 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_001, TestSize.Level0)
2469 {
2470 sptr<Surface> renderSurface = player_->GetVideoSurface();
2471 ASSERT_NE(nullptr, renderSurface);
2472 std::vector<std::string> srcVector = {MEDIA_ROOT + "H264_MP3.mp4"};
2473 for (int32_t i = 0; i < static_cast<int32_t>(srcVector.size()); i++) {
2474 if (srcVector[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2475 system("param set sys.media.player.resource.type NetWork");
2476 }
2477 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVector[i]));
2478 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(renderSurface));
2479 char text[100]; // 100: text len
2480 sprintf_s(text, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", 0, 0, 4);
2481 system(text);
2482 sprintf_s(text, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), 0, 4);
2483 system(text);
2484 system("hidumper -s 1909 -a \"-t 6\"");
2485 system("hidumper -s 1909 -a \"-t 3\"");
2486 int32_t ret = player_->Prepare();
2487 EXPECT_EQ(MSERR_OK, ret);
2488 EXPECT_EQ(MSERR_OK, player_->Reset());
2489 system("param set sys.media.player.resource.type Local");
2490 }
2491 }
2492
2493 /**
2494 * @tc.name : Test Player Mem Recycle
2495 * @tc.number: Player_Mem_Recycle_002
2496 * @tc.desc : Test Player Mem Recycle
2497 */
2498 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_002, TestSize.Level0)
2499 {
2500 sptr<Surface> vSurface = player_->GetVideoSurface();
2501 ASSERT_NE(nullptr, vSurface);
2502 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2503 for (uint32_t i = 0; i < srcVec.size(); i++) {
2504 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2505 system("param set sys.media.player.resource.type NetWork");
2506 }
2507 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2508 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(vSurface));
2509 EXPECT_EQ(MSERR_OK, player_->Prepare());
2510 char str[100]; // 100: str len
2511 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2512 system(str);
2513 system("hidumper -s 1909 -a \"-t 3\"");
2514 EXPECT_EQ(MSERR_OK, player_->Play());
2515 EXPECT_EQ(MSERR_OK, player_->Reset());
2516 system("param set sys.media.player.resource.type Local");
2517 }
2518 }
2519
2520 /**
2521 * @tc.name : Test Player Mem Recycle
2522 * @tc.number: Player_Mem_Recycle_003
2523 * @tc.desc : Test Player Mem Recycle
2524 */
2525 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_003, TestSize.Level0)
2526 {
2527 sptr<Surface> videoSurface = player_->GetVideoSurface();
2528 ASSERT_NE(nullptr, videoSurface);
2529 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2530 for (uint32_t i = 0; i < srcVec.size(); i++) {
2531 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2532 system("param set sys.media.player.resource.type NetWork");
2533 }
2534 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2535 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2536 EXPECT_EQ(MSERR_OK, player_->Prepare());
2537 EXPECT_EQ(MSERR_OK, player_->Play());
2538 sleep(15);
2539 char str[100]; // 100: str len
2540 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2541 system(str);
2542 system("hidumper -s 1909 -a \"-t 3\"");
2543 EXPECT_EQ(MSERR_OK, player_->Play());
2544 EXPECT_EQ(MSERR_OK, player_->Reset());
2545 system("param set sys.media.player.resource.type Local");
2546 }
2547 }
2548
2549 /**
2550 * @tc.name : Test Player Mem Recycle
2551 * @tc.number: Player_Mem_Recycle_004
2552 * @tc.desc : Test Player Mem Recycle
2553 */
2554 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_004, TestSize.Level0)
2555 {
2556 sptr<Surface> videoSurface = player_->GetVideoSurface();
2557 ASSERT_NE(nullptr, videoSurface);
2558 std::vector<std::string> vec = {MEDIA_ROOT + "H264_MP3.mp4"};
2559 for (uint32_t i = 0; i < vec.size(); i++) {
2560 if (vec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2561 system("param set sys.media.player.resource.type NetWork");
2562 }
2563 const auto ret = MSERR_OK;
2564 ASSERT_EQ(ret, player_->SetSource(vec[i]));
2565 EXPECT_EQ(ret, player_->SetVideoSurface(videoSurface));
2566 EXPECT_EQ(ret, player_->Prepare());
2567 EXPECT_EQ(ret, player_->Play());
2568 EXPECT_EQ(ret, player_->Pause());
2569 char str[100]; // 100: str len
2570 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2571 system(str);
2572 system("hidumper -s 1909 -a \"-t 3\"");
2573 int32_t currentTime = 0;
2574 std::vector<Format> videoTrack;
2575 std::vector<Format> audioTrack;
2576 int32_t duration = 0;
2577 PlaybackRateMode mode;
2578 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
2579 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
2580 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(currentTime));
2581 EXPECT_NE(0, player_->GetVideoWidth());
2582 EXPECT_NE(0, player_->GetVideoHeight());
2583 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
2584 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2585 int32_t index;
2586 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, index));
2587 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_VID, index));
2588 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_SUBTITLE, index));
2589 EXPECT_NE(MSERR_OK, player_->GetCurrentTrack(100, index));
2590 EXPECT_EQ(false, player_->IsPlaying());
2591 EXPECT_EQ(false, player_->IsLooping());
2592 EXPECT_EQ(MSERR_OK, player_->Seek(1000, SEEK_NEXT_SYNC));
2593 EXPECT_EQ(MSERR_OK, player_->Reset());
2594 system("param set sys.media.player.resource.type Local");
2595 }
2596 }
2597
2598 /**
2599 * @tc.name : Test Player Mem Recycle
2600 * @tc.number: Player_Mem_Recycle_005
2601 * @tc.desc : Test Player Mem Recycle
2602 */
2603 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_005, TestSize.Level0)
2604 {
2605 sptr<Surface> videoSurface = player_->GetVideoSurface();
2606 ASSERT_NE(nullptr, videoSurface);
2607 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2608 for (uint32_t i = 0; i < srcVec.size(); i++) {
2609 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2610 system("param set sys.media.player.resource.type NetWork");
2611 }
2612 const auto result = MSERR_OK;
2613 ASSERT_EQ(result, player_->SetSource(srcVec[i]));
2614 EXPECT_EQ(result, player_->SetVideoSurface(videoSurface));
2615 EXPECT_EQ(result, player_->Prepare());
2616 EXPECT_EQ(result, player_->Play());
2617 EXPECT_EQ(result, player_->Pause());
2618 char str[100]; // 100: str len
2619 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2620 system(str);
2621 system("hidumper -s 1909 -a \"-t 3\"");
2622 EXPECT_EQ(result, player_->Reset());
2623 system("param set sys.media.player.resource.type Local");
2624 }
2625 }
2626
2627 /**
2628 * @tc.name : Test Player Mem Recycle
2629 * @tc.number: Player_Mem_Recycle_006
2630 * @tc.desc : Test Player Mem Recycle
2631 */
2632 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_006, TestSize.Level0)
2633 {
2634 sptr<Surface> videoSurface = player_->GetVideoSurface();
2635 ASSERT_NE(nullptr, videoSurface);
2636 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2637 for (uint32_t i = 0; i < srcVec.size(); i++) {
2638 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2639 system("param set sys.media.player.resource.type NetWork");
2640 }
2641 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2642 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2643 EXPECT_EQ(MSERR_OK, player_->Prepare());
2644 EXPECT_EQ(MSERR_OK, player_->Play());
2645 EXPECT_EQ(MSERR_OK, player_->Pause());
2646 char str[100]; // 100: str len
2647 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2648 system(str);
2649 system("hidumper -s 1909 -a \"-t 3\"");
2650 EXPECT_EQ(MSERR_OK, player_->Reset());
2651 system("param set sys.media.player.resource.type Local");
2652 }
2653 }
2654
2655 /**
2656 * @tc.name : Test Player Mem Recycle
2657 * @tc.number: Player_Mem_Recycle_007
2658 * @tc.desc : Test Player Mem Recycle
2659 */
2660 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_007, TestSize.Level0)
2661 {
2662 sptr<Surface> videoSurface = player_->GetVideoSurface();
2663 ASSERT_NE(nullptr, videoSurface);
2664 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2665 std::vector<PlaybackRateMode> speedMode = {SPEED_FORWARD_2_00_X, SPEED_FORWARD_1_25_X};
2666 for (uint32_t i = 0; i < srcVec.size(); i++) {
2667 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2668 system("param set sys.media.player.resource.type NetWork");
2669 }
2670 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2671 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2672 EXPECT_EQ(MSERR_OK, player_->Prepare());
2673 EXPECT_EQ(MSERR_OK, player_->Play());
2674 EXPECT_EQ(MSERR_OK, player_->Pause());
2675 char str[100]; // 100: str len
2676 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2677 system(str);
2678 system("hidumper -s 1909 -a \"-t 3\"");
2679 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(speedMode[i]));
2680 EXPECT_EQ(MSERR_OK, player_->Reset());
2681 system("param set sys.media.player.resource.type Local");
2682 }
2683 }
2684
2685 /**
2686 * @tc.name : Test Player Mem Recycle
2687 * @tc.number: Player_Mem_Recycle_008
2688 * @tc.desc : Test Player Mem Recycle
2689 */
2690 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_008, TestSize.Level0)
2691 {
2692 sptr<Surface> videoSurface = player_->GetVideoSurface();
2693 ASSERT_NE(nullptr, videoSurface);
2694 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2695 for (uint32_t i = 0; i < srcVec.size(); i++) {
2696 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2697 system("param set sys.media.player.resource.type NetWork");
2698 }
2699 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2700 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2701 EXPECT_EQ(MSERR_OK, player_->Prepare());
2702 EXPECT_EQ(MSERR_OK, player_->Play());
2703 EXPECT_EQ(MSERR_OK, player_->Pause());
2704 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
2705 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
2706 EXPECT_EQ(MSERR_OK, player_->SetVolume(0.5, 0.5));
2707 char str[100]; // 100: str len
2708 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2709 system(str);
2710 system("hidumper -s 1909 -a \"-t 3\"");
2711 EXPECT_EQ(MSERR_OK, player_->SetLooping(false));
2712 EXPECT_EQ(MSERR_OK, player_->Reset());
2713 system("param set sys.media.player.resource.type Local");
2714 }
2715 }
2716
2717 /**
2718 * @tc.name : Test Player Mem Recycle
2719 * @tc.number: Player_Mem_Recycle_009
2720 * @tc.desc : Test Player Mem Recycle
2721 */
2722 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_009, TestSize.Level0)
2723 {
2724 sptr<Surface> videoSurface = player_->GetVideoSurface();
2725 ASSERT_NE(nullptr, videoSurface);
2726 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2727 for (uint32_t i = 0; i < srcVec.size(); i++) {
2728 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2729 system("param set sys.media.player.resource.type NetWork");
2730 }
2731 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2732 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2733 EXPECT_EQ(MSERR_OK, player_->Prepare());
2734 EXPECT_EQ(MSERR_OK, player_->Play());
2735 EXPECT_EQ(MSERR_OK, player_->Pause());
2736 char str[100]; // 100: str len
2737 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2738 system(str);
2739 system("hidumper -s 1909 -a \"-t 3\"");
2740 EXPECT_EQ(MSERR_OK, player_->SelectBitRate(0));
2741 EXPECT_EQ(MSERR_OK, player_->Reset());
2742 system("param set sys.media.player.resource.type Local");
2743 }
2744 }
2745
2746 /**
2747 * @tc.name : Test Player Mem Recycle
2748 * @tc.number: Player_Mem_Recycle_010
2749 * @tc.desc : Test Player Mem Recycle
2750 */
2751 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_010, TestSize.Level0)
2752 {
2753 sptr<Surface> videoSurface = player_->GetVideoSurface();
2754 ASSERT_NE(nullptr, videoSurface);
2755 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2756 for (uint32_t i = 0; i < srcVec.size(); i++) {
2757 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2758 system("param set sys.media.player.resource.type NetWork");
2759 }
2760 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2761 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2762 EXPECT_EQ(MSERR_OK, player_->Prepare());
2763 EXPECT_EQ(MSERR_OK, player_->Play());
2764 EXPECT_EQ(MSERR_OK, player_->Stop());
2765 char str[100]; // 100: str len
2766 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2767 system(str);
2768 system("hidumper -s 1909 -a \"-t 3\"");
2769 EXPECT_EQ(MSERR_OK, player_->Reset());
2770 system("param set sys.media.player.resource.type Local");
2771 }
2772 }
2773
2774 /**
2775 * @tc.name : Test Player Mem Recycle
2776 * @tc.number: Player_Mem_Recycle_011
2777 * @tc.desc : Test Player Mem Recycle
2778 */
2779 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_011, TestSize.Level0)
2780 {
2781 sptr<Surface> videoSurface = player_->GetVideoSurface();
2782 ASSERT_NE(nullptr, videoSurface);
2783 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2784 for (uint32_t i = 0; i < srcVec.size(); i++) {
2785 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2786 system("param set sys.media.player.resource.type NetWork");
2787 }
2788 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2789 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2790 EXPECT_EQ(MSERR_OK, player_->Prepare());
2791 EXPECT_EQ(MSERR_OK, player_->Play());
2792 EXPECT_EQ(MSERR_OK, player_->Pause());
2793 char str[100]; // 100: str len
2794 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2795 system(str);
2796 system("hidumper -s 1909 -a \"-t 2\"");
2797 EXPECT_EQ(MSERR_OK, player_->Reset());
2798 system("param set sys.media.player.resource.type Local");
2799 }
2800 }
2801
2802 /**
2803 * @tc.name : Test Player Mem Recycle
2804 * @tc.number: Player_Mem_Recycle_012
2805 * @tc.desc : Test Player Mem Recycle
2806 */
2807 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_012, TestSize.Level0)
2808 {
2809 sptr<Surface> videoSurface = player_->GetVideoSurface();
2810 ASSERT_NE(nullptr, videoSurface);
2811 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2812 for (uint32_t i = 0; i < srcVec.size(); i++) {
2813 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2814 system("param set sys.media.player.resource.type NetWork");
2815 }
2816 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2817 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2818 EXPECT_EQ(MSERR_OK, player_->Prepare());
2819 EXPECT_EQ(MSERR_OK, player_->Play());
2820 EXPECT_EQ(MSERR_OK, player_->Pause());
2821 char str[100]; // 100: str len
2822 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2823 system(str);
2824 system("hidumper -s 1909 -a \"-t 4\"");
2825 EXPECT_EQ(MSERR_OK, player_->Reset());
2826 system("param set sys.media.player.resource.type Local");
2827 }
2828 }
2829
2830 /**
2831 * @tc.name : Test Player Mem Recycle
2832 * @tc.number: Player_Mem_Recycle_013
2833 * @tc.desc : Test Player Mem Recycle
2834 */
2835 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_013, TestSize.Level0)
2836 {
2837 sptr<Surface> videoSurface = player_->GetVideoSurface();
2838 ASSERT_NE(nullptr, videoSurface);
2839 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_MP3.mp4"};
2840 for (uint32_t i = 0; i < srcVec.size(); i++) {
2841 if (srcVec[i] == MEDIA_ROOT + "H264_MP3.mp4") {
2842 system("param set sys.media.player.resource.type NetWork");
2843 }
2844 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2845 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2846 EXPECT_EQ(MSERR_OK, player_->Prepare());
2847 EXPECT_EQ(MSERR_OK, player_->Play());
2848 EXPECT_EQ(MSERR_OK, player_->Pause());
2849 char str[100]; // 100: str len
2850 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2851 system(str);
2852 system("hidumper -s 1909 -a \"-f 3\"");
2853 EXPECT_EQ(MSERR_OK, player_->Reset());
2854 system("param set sys.media.player.resource.type Local");
2855 system("killall memmgrservice");
2856 sleep(1);
2857 }
2858 }
2859
2860 /**
2861 * @tc.name : Test Player Mem Recycle
2862 * @tc.number: Player_Mem_Recycle_014
2863 * @tc.desc : Test Player Mem Recycle
2864 */
2865 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_014, TestSize.Level0)
2866 {
2867 sptr<Surface> videoSurface = player_->GetVideoSurface();
2868 ASSERT_NE(nullptr, videoSurface);
2869 std::vector<std::string> srcVector = {MEDIA_ROOT + "H264_AAC.mp4"};
2870 for (uint32_t i = 0; i < srcVector.size(); i++) {
2871 if (srcVector[i] == MEDIA_ROOT + "H264_AAC.mp4") {
2872 system("param set sys.media.player.resource.type NetWork");
2873 }
2874 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVector[i]));
2875 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2876 EXPECT_EQ(MSERR_OK, player_->Prepare());
2877 char str[100]; // 100: str len
2878 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2879 system(str);
2880 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 2);
2881 system(str);
2882 sleep(30);
2883 EXPECT_EQ(MSERR_OK, player_->Play());
2884 EXPECT_EQ(MSERR_OK, player_->Reset());
2885 system("param set sys.media.player.resource.type Local");
2886 }
2887 }
2888
2889 /**
2890 * @tc.name : Test Player Mem Recycle
2891 * @tc.number: Player_Mem_Recycle_015
2892 * @tc.desc : Test Player Mem Recycle
2893 */
2894 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_015, TestSize.Level0)
2895 {
2896 sptr<Surface> videoSurface = player_->GetVideoSurface();
2897 ASSERT_NE(nullptr, videoSurface);
2898 std::vector<std::string> srcVec = {MEDIA_ROOT + "H264_AAC.mp4"};
2899 for (uint32_t i = 0; i < srcVec.size(); i++) {
2900 if (srcVec[i] == MEDIA_ROOT + "H264_AAC.mp4") {
2901 system("param set sys.media.player.resource.type NetWork");
2902 }
2903 ASSERT_EQ(MSERR_OK, player_->SetSource(srcVec[i]));
2904 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2905 EXPECT_EQ(MSERR_OK, player_->Prepare());
2906 char str[100]; // 100: str len
2907 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2908 system(str);
2909 system("hidumper -s 3002 -a \"player\"");
2910 sleep(30);
2911 system("hidumper -s 3002 -a \"player\"");
2912 EXPECT_EQ(MSERR_OK, player_->Play());
2913 EXPECT_EQ(MSERR_OK, player_->Stop());
2914 EXPECT_EQ(MSERR_OK, player_->Reset());
2915 system("param set sys.media.player.resource.type Local");
2916 }
2917 }
2918
2919 /**
2920 * @tc.name : Test Player Mem Recycle
2921 * @tc.number: Player_Mem_Recycle_016
2922 * @tc.desc : Test Player Mem Recycle
2923 */
2924 HWTEST_F(PlayerServerUnitTest, Player_Mem_Recycle_016, TestSize.Level0)
2925 {
2926 int32_t duration = 0;
2927 std::vector<Format> videoTrack;
2928 std::vector<Format> audioTrack;
2929 PlaybackRateMode mode;
2930 int32_t index = 0;
2931 EXPECT_EQ(MSERR_OK, player_->SetVolume(0.9, 0.9));
2932 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
2933 sptr<Surface> videoSurface = player_->GetVideoSurface();
2934 ASSERT_NE(nullptr, videoSurface);
2935 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2936 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
2937 EXPECT_EQ(true, player_->IsLooping());
2938 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
2939 char str[100]; // 100: str len
2940 sprintf_s(str, 100, "hidumper -s 1909 -a \"-d %d %d %d\"", getpid(), getuid(), 4);
2941 system(str);
2942 system("hidumper -s 1909 -a \"-t 4\"");
2943 EXPECT_EQ(720, player_->GetVideoWidth());
2944 EXPECT_EQ(480, player_->GetVideoHeight());
2945 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
2946 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
2947 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
2948 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2949 EXPECT_EQ(SPEED_FORWARD_1_00_X, mode);
2950 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_0_50_X));
2951 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2952 EXPECT_EQ(SPEED_FORWARD_0_50_X, mode);
2953 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
2954 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
2955 EXPECT_EQ(SPEED_FORWARD_2_00_X, mode);
2956
2957 EXPECT_EQ(false, player_->IsPlaying());
2958 EXPECT_EQ(true, player_->IsLooping());
2959
2960 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_AUD, index));
2961 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_VID, index));
2962 EXPECT_EQ(MSERR_OK, player_->GetCurrentTrack(MediaType::MEDIA_TYPE_SUBTITLE, index));
2963 EXPECT_NE(MSERR_OK, player_->GetCurrentTrack(100, index));
2964
2965 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
2966 EXPECT_EQ(MSERR_OK, player_->Seek(duration, PlayerSeekMode::SEEK_PREVIOUS_SYNC));
2967 EXPECT_EQ(MSERR_OK, player_->Reset());
2968 EXPECT_EQ(MSERR_OK, player_->Release());
2969 }
2970
2971 /**
2972 * @tc.name : Test SetEffect API
2973 * @tc.number: Player_SetEffect_001
2974 * @tc.desc : Test Player SetEffect state machine
2975 */
2976 HWTEST_F(PlayerServerUnitTest, Player_SetEffect_001, TestSize.Level0)
2977 {
2978 Format format;
2979 const float FLOAT_VALUE = 1.0;
2980 const double DOUBLE_VALUE = 2.5;
2981 const std::string STRING_VALUE = "player_test";
2982 const int32_t INT_VALUE = 1;
2983 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, OHOS::AudioStandard::AudioEffectMode::EFFECT_NONE);
2984 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2985 (void)format.PutFloatValue(PlayerKeys::AUDIO_EFFECT_MODE, FLOAT_VALUE);
2986 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2987 (void)format.PutDoubleValue(PlayerKeys::AUDIO_EFFECT_MODE, DOUBLE_VALUE);
2988 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2989 (void)format.PutStringValue(PlayerKeys::AUDIO_EFFECT_MODE, STRING_VALUE);
2990 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2991 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, INT_VALUE);
2992 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
2993
2994 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "01.mp3"));
2995 sptr<Surface> videoSurface = player_->GetVideoSurface();
2996 ASSERT_NE(nullptr, videoSurface);
2997 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
2998
2999 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
3000 EXPECT_EQ(MSERR_OK, player_->Prepare());
3001 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
3002 EXPECT_EQ(MSERR_OK, player_->Play());
3003 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
3004 EXPECT_EQ(MSERR_OK, player_->Pause());
3005 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
3006 EXPECT_EQ(MSERR_OK, player_->Stop());
3007 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
3008 EXPECT_EQ(MSERR_OK, player_->Prepare());
3009 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
3010 EXPECT_EQ(MSERR_OK, player_->Reset());
3011 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
3012 EXPECT_EQ(MSERR_OK, player_->Release());
3013 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
3014 }
3015
3016 /**
3017 * @tc.name : Test SetEffect API
3018 * @tc.number: Player_SetEffect_002
3019 * @tc.desc : Test Player SetEffect param
3020 */
3021 HWTEST_F(PlayerServerUnitTest, Player_SetEffect_002, TestSize.Level0)
3022 {
3023 Format format;
3024 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "01.mp3"));
3025 sptr<Surface> videoSurface = player_->GetVideoSurface();
3026 ASSERT_NE(nullptr, videoSurface);
3027 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3028 EXPECT_EQ(MSERR_OK, player_->Prepare());
3029
3030 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT);
3031 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
3032 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, OHOS::AudioStandard::AudioEffectMode::EFFECT_NONE);
3033 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
3034 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, 100); // 100 is an invalid parameter.
3035 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
3036 (void)format.PutIntValue(PlayerKeys::AUDIO_EFFECT_MODE, -1); // -1 is an invalid parameter.
3037 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
3038
3039 EXPECT_EQ(MSERR_OK, player_->Release());
3040 }
3041
3042 /**
3043 * @tc.name : Test media error
3044 * @tc.number: Player_Media_Error
3045 * @tc.desc : Test Player Media Error
3046 */
3047 HWTEST_F(PlayerServerUnitTest, Player_Media_Error, TestSize.Level0)
3048 {
3049 std::array<MediaServiceErrCode, 5> errCodes = {MSERR_OK, MSERR_NO_MEMORY, MSERR_INVALID_OPERATION,
3050 MSERR_INVALID_VAL, MSERR_UNKNOWN};
3051 for (const auto& code : errCodes) {
3052 MediaServiceErrCodeTest(code);
3053 }
3054 for (MediaServiceErrCode code = MSERR_SERVICE_DIED; code < MSERR_EXTEND_START;
3055 code = (MediaServiceErrCode)(code + 1)) {
3056 MediaServiceErrCodeTest(code);
3057 }
3058 MediaServiceErrCodeTest(MSERR_EXTEND_START);
3059
3060 for (auto code = MSERR_EXT_OK; code <= MSERR_EXT_UNSUPPORT; code = (MediaServiceExtErrCode)(code + 1)) {
3061 EXPECT_EQ(MSEXTERRCODE_INFOS.at(code), MSExtErrorToString(code));
3062 }
3063 EXPECT_EQ(MSEXTERRCODE_INFOS.at(MSERR_EXT_EXTEND_START), MSExtErrorToString(MSERR_EXT_EXTEND_START));
3064
3065 std::array<MediaServiceExtErrCodeAPI9, 5> errCodesAPI9 = {MSERR_EXT_API9_OK, MSERR_EXT_API9_NO_PERMISSION,
3066 MSERR_EXT_API9_PERMISSION_DENIED, MSERR_EXT_API9_INVALID_PARAMETER, MSERR_EXT_API9_UNSUPPORT_CAPABILITY};
3067 for (const auto& errCodeApi9 : errCodesAPI9) {
3068 MediaServiceExtErrCodeAPI9Test(errCodeApi9);
3069 }
3070 for (auto code = MSERR_EXT_API9_NO_MEMORY;
3071 code <= MSERR_EXT_API9_AUDIO_INTERRUPTED; code = (MediaServiceExtErrCodeAPI9)(code + 1)) {
3072 MediaServiceExtErrCodeAPI9Test(code);
3073 }
3074 }
3075
3076 /**
3077 * @tc.name : Test ChangeSurface
3078 * @tc.number: Player_ChangeSurface_001
3079 * @tc.desc : Test video player change surface in idle state
3080 */
3081 HWTEST_F(PlayerServerUnitTest, Player_ChangeSurface_001, TestSize.Level0)
3082 {
3083 sptr<Surface> videoSurface = player_->GetVideoSurface();
3084 ASSERT_NE(nullptr, videoSurface);
3085 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
3086 }
3087
3088 /**
3089 * @tc.name : Test ChangeSurface
3090 * @tc.number: Player_ChangeSurface_002
3091 * @tc.desc : Test video player change surface in released state
3092 */
3093 HWTEST_F(PlayerServerUnitTest, Player_ChangeSurface_002, TestSize.Level0)
3094 {
3095 sptr<Surface> videoSurface = player_->GetVideoSurface();
3096 ASSERT_NE(nullptr, videoSurface);
3097 player_->Release();
3098 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
3099 }
3100
3101 /**
3102 * @tc.name : Test ChangeSurface
3103 * @tc.number: Player_ChangeSurface_003
3104 * @tc.desc : Test video player change surface in error state
3105 */
3106 HWTEST_F(PlayerServerUnitTest, Player_ChangeSurface_003, TestSize.Level0)
3107 {
3108 int32_t ret = player_->SetSource(MEDIA_ROOT + "error.mp4");
3109 EXPECT_EQ(MSERR_OK, ret);
3110 sptr<Surface> videoSurface = player_->GetVideoSurface();
3111 ASSERT_NE(nullptr, videoSurface);
3112 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3113 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
3114 sleep(PLAYING_TIME_2_SEC);
3115 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
3116 ASSERT_NE(nullptr, nextVideoSurface);
3117 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
3118 }
3119
3120 /**
3121 * @tc.name : Test ChangeSurface
3122 * @tc.number: Player_ChangeSurface_004
3123 * @tc.desc : Test video player change surface in initialized state
3124 */
3125 HWTEST_F(PlayerServerUnitTest, Player_ChangeSurface_004, TestSize.Level0)
3126 {
3127 int32_t ret = player_->SetSource(VIDEO_FILE1);
3128 EXPECT_EQ(MSERR_OK, ret);
3129 sptr<Surface> videoSurface = player_->GetVideoSurface();
3130 ASSERT_NE(nullptr, videoSurface);
3131 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3132 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
3133 ASSERT_NE(nullptr, nextVideoSurface);
3134 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
3135 }
3136
3137 /**
3138 * @tc.name : Test ChangeSurface
3139 * @tc.number: Player_ChangeSurface_005
3140 * @tc.desc : Test video player change surface in prepared state
3141 */
3142 HWTEST_F(PlayerServerUnitTest, Player_ChangeSurface_005, TestSize.Level0)
3143 {
3144 int32_t ret = player_->SetSource(VIDEO_FILE1);
3145 EXPECT_EQ(MSERR_OK, ret);
3146 sptr<Surface> videoSurface = player_->GetVideoSurface();
3147 ASSERT_NE(nullptr, videoSurface);
3148 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3149 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3150 sleep(PLAYING_TIME_2_SEC);
3151 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
3152 ASSERT_NE(nullptr, nextVideoSurface);
3153 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
3154 }
3155
3156 /**
3157 * @tc.name : Test ChangeSurface
3158 * @tc.number: Player_ChangeSurface_006
3159 * @tc.desc : Test video player change surface in playing state
3160 */
3161 HWTEST_F(PlayerServerUnitTest, Player_ChangeSurface_006, TestSize.Level0)
3162 {
3163 int32_t ret = player_->SetSource(VIDEO_FILE1);
3164 EXPECT_EQ(MSERR_OK, ret);
3165 sptr<Surface> videoSurface = player_->GetVideoSurface();
3166 ASSERT_NE(nullptr, videoSurface);
3167 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3168 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3169 sleep(PLAYING_TIME_2_SEC);
3170 EXPECT_EQ(MSERR_OK, player_->Play());
3171 sleep(PLAYING_TIME_2_SEC);
3172 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
3173 ASSERT_NE(nullptr, nextVideoSurface);
3174 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
3175 }
3176
3177 /**
3178 * @tc.name : Test ChangeSurface
3179 * @tc.number: Player_ChangeSurface_007
3180 * @tc.desc : Test video player change surface in paused state
3181 */
3182 HWTEST_F(PlayerServerUnitTest, Player_ChangeSurface_007, TestSize.Level0)
3183 {
3184 int32_t ret = player_->SetSource(VIDEO_FILE1);
3185 EXPECT_EQ(MSERR_OK, ret);
3186 sptr<Surface> videoSurface = player_->GetVideoSurface();
3187 ASSERT_NE(nullptr, videoSurface);
3188 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3189 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3190 sleep(PLAYING_TIME_2_SEC);
3191 EXPECT_EQ(MSERR_OK, player_->Play());
3192 sleep(PLAYING_TIME_2_SEC);
3193 EXPECT_EQ(MSERR_OK, player_->Pause());
3194 sleep(PLAYING_TIME_2_SEC);
3195 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
3196 ASSERT_NE(nullptr, nextVideoSurface);
3197 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
3198 }
3199
3200 /**
3201 * @tc.name : Test ChangeSurface
3202 * @tc.number: Player_ChangeSurface_008
3203 * @tc.desc : Test video player change surface in stopped state
3204 */
3205 HWTEST_F(PlayerServerUnitTest, Player_ChangeSurface_008, TestSize.Level0)
3206 {
3207 int32_t ret = player_->SetSource(VIDEO_FILE1);
3208 EXPECT_EQ(MSERR_OK, ret);
3209 sptr<Surface> videoSurface = player_->GetVideoSurface();
3210 ASSERT_NE(nullptr, videoSurface);
3211 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3212 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3213 sleep(PLAYING_TIME_2_SEC);
3214 EXPECT_EQ(MSERR_OK, player_->Play());
3215 sleep(PLAYING_TIME_2_SEC);
3216 EXPECT_EQ(MSERR_OK, player_->Stop());
3217 sleep(PLAYING_TIME_2_SEC);
3218 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
3219 ASSERT_NE(nullptr, nextVideoSurface);
3220 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
3221 }
3222
3223 /**
3224 * @tc.name : Test ChangeSurface
3225 * @tc.number: Player_ChangeSurface_009
3226 * @tc.desc : Test video player change surface in completed state
3227 */
3228 HWTEST_F(PlayerServerUnitTest, Player_ChangeSurface_009, TestSize.Level0)
3229 {
3230 int32_t ret = player_->SetSource(VIDEO_FILE1);
3231 EXPECT_EQ(MSERR_OK, ret);
3232 sptr<Surface> videoSurface = player_->GetVideoSurface();
3233 ASSERT_NE(nullptr, videoSurface);
3234 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3235 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3236 sleep(PLAYING_TIME_2_SEC);
3237 EXPECT_EQ(MSERR_OK, player_->Play());
3238 int32_t duration = 0;
3239 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
3240 sleep(PLAYING_TIME_10_SEC);
3241 sptr<Surface> nextVideoSurface = player_->GetVideoSurfaceNext();
3242 ASSERT_NE(nullptr, nextVideoSurface);
3243 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(nextVideoSurface));
3244 }
3245
3246 /**
3247 * @tc.name : Test SetPlaybackSpeed API
3248 * @tc.number: Player_SetPlaybackSpeed_003
3249 * @tc.desc : Test Player SetPlaybackSpeed SPEED_FORWARD_0_50_X
3250 */
3251 HWTEST_F(PlayerServerUnitTest, Player_SetPlaybackSpeed_003, TestSize.Level0)
3252 {
3253 PlaybackRateMode mode;
3254 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3255 sptr<Surface> videoSurface = player_->GetVideoSurface();
3256 ASSERT_NE(nullptr, videoSurface);
3257 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3258 EXPECT_EQ(MSERR_OK, player_->Prepare());
3259 EXPECT_EQ(MSERR_OK, player_->Play());
3260 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_0_50_X));
3261 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
3262 EXPECT_EQ(SPEED_FORWARD_0_50_X, mode);
3263 }
3264
3265 /**
3266 * @tc.name : Test SetPlaybackSpeed API
3267 * @tc.number: Player_SetPlaybackSpeed_004
3268 * @tc.desc : Test Player SetPlaybackSpeed SPEED_FORWARD_1_50_X
3269 */
3270 HWTEST_F(PlayerServerUnitTest, Player_SetPlaybackSpeed_004, TestSize.Level0)
3271 {
3272 PlaybackRateMode mode;
3273 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3274 sptr<Surface> videoSurface = player_->GetVideoSurface();
3275 ASSERT_NE(nullptr, videoSurface);
3276 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3277 EXPECT_EQ(MSERR_OK, player_->Prepare());
3278 EXPECT_EQ(MSERR_OK, player_->Play());
3279 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_1_50_X));
3280 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
3281 EXPECT_EQ(SPEED_FORWARD_1_50_X, mode);
3282 }
3283
3284 /**
3285 * @tc.name : Test SetPlaybackSpeed API
3286 * @tc.number: Player_SetPlaybackSpeed_005
3287 * @tc.desc : Test Player SetPlaybackSpeed SPEED_FORWARD_1_50_X
3288 */
3289 HWTEST_F(PlayerServerUnitTest, Player_SetPlaybackSpeed_005, TestSize.Level0)
3290 {
3291 PlaybackRateMode mode;
3292 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3293 sptr<Surface> videoSurface = player_->GetVideoSurface();
3294 ASSERT_NE(nullptr, videoSurface);
3295 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3296 EXPECT_EQ(MSERR_OK, player_->Prepare());
3297 EXPECT_EQ(MSERR_OK, player_->Play());
3298 int32_t speed = -1;
3299 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(static_cast<OHOS::Media::PlaybackRateMode>(speed)));
3300 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
3301 EXPECT_EQ(-1, mode);
3302 }
3303
3304 /**
3305 * @tc.name : Test SetSurface API
3306 * @tc.number: Player_SetSurface_001
3307 * @tc.desc : Test Player SetSurface->SetSurface
3308 */
3309 HWTEST_F(PlayerServerUnitTest, Player_SetSurface_001, TestSize.Level0)
3310 {
3311 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3312 sptr<Surface> videoSurface = player_->GetVideoSurface();
3313 ASSERT_NE(nullptr, videoSurface);
3314 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3315 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3316 int32_t ret = player_->PrepareAsync();
3317 if (ret == MSERR_OK) {
3318 PlayFunTest(LOCAL_PLAY);
3319 }
3320 }
3321
3322 /**
3323 * @tc.name : Test AddSubSource
3324 * @tc.number: Player_AddSubSource_001
3325 * @tc.desc : Test Player AddSubSource state machine
3326 */
3327 HWTEST_F(PlayerServerUnitTest, Player_AddSubSource_001, TestSize.Level0)
3328 {
3329 ASSERT_NE(MSERR_OK, player_->AddSubSource(SUBTITLE_SRT_FIELE, 0, 0));
3330 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4", 0, 0));
3331 sptr<Surface> videoSurface = player_->GetVideoSurface();
3332 ASSERT_NE(nullptr, videoSurface);
3333 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3334 EXPECT_NE(MSERR_OK, player_->AddSubSource(SUBTITLE_SRT_FIELE)); // Illegal state machine
3335 EXPECT_EQ(MSERR_OK, player_->Prepare());
3336 EXPECT_EQ(MSERR_OK, player_->Play());
3337 EXPECT_NE(SUBTITLE_0_SEC, player_->GetSubtitleText(SUBTITLE_0_SEC));
3338 EXPECT_EQ(MSERR_OK, player_->Pause());
3339 EXPECT_EQ(MSERR_OK, player_->Stop());
3340 EXPECT_EQ(MSERR_OK, player_->Reset());
3341 EXPECT_EQ(MSERR_OK, player_->Release());
3342 }
3343
3344 /**
3345 * @tc.name : Test AddSubSource
3346 * @tc.number: Player_AddSubSource_002
3347 * @tc.desc : Test Player AddSubSource behavior
3348 */
3349 HWTEST_F(PlayerServerUnitTest, Player_AddSubSource_002, TestSize.Level0)
3350 {
3351 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
3352 sptr<Surface> videoSurface = player_->GetVideoSurface();
3353 ASSERT_NE(nullptr, videoSurface);
3354 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3355 EXPECT_NE(MSERR_OK, player_->AddSubSource(SUBTITLE_SRT_FIELE, 0, 0));
3356 EXPECT_EQ(MSERR_OK, player_->Prepare());
3357 EXPECT_EQ(MSERR_OK, player_->Play());
3358 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_5_SEC, SEEK_CLOSEST));
3359 EXPECT_EQ("", player_->GetSubtitleText(""));
3360 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST));
3361 EXPECT_EQ("", player_->GetSubtitleText(""));
3362 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_5_SEC, SEEK_NEXT_SYNC));
3363 EXPECT_EQ("", player_->GetSubtitleText(""));
3364 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC));
3365 EXPECT_EQ("", player_->GetSubtitleText(""));
3366 int duration = 0;
3367 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3368 EXPECT_EQ(MSERR_OK, player_->Play());
3369 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
3370 EXPECT_EQ("", player_->GetSubtitleText(""));
3371 }
3372
3373 /**
3374 * @tc.name : Test PlayerServer Stop
3375 * @tc.number: PlayerServer_Stop_001
3376 * @tc.desc : Test PlayerServer Stop on different status
3377 */
3378 HWTEST_F(PlayerServerUnitTest, PlayerServer_Stop_001, TestSize.Level0)
3379 {
3380 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
3381 sptr<Surface> videoSurface = player_->GetVideoSurface();
3382 ASSERT_NE(nullptr, videoSurface);
3383 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3384 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3385 EXPECT_EQ(MSERR_OK, player_->Stop());
3386 }
3387
3388 /**
3389 * @tc.name : Test PlayerServer Stop
3390 * @tc.number: PlayerServer_Stop_002
3391 * @tc.desc : Test PlayerServer Stop on different status
3392 */
3393 HWTEST_F(PlayerServerUnitTest, PlayerServer_Stop_002, TestSize.Level0)
3394 {
3395 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
3396 sptr<Surface> videoSurface = player_->GetVideoSurface();
3397 ASSERT_NE(nullptr, videoSurface);
3398 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3399 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3400 EXPECT_EQ(MSERR_OK, player_->Play());
3401 EXPECT_TRUE(player_->IsPlaying());
3402 EXPECT_EQ(MSERR_OK, player_->Stop());
3403 }
3404
3405 /**
3406 * @tc.name : Test PlayerServer Stop
3407 * @tc.number: PlayerServer_Stop_003
3408 * @tc.desc : Test PlayerServer Stop on different status
3409 */
3410 HWTEST_F(PlayerServerUnitTest, PlayerServer_Stop_003, TestSize.Level0)
3411 {
3412 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
3413 sptr<Surface> videoSurface = player_->GetVideoSurface();
3414 int32_t duration = 0;
3415 ASSERT_NE(nullptr, videoSurface);
3416 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3417 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3418 EXPECT_EQ(MSERR_OK, player_->Play());
3419 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3420 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_NEXT_SYNC));
3421 EXPECT_TRUE(player_->IsPlaying());
3422 sleep(PLAYING_TIME_2_SEC);
3423 EXPECT_EQ(MSERR_OK, player_->Stop());
3424 }
3425
3426 /**
3427 * @tc.name : Test PlayerServer Stop
3428 * @tc.number: PlayerServer_Stop_004
3429 * @tc.desc : Test PlayerServer Stop on different status
3430 */
3431 HWTEST_F(PlayerServerUnitTest, PlayerServer_Stop_004, TestSize.Level0)
3432 {
3433 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
3434 sptr<Surface> videoSurface = player_->GetVideoSurface();
3435 ASSERT_NE(nullptr, videoSurface);
3436 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3437 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3438 EXPECT_EQ(MSERR_OK, player_->Play());
3439 EXPECT_TRUE(player_->IsPlaying());
3440 EXPECT_EQ(MSERR_OK, player_->Pause());
3441 EXPECT_EQ(MSERR_OK, player_->Stop());
3442 }
3443
3444 /**
3445 * @tc.name : Test PlayerServer Stop
3446 * @tc.number: PlayerServer_Stop_005
3447 * @tc.desc : Test PlayerServer Stop on different status
3448 */
3449 HWTEST_F(PlayerServerUnitTest, PlayerServer_Stop_005, TestSize.Level0)
3450 {
3451 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "H264_AAC.mp4", 0, 0));
3452 sptr<Surface> videoSurface = player_->GetVideoSurface();
3453 ASSERT_NE(nullptr, videoSurface);
3454 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3455 EXPECT_NE(MSERR_OK, player_->Stop());
3456 }
3457
3458 /**
3459 * @tc.name : Test SetParameter Stop
3460 * @tc.number: Player_SetParameter_001
3461 * @tc.desc : Test Player SetParameter
3462 */
3463 HWTEST_F(PlayerServerUnitTest, Player_SetParameter_001, TestSize.Level0)
3464 {
3465 std::vector<Format> videoTrack;
3466 std::vector<Format> audioTrack;
3467 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3468 sptr<Surface> videoSurface = player_->GetVideoSurface();
3469 ASSERT_NE(nullptr, videoSurface);
3470 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3471 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3472 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
3473 Format format;
3474 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
3475 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
3476 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
3477 }
3478
3479 /**
3480 * @tc.name : Test SetParameter Stop
3481 * @tc.number: Player_SetParameter_002
3482 * @tc.desc : Test Player SetParameter
3483 */
3484 HWTEST_F(PlayerServerUnitTest, Player_SetParameter_002, TestSize.Level0)
3485 {
3486 std::vector<Format> videoTrack;
3487 std::vector<Format> audioTrack;
3488 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3489 sptr<Surface> videoSurface = player_->GetVideoSurface();
3490 ASSERT_NE(nullptr, videoSurface);
3491 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3492 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3493 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
3494 Format format;
3495 int32_t contentType = 1;
3496 int32_t scaleType = 1;
3497 int32_t streamUsage = 1;
3498 int32_t rendererFlags = 1;
3499 int32_t audioInterruptMode = 1;
3500 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE, scaleType);
3501 format.PutIntValue(PlayerKeys::CONTENT_TYPE, contentType);
3502 format.PutIntValue(PlayerKeys::STREAM_USAGE, streamUsage);
3503 format.PutIntValue(PlayerKeys::RENDERER_FLAG, rendererFlags);
3504 format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_MODE, audioInterruptMode);
3505 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
3506 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
3507 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
3508 }
3509
3510 /**
3511 * @tc.name : Test SetParameter Stop
3512 * @tc.number: Player_SetParameter_003
3513 * @tc.desc : Test Player SetParameter
3514 */
3515 HWTEST_F(PlayerServerUnitTest, Player_SetParameter_003, TestSize.Level0)
3516 {
3517 Format formatScaleType;
3518 Format formatContentType;
3519 Format formatStreamUsage;
3520 Format formatStreamUsageAndContentType;
3521 Format formatInterruptMode;
3522 std::vector<Format> videoTrack;
3523 std::vector<Format> audioTrack;
3524 int32_t contentType = 1;
3525 int32_t scaleType = 1;
3526 int32_t streamUsage = 1;
3527 int32_t audioInterruptMode = 1;
3528 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3529 sptr<Surface> videoSurface = player_->GetVideoSurface();
3530 ASSERT_NE(nullptr, videoSurface);
3531 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3532 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3533 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
3534
3535 formatScaleType.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE, scaleType);
3536 EXPECT_EQ(MSERR_OK, player_->SetParameter(formatScaleType));
3537
3538 formatContentType.PutIntValue(PlayerKeys::CONTENT_TYPE, contentType);
3539 EXPECT_EQ(MSERR_OK, player_->SetParameter(formatContentType));
3540
3541 formatStreamUsage.PutIntValue(PlayerKeys::STREAM_USAGE, streamUsage);
3542 EXPECT_EQ(MSERR_OK, player_->SetParameter(formatStreamUsage));
3543
3544 formatStreamUsageAndContentType.PutIntValue(PlayerKeys::CONTENT_TYPE, contentType);
3545 formatStreamUsageAndContentType.PutIntValue(PlayerKeys::STREAM_USAGE, streamUsage);
3546 EXPECT_EQ(MSERR_OK, player_->SetParameter(formatStreamUsageAndContentType));
3547
3548 formatInterruptMode.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_MODE, audioInterruptMode);
3549 EXPECT_EQ(MSERR_OK, player_->SetParameter(formatInterruptMode));
3550
3551 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
3552 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
3553 }
3554
3555 /**
3556 * @tc.name : Test Player state machine, invalid operation on stopped
3557 * @tc.number: Player_State_Machine_001
3558 * @tc.desc : Test Player state machine, invalid operation on stopped
3559 */
3560 HWTEST_F(PlayerServerUnitTest, Player_State_Machine_001, TestSize.Level0)
3561 {
3562 ASSERT_EQ(PlayerStates::PLAYER_IDLE, player_->GetState());
3563 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3564 ASSERT_EQ(MSERR_OK, player_->PrepareAsync());
3565 sleep(1);
3566 ASSERT_EQ(PlayerStates::PLAYER_PREPARED, player_->GetState());
3567 int32_t duration = 0;
3568 ASSERT_EQ(MSERR_OK, player_->GetDuration(duration));
3569 ASSERT_EQ(MSERR_OK, player_->Play());
3570 sleep(1);
3571 ASSERT_EQ(true, player_->IsPlaying());
3572 ASSERT_EQ(PlayerStates::PLAYER_STARTED, player_->GetState());
3573 ASSERT_EQ(MSERR_OK, player_->Stop());
3574 sleep(1);
3575 ASSERT_EQ(PlayerStates::PLAYER_STOPPED, player_->GetState());
3576 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Pause());
3577 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Play());
3578 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3579 }
3580
3581 /**
3582 * @tc.name : Test Player state machine, invalid operation on error
3583 * @tc.number: Player_State_Machine_002
3584 * @tc.desc : Test Player state machine, invalid operation on error
3585 */
3586 HWTEST_F(PlayerServerUnitTest, Player_State_Machine_002, TestSize.Level0)
3587 {
3588 ASSERT_EQ(PlayerStates::PLAYER_IDLE, player_->GetState());
3589 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "1kb.mp3"));
3590 ASSERT_NE(MSERR_OK, player_->PrepareAsync());
3591 sleep(1);
3592 ASSERT_EQ(PlayerStates::PLAYER_STATE_ERROR, player_->GetState());
3593 int32_t duration = 0;
3594 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->GetDuration(duration));
3595 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Seek(0, PlayerSeekMode::SEEK_NEXT_SYNC));
3596 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Play());
3597 sleep(1);
3598 ASSERT_EQ(false, player_->IsPlaying());
3599 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Stop());
3600 sleep(1);
3601 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Pause());
3602 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Play());
3603 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3604 ASSERT_EQ(MSERR_OK, player_->Reset());
3605 ASSERT_EQ(PlayerStates::PLAYER_IDLE, player_->GetState());
3606 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Reset());
3607 }
3608
3609 /**
3610 * @tc.name : Test Player state machine, invalid operation on idle
3611 * @tc.number: Player_State_Machine_003
3612 * @tc.desc : Test Player state machine, invalid operation on idle
3613 */
3614 HWTEST_F(PlayerServerUnitTest, Player_State_Machine_003, TestSize.Level0)
3615 {
3616 ASSERT_EQ(PlayerStates::PLAYER_IDLE, player_->GetState());
3617 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->PrepareAsync());
3618 sleep(1);
3619 int32_t duration = 0;
3620 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->GetDuration(duration));
3621 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Play());
3622 sleep(1);
3623 ASSERT_EQ(false, player_->IsPlaying());
3624 ASSERT_EQ(PlayerStates::PLAYER_IDLE, player_->GetState());
3625 ASSERT_EQ(MSERR_NO_MEMORY, player_->Seek(0, PlayerSeekMode::SEEK_NEXT_SYNC));
3626 sleep(1);
3627 ASSERT_EQ(false, player_->IsPlaying());
3628 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Pause());
3629 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Stop());
3630 }
3631
3632 /**
3633 * @tc.name : Test Player state machine, invalid operation on initialized
3634 * @tc.number: Player_State_Machine_004
3635 * @tc.desc : Test Player state machine, invalid operation on initialized
3636 */
3637 HWTEST_F(PlayerServerUnitTest, Player_State_Machine_004, TestSize.Level0)
3638 {
3639 ASSERT_EQ(PlayerStates::PLAYER_IDLE, player_->GetState());
3640 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3641 sleep(1);
3642 int32_t duration = 0;
3643 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->GetDuration(duration));
3644 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Seek(duration, PlayerSeekMode::SEEK_NEXT_SYNC));
3645 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Play());
3646 sleep(1);
3647 ASSERT_EQ(false, player_->IsPlaying());
3648 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Stop());
3649 sleep(1);
3650 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Pause());
3651 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Play());
3652 }
3653
3654 /**
3655 * @tc.name : Test Player state machine, invalid operation on prepared
3656 * @tc.number: Player_State_Machine_005
3657 * @tc.desc : Test Player state machine, invalid operation on prepared
3658 */
3659 HWTEST_F(PlayerServerUnitTest, Player_State_Machine_005, TestSize.Level0)
3660 {
3661 ASSERT_EQ(PlayerStates::PLAYER_IDLE, player_->GetState());
3662 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3663 ASSERT_EQ(MSERR_OK, player_->PrepareAsync());
3664 sleep(1);
3665 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3666 int32_t duration = 0;
3667 ASSERT_EQ(MSERR_OK, player_->GetDuration(duration));
3668 ASSERT_EQ(MSERR_OK, player_->Seek(duration, PlayerSeekMode::SEEK_NEXT_SYNC));
3669 ASSERT_EQ(PlayerStates::PLAYER_PREPARED, player_->GetState());
3670 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Pause());
3671 sleep(1);
3672 ASSERT_EQ(false, player_->IsPlaying());
3673 ASSERT_EQ(MSERR_OK, player_->Stop());
3674 }
3675
3676 /**
3677 * @tc.name : Test Player state machine, invalid operation on playing
3678 * @tc.number: Player_State_Machine_006
3679 * @tc.desc : Test Player state machine, invalid operation on playing
3680 */
3681 HWTEST_F(PlayerServerUnitTest, Player_State_Machine_006, TestSize.Level0)
3682 {
3683 ASSERT_EQ(PlayerStates::PLAYER_IDLE, player_->GetState());
3684 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3685 ASSERT_EQ(MSERR_OK, player_->PrepareAsync());
3686 ASSERT_EQ(MSERR_OK, player_->SetLooping(true));
3687 sleep(1);
3688 int32_t duration = 0;
3689 ASSERT_EQ(MSERR_OK, player_->GetDuration(duration));
3690 ASSERT_EQ(MSERR_OK, player_->Play());
3691 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3692 ASSERT_EQ(MSERR_OK, player_->Seek(duration, PlayerSeekMode::SEEK_NEXT_SYNC));
3693 sleep(1);
3694 ASSERT_EQ(true, player_->IsPlaying());
3695 ASSERT_EQ(MSERR_OK, player_->Stop());
3696 }
3697
3698 /**
3699 * @tc.name : Test Player state machine, invalid operation on completed
3700 * @tc.number: Player_State_Machine_007
3701 * @tc.desc : Test Player state machine, invalid operation on completed
3702 */
3703 HWTEST_F(PlayerServerUnitTest, Player_State_Machine_007, TestSize.Level0)
3704 {
3705 ASSERT_EQ(PlayerStates::PLAYER_IDLE, player_->GetState());
3706 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3707 ASSERT_EQ(MSERR_OK, player_->PrepareAsync());
3708 sleep(1);
3709 int32_t duration = 0;
3710 ASSERT_EQ(MSERR_OK, player_->GetDuration(duration));
3711 ASSERT_EQ(MSERR_OK, player_->Seek(duration, PlayerSeekMode::SEEK_NEXT_SYNC));
3712 ASSERT_EQ(MSERR_OK, player_->Play());
3713 sleep(1);
3714 ASSERT_EQ(false, player_->IsPlaying());
3715 ASSERT_EQ(PlayerStates::PLAYER_PLAYBACK_COMPLETE, player_->GetState());
3716 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->Pause());
3717 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->PrepareAsync());
3718 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3719 }
3720
3721 /**
3722 * @tc.name : Test Player state machine, invalid operation on paused
3723 * @tc.number: Player_State_Machine_008
3724 * @tc.desc : Test Player state machine, invalid operation on paused
3725 */
3726 HWTEST_F(PlayerServerUnitTest, Player_State_Machine_008, TestSize.Level0)
3727 {
3728 ASSERT_EQ(PlayerStates::PLAYER_IDLE, player_->GetState());
3729 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3730 ASSERT_EQ(MSERR_OK, player_->PrepareAsync());
3731 sleep(1);
3732 int32_t duration = 0;
3733 ASSERT_EQ(MSERR_OK, player_->GetDuration(duration));
3734 ASSERT_EQ(MSERR_OK, player_->Play());
3735 ASSERT_EQ(MSERR_OK, player_->Pause());
3736 sleep(1);
3737 ASSERT_EQ(PlayerStates::PLAYER_PAUSED, player_->GetState());
3738 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3"));
3739 ASSERT_EQ(MSERR_INVALID_OPERATION, player_->PrepareAsync());
3740 }
3741
3742 /**
3743 * @tc.name : Test SetPlayRange [0, 600]
3744 * @tc.number: Player_SetPlayRange_001
3745 * @tc.desc : Test Player SetPlayRange interface
3746 */
3747 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_001, TestSize.Level0)
3748 {
3749 int32_t duration = 0;
3750 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3751 sptr<Surface> videoSurface = player_->GetVideoSurface();
3752 ASSERT_NE(nullptr, videoSurface);
3753 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3754 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(0, 600));
3755 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3756 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3757 EXPECT_EQ(MSERR_OK, player_->Play());
3758 EXPECT_TRUE(player_->IsPlaying());
3759 EXPECT_EQ(MSERR_OK, player_->Pause());
3760 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(0, duration));
3761 EXPECT_EQ(MSERR_OK, player_->Play());
3762 EXPECT_EQ(MSERR_OK, player_->Pause());
3763 }
3764
3765 /**
3766 * @tc.name : Test SetPlayRange [0, 600]
3767 * @tc.number: Player_SetPlayRange_002
3768 * @tc.desc : Test Player SetPlayRange interface
3769 */
3770 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_002, TestSize.Level0)
3771 {
3772 int32_t duration = 0;
3773 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3774 sptr<Surface> videoSurface = player_->GetVideoSurface();
3775 ASSERT_NE(nullptr, videoSurface);
3776 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3777 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3778 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3779 EXPECT_EQ(MSERR_OK, player_->Play());
3780 EXPECT_TRUE(player_->IsPlaying());
3781 EXPECT_EQ(MSERR_OK, player_->Pause());
3782 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(0, 600));
3783 EXPECT_EQ(MSERR_OK, player_->Play());
3784 EXPECT_EQ(MSERR_OK, player_->Pause());
3785 }
3786
3787 /**
3788 * @tc.name : Test SetPlayRange [-2, -1]
3789 * @tc.number: Player_SetPlayRange_003
3790 * @tc.desc : Test Player SetPlayRange interface
3791 */
3792 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_003, TestSize.Level0)
3793 {
3794 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3795 sptr<Surface> videoSurface = player_->GetVideoSurface();
3796 ASSERT_NE(nullptr, videoSurface);
3797 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3798 ASSERT_NE(MSERR_OK, player_->SetPlayRange(-2, -1));
3799 }
3800
3801 /**
3802 * @tc.name : Test SetPlayRange [-1, -2]
3803 * @tc.number: Player_SetPlayRange_004
3804 * @tc.desc : Test Player SetPlayRange interface
3805 */
3806 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_004, TestSize.Level0)
3807 {
3808 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3809 sptr<Surface> videoSurface = player_->GetVideoSurface();
3810 ASSERT_NE(nullptr, videoSurface);
3811 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3812 ASSERT_NE(MSERR_OK, player_->SetPlayRange(-1, -2));
3813 }
3814
3815 /**
3816 * @tc.name : Test SetPlayRange [-1, 0]
3817 * @tc.number: Player_SetPlayRange_005
3818 * @tc.desc : Test Player SetPlayRange interface
3819 */
3820 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_005, TestSize.Level0)
3821 {
3822 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3823 sptr<Surface> videoSurface = player_->GetVideoSurface();
3824 ASSERT_NE(nullptr, videoSurface);
3825 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3826 ASSERT_NE(MSERR_OK, player_->SetPlayRange(-1, 0));
3827 }
3828
3829 /**
3830 * @tc.name : Test SetPlayRange [-1, -1]
3831 * @tc.number: Player_SetPlayRange_006
3832 * @tc.desc : Test Player SetPlayRange interface
3833 */
3834 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_006, TestSize.Level0)
3835 {
3836 int32_t duration = 0;
3837 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3838 sptr<Surface> videoSurface = player_->GetVideoSurface();
3839 ASSERT_NE(nullptr, videoSurface);
3840 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3841 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3842 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3843 EXPECT_EQ(MSERR_OK, player_->Play());
3844 EXPECT_TRUE(player_->IsPlaying());
3845 EXPECT_EQ(MSERR_OK, player_->Pause());
3846 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(-1, 600));
3847 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(-1, -1));
3848 EXPECT_EQ(MSERR_OK, player_->Play());
3849 EXPECT_EQ(MSERR_OK, player_->Pause());
3850 }
3851
3852 /**
3853 * @tc.name : Test SetPlayRange [100, 2]
3854 * @tc.number: Player_SetPlayRange_007
3855 * @tc.desc : Test Player SetPlayRange interface
3856 */
3857 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_007, TestSize.Level0)
3858 {
3859 int32_t duration = 0;
3860 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3861 sptr<Surface> videoSurface = player_->GetVideoSurface();
3862 ASSERT_NE(nullptr, videoSurface);
3863 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3864 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3865 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3866 EXPECT_EQ(MSERR_OK, player_->Play());
3867 EXPECT_TRUE(player_->IsPlaying());
3868 EXPECT_EQ(MSERR_OK, player_->Pause());
3869 ASSERT_NE(MSERR_OK, player_->SetPlayRange(100, 2));
3870 }
3871
3872 /**
3873 * @tc.name : Test SetPlayRange [duration + 1, duration + 2]
3874 * @tc.number: Player_SetPlayRange_008
3875 * @tc.desc : Test Player SetPlayRange interface
3876 */
3877 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_008, TestSize.Level0)
3878 {
3879 int32_t duration = 0;
3880 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3881 sptr<Surface> videoSurface = player_->GetVideoSurface();
3882 ASSERT_NE(nullptr, videoSurface);
3883 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3884 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3885 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3886 EXPECT_EQ(MSERR_OK, player_->Play());
3887 EXPECT_TRUE(player_->IsPlaying());
3888 EXPECT_EQ(MSERR_OK, player_->Pause());
3889 int32_t start = duration + 1;
3890 int32_t end = duration + 2;
3891 ASSERT_NE(MSERR_OK, player_->SetPlayRange(start, end));
3892 }
3893
3894 /**
3895 * @tc.name : Test SetPlayRange [100, duration + 1]
3896 * @tc.number: Player_SetPlayRange_009
3897 * @tc.desc : Test Player SetPlayRange interface
3898 */
3899 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_009, TestSize.Level0)
3900 {
3901 int32_t duration = 0;
3902 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3903 sptr<Surface> videoSurface = player_->GetVideoSurface();
3904 ASSERT_NE(nullptr, videoSurface);
3905 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3906 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3907 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
3908 EXPECT_EQ(MSERR_OK, player_->Play());
3909 EXPECT_TRUE(player_->IsPlaying());
3910 EXPECT_EQ(MSERR_OK, player_->Pause());
3911 int32_t end = duration + 1;
3912 ASSERT_NE(MSERR_OK, player_->SetPlayRange(100, end));
3913 }
3914
3915 /**
3916 * @tc.name : Test SetPlayRange [10035, 10037]
3917 * @tc.number: Player_SetPlayRange_010
3918 * @tc.desc : Test Player SetPlayRange interface, duration 10034
3919 */
3920 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_010, TestSize.Level0)
3921 {
3922 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3923 sptr<Surface> videoSurface = player_->GetVideoSurface();
3924 ASSERT_NE(nullptr, videoSurface);
3925 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3926 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(10035, 10037));
3927 ASSERT_NE(MSERR_OK, player_->PrepareAsync());
3928 }
3929
3930 /**
3931 * @tc.name : Test SetPlayRange [100, 10037]
3932 * @tc.number: Player_SetPlayRange_011
3933 * @tc.desc : Test Player SetPlayRange interface, duration 10034
3934 */
3935 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_011, TestSize.Level0)
3936 {
3937 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3938 sptr<Surface> videoSurface = player_->GetVideoSurface();
3939 ASSERT_NE(nullptr, videoSurface);
3940 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3941 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(100, 10037));
3942 ASSERT_NE(MSERR_OK, player_->PrepareAsync());
3943 }
3944
3945 /**
3946 * @tc.name : Test SetPlayRange
3947 * @tc.number: Player_SetPlayRange_012
3948 * @tc.desc : Test Player SetPlayRange invalid state
3949 */
3950 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_012, TestSize.Level0)
3951 {
3952 EXPECT_NE(MSERR_OK, player_->SetPlayRange(100, 10037));
3953 }
3954
3955 /**
3956 * @tc.name : Test SetPlayRange
3957 * @tc.number: Player_SetPlayRange_013
3958 * @tc.desc : Test Player SetPlayRange invalid playerEngine
3959 */
3960 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRange_013, TestSize.Level0)
3961 {
3962 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
3963 server->lastOpStatus_ = PLAYER_INITIALIZED;
3964 EXPECT_EQ(MSERR_OK, server->SetPlayRange(100, 10037));
3965 }
3966
3967 /**
3968 * @tc.name : Test SeekContinuous in prepared
3969 * @tc.number: Player_SeekContinuous_001
3970 * @tc.desc : Test Player SeekContinuous
3971 */
3972 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_001, TestSize.Level0)
3973 {
3974 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3975 sptr<Surface> videoSurface = player_->GetVideoSurface();
3976 ASSERT_NE(nullptr, videoSurface);
3977 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3978 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3979 for (int i = 0; i < 10; i++) {
3980 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
3981 usleep(SEEK_CONTINUOUS_WAIT_US);
3982 }
3983 EXPECT_EQ(MSERR_OK, player_->Play());
3984 }
3985
3986 /**
3987 * @tc.name : Test SeekContinuous in playing
3988 * @tc.number: Player_SeekContinuous_002
3989 * @tc.desc : Test Player SeekContinuous
3990 */
3991 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_002, TestSize.Level0)
3992 {
3993 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
3994 sptr<Surface> videoSurface = player_->GetVideoSurface();
3995 ASSERT_NE(nullptr, videoSurface);
3996 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
3997 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
3998 EXPECT_EQ(MSERR_OK, player_->Play());
3999 sleep(PLAYING_TIME_2_SEC);
4000 for (int i = 0; i < 30; i++) {
4001 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
4002 usleep(SEEK_CONTINUOUS_WAIT_US);
4003 }
4004 EXPECT_EQ(MSERR_OK, player_->Play());
4005 EXPECT_EQ(MSERR_OK, player_->Stop());
4006 }
4007
4008 /**
4009 * @tc.name : Test SeekContinuous in paused
4010 * @tc.number: Player_SeekContinuous_003
4011 * @tc.desc : Test Player SeekContinuous
4012 */
4013 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_003, TestSize.Level0)
4014 {
4015 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4016 sptr<Surface> videoSurface = player_->GetVideoSurface();
4017 ASSERT_NE(nullptr, videoSurface);
4018 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4019 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4020 EXPECT_EQ(MSERR_OK, player_->Play());
4021 sleep(PLAYING_TIME_2_SEC);
4022 EXPECT_EQ(MSERR_OK, player_->Pause());
4023 for (int i = 0; i < 30; i++) {
4024 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
4025 usleep(SEEK_CONTINUOUS_WAIT_US);
4026 }
4027 EXPECT_EQ(MSERR_OK, player_->Play());
4028 EXPECT_EQ(MSERR_OK, player_->Stop());
4029 }
4030
4031 /**
4032 * @tc.name : Test SeekContinuous in completed
4033 * @tc.number: Player_SeekContinuous_004
4034 * @tc.desc : Test Player SeekContinuous
4035 */
4036 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_004, TestSize.Level0)
4037 {
4038 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4039 sptr<Surface> videoSurface = player_->GetVideoSurface();
4040 ASSERT_NE(nullptr, videoSurface);
4041 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4042 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4043 EXPECT_EQ(MSERR_OK, player_->Play());
4044 sleep(PLAYING_TIME_2_SEC);
4045 EXPECT_EQ(MSERR_OK, player_->Seek(9, SEEK_PREVIOUS_SYNC));
4046 sleep(PLAYING_TIME_10_SEC);
4047 for (int i = 0; i < 30; i++) {
4048 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
4049 usleep(SEEK_CONTINUOUS_WAIT_US);
4050 }
4051 EXPECT_EQ(MSERR_OK, player_->Play());
4052 EXPECT_EQ(MSERR_OK, player_->Stop());
4053 }
4054
4055 /**
4056 * @tc.name : Test SeekContinuous backward
4057 * @tc.number: Player_SeekContinuous_005
4058 * @tc.desc : Test Player SeekContinuous
4059 */
4060 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_005, TestSize.Level0)
4061 {
4062 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4063 sptr<Surface> videoSurface = player_->GetVideoSurface();
4064 ASSERT_NE(nullptr, videoSurface);
4065 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4066 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4067 EXPECT_EQ(MSERR_OK, player_->Play());
4068 sleep(PLAYING_TIME_2_SEC);
4069 for (int i = 0; i < 30; i++) {
4070 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
4071 usleep(SEEK_CONTINUOUS_WAIT_US);
4072 }
4073 EXPECT_EQ(MSERR_OK, player_->Play());
4074 EXPECT_EQ(MSERR_OK, player_->Stop());
4075 }
4076
4077 /**
4078 * @tc.name : Test SeekContinuous forward and backward
4079 * @tc.number: Player_SeekContinuous_006
4080 * @tc.desc : Test Player SeekContinuous
4081 */
4082 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_006, TestSize.Level0)
4083 {
4084 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4085 sptr<Surface> videoSurface = player_->GetVideoSurface();
4086 ASSERT_NE(nullptr, videoSurface);
4087 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4088 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4089 EXPECT_EQ(MSERR_OK, player_->Play());
4090 sleep(PLAYING_TIME_2_SEC);
4091 for (int i = 0; i < 30; i++) {
4092 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
4093 usleep(SEEK_CONTINUOUS_WAIT_US);
4094 }
4095 for (int i = 0; i < 30; i++) {
4096 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
4097 usleep(SEEK_CONTINUOUS_WAIT_US);
4098 }
4099 EXPECT_EQ(MSERR_OK, player_->Play());
4100 EXPECT_EQ(MSERR_OK, player_->Stop());
4101 }
4102
4103 /**
4104 * @tc.name : Test SetPlaybackSpeed API
4105 * @tc.number: Player_SetPlaybackSpeed_006
4106 * @tc.desc : Test Player SetPlaybackSpeed SPEED_FORWARD_3_00_X
4107 */
4108 HWTEST_F(PlayerServerUnitTest, Player_SetPlaybackSpeed_006, TestSize.Level0)
4109 {
4110 PlaybackRateMode mode;
4111 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4112 sptr<Surface> videoSurface = player_->GetVideoSurface();
4113 ASSERT_NE(nullptr, videoSurface);
4114 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4115 EXPECT_EQ(MSERR_OK, player_->Prepare());
4116 EXPECT_EQ(MSERR_OK, player_->Play());
4117 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_3_00_X));
4118 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
4119 EXPECT_EQ(SPEED_FORWARD_3_00_X, mode);
4120 }
4121
4122 /**
4123 * @tc.name : Test SetMaxAmplitudeCbStatus API
4124 * @tc.number: Player_SetMaxAmplitudeCbStatus_001
4125 * @tc.desc : Test Player SetMaxAmplitudeCbStatus status on before prepare
4126 */
4127 HWTEST_F(PlayerServerUnitTest, Player_SetMaxAmplitudeCbStatus_001, TestSize.Level0)
4128 {
4129 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4130 sptr<Surface> videoSurface = player_->GetVideoSurface();
4131 ASSERT_NE(nullptr, videoSurface);
4132 EXPECT_EQ(MSERR_OK, player_->SetMaxAmplitudeCbStatus(true));
4133 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4134 EXPECT_EQ(MSERR_OK, player_->Prepare());
4135 EXPECT_EQ(MSERR_OK, player_->Play());
4136 }
4137
4138 /**
4139 * @tc.name : Test SetMaxAmplitudeCbStatus API
4140 * @tc.number: Player_SetMaxAmplitudeCbStatus_002
4141 * @tc.desc : Test Player SetMaxAmplitudeCbStatus status on after prepare
4142 */
4143 HWTEST_F(PlayerServerUnitTest, Player_SetMaxAmplitudeCbStatus_002, TestSize.Level0)
4144 {
4145 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4146 sptr<Surface> videoSurface = player_->GetVideoSurface();
4147 ASSERT_NE(nullptr, videoSurface);
4148 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4149 EXPECT_EQ(MSERR_OK, player_->Prepare());
4150 EXPECT_EQ(MSERR_OK, player_->SetMaxAmplitudeCbStatus(true));
4151 EXPECT_EQ(MSERR_OK, player_->Play());
4152 }
4153
4154 /**
4155 * @tc.name : Test SetMaxAmplitudeCbStatus API
4156 * @tc.number: Player_SetMaxAmplitudeCbStatus_003
4157 * @tc.desc : Test Player SetMaxAmplitudeCbStatus status off before prepare
4158 */
4159 HWTEST_F(PlayerServerUnitTest, Player_SetMaxAmplitudeCbStatus_003, TestSize.Level0)
4160 {
4161 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4162 sptr<Surface> videoSurface = player_->GetVideoSurface();
4163 ASSERT_NE(nullptr, videoSurface);
4164 EXPECT_EQ(MSERR_OK, player_->SetMaxAmplitudeCbStatus(false));
4165 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4166 EXPECT_EQ(MSERR_OK, player_->Prepare());
4167 EXPECT_EQ(MSERR_OK, player_->Play());
4168 }
4169
4170 /**
4171 * @tc.name : Test SetMaxAmplitudeCbStatus API
4172 * @tc.number: Player_SetMaxAmplitudeCbStatus_004
4173 * @tc.desc : Test Player SetMaxAmplitudeCbStatus status off after prepare
4174 */
4175 HWTEST_F(PlayerServerUnitTest, Player_SetMaxAmplitudeCbStatus_004, TestSize.Level0)
4176 {
4177 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4178 sptr<Surface> videoSurface = player_->GetVideoSurface();
4179 ASSERT_NE(nullptr, videoSurface);
4180 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4181 EXPECT_EQ(MSERR_OK, player_->Prepare());
4182 EXPECT_EQ(MSERR_OK, player_->SetMaxAmplitudeCbStatus(false));
4183 EXPECT_EQ(MSERR_OK, player_->Play());
4184 }
4185
4186 /**
4187 * @tc.name : Test SetDeviceChangeCbStatus API
4188 * @tc.number: Player_SetDeviceChangeCbStatus_001
4189 * @tc.desc : Test Player SetDeviceChangeCbStatus status on before prepare
4190 */
4191 HWTEST_F(PlayerServerUnitTest, Player_SetDeviceChangeCbStatus_001, TestSize.Level0)
4192 {
4193 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4194 sptr<Surface> videoSurface = player_->GetVideoSurface();
4195 ASSERT_NE(nullptr, videoSurface);
4196 EXPECT_EQ(MSERR_OK, player_->SetDeviceChangeCbStatus(true));
4197 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4198 EXPECT_EQ(MSERR_OK, player_->Prepare());
4199 EXPECT_EQ(MSERR_OK, player_->Play());
4200 }
4201
4202 /**
4203 * @tc.name : Test SetDeviceChangeCbStatus API
4204 * @tc.number: Player_SetDeviceChangeCbStatus_002
4205 * @tc.desc : Test Player SetDeviceChangeCbStatus status on after prepare
4206 */
4207 HWTEST_F(PlayerServerUnitTest, Player_SetDeviceChangeCbStatus_002, TestSize.Level0)
4208 {
4209 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4210 sptr<Surface> videoSurface = player_->GetVideoSurface();
4211 ASSERT_NE(nullptr, videoSurface);
4212 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4213 EXPECT_EQ(MSERR_OK, player_->Prepare());
4214 EXPECT_EQ(MSERR_OK, player_->SetDeviceChangeCbStatus(true));
4215 EXPECT_EQ(MSERR_OK, player_->Play());
4216 }
4217
4218 /**
4219 * @tc.name : Test SetDeviceChangeCbStatus API
4220 * @tc.number: Player_SetDeviceChangeCbStatus_003
4221 * @tc.desc : Test Player SetDeviceChangeCbStatus status off before prepare
4222 */
4223 HWTEST_F(PlayerServerUnitTest, Player_SetDeviceChangeCbStatus_003, TestSize.Level0)
4224 {
4225 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4226 sptr<Surface> videoSurface = player_->GetVideoSurface();
4227 ASSERT_NE(nullptr, videoSurface);
4228 EXPECT_EQ(MSERR_OK, player_->SetDeviceChangeCbStatus(false));
4229 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4230 EXPECT_EQ(MSERR_OK, player_->Prepare());
4231 EXPECT_EQ(MSERR_OK, player_->Play());
4232 }
4233
4234 /**
4235 * @tc.name : Test SetDeviceChangeCbStatus API
4236 * @tc.number: Player_SetDeviceChangeCbStatus_004
4237 * @tc.desc : Test Player SetDeviceChangeCbStatus status off after prepare
4238 */
4239 HWTEST_F(PlayerServerUnitTest, Player_SetDeviceChangeCbStatus_004, TestSize.Level0)
4240 {
4241 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4242 sptr<Surface> videoSurface = player_->GetVideoSurface();
4243 ASSERT_NE(nullptr, videoSurface);
4244 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4245 EXPECT_EQ(MSERR_OK, player_->Prepare());
4246 EXPECT_EQ(MSERR_OK, player_->SetDeviceChangeCbStatus(false));
4247 EXPECT_EQ(MSERR_OK, player_->Play());
4248 }
4249
4250 /**
4251 * @tc.name : Test SetPlaybackStrategy
4252 * @tc.number: Player_SetPlaybackStrategy_001
4253 * @tc.desc : Test Player SetPlaybackStrategy
4254 */
4255 HWTEST_F(PlayerServerUnitTest, Player_SetPlaybackStrategy_001, TestSize.Level0)
4256 {
4257 AVPlayStrategy playbackStrategy = {
4258 .mutedMediaType = OHOS::Media::MediaType::MEDIA_TYPE_AUD
4259 };
4260 ASSERT_NE(MSERR_OK, player_->SetPlaybackStrategy(playbackStrategy));
4261 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4262 ASSERT_EQ(MSERR_OK, player_->SetPlaybackStrategy(playbackStrategy));
4263 }
4264
4265 /**
4266 * @tc.name : Test SetMediaMuted
4267 * @tc.number: Player_SetMediaMuted_001
4268 * @tc.desc : Test Player SetMediaMuted
4269 */
4270 HWTEST_F(PlayerServerUnitTest, Player_SetMediaMuted_001, TestSize.Level0)
4271 {
4272 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
4273 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4274 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
4275 ASSERT_EQ(MSERR_OK, player_->PrepareAsync());
4276 ASSERT_EQ(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
4277 ASSERT_EQ(MSERR_OK, player_->Play());
4278 ASSERT_EQ(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
4279 ASSERT_EQ(MSERR_OK, player_->Pause());
4280 ASSERT_EQ(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
4281 ASSERT_EQ(MSERR_OK, player_->Stop());
4282 ASSERT_EQ(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true));
4283 }
4284
4285 /**
4286 * @tc.name : Test SetMediaMuted
4287 * @tc.number: Player_SetMediaMuted_002
4288 * @tc.desc : Test Player SetMediaMuted
4289 */
4290 HWTEST_F(PlayerServerUnitTest, Player_SetMediaMuted_002, TestSize.Level0)
4291 {
4292 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true));
4293 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4294 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true));
4295 ASSERT_EQ(MSERR_OK, player_->PrepareAsync());
4296 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true));
4297 ASSERT_EQ(MSERR_OK, player_->Play());
4298 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true));
4299 ASSERT_EQ(MSERR_OK, player_->Stop());
4300 ASSERT_NE(MSERR_OK, player_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true));
4301 }
4302
4303 /**
4304 * @tc.name : Test GetCurrentTime
4305 * @tc.number: Player_GetCurrentTime_001
4306 * @tc.desc : Test GetCurrentTime interface with invalid parameters
4307 */
4308 HWTEST_F(PlayerServerUnitTest, Player_GetCurrentTime_001, TestSize.Level0)
4309 {
4310 int32_t time = 0;
4311 int32_t duration = 0;
4312 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4313 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
4314 sptr<Surface> videoSurface = player_->GetVideoSurface();
4315 ASSERT_NE(nullptr, videoSurface);
4316 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4317 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
4318 EXPECT_EQ(MSERR_OK, player_->Prepare());
4319 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
4320 EXPECT_EQ(MSERR_OK, player_->Play());
4321 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
4322 EXPECT_EQ(MSERR_OK, player_->Pause());
4323 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
4324 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
4325 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
4326 EXPECT_EQ(MSERR_OK, player_->Play());
4327 sleep(PLAYING_TIME_2_SEC);
4328 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
4329 EXPECT_EQ(MSERR_OK, player_->Stop());
4330 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
4331 EXPECT_EQ(MSERR_OK, player_->Reset());
4332 EXPECT_NE(MSERR_OK, player_->GetCurrentTime(time));
4333 }
4334
4335 /**
4336 * @tc.name : Test GetCurrentTime
4337 * @tc.number: Player_GetCurrentTime_002
4338 * @tc.desc : Test GetCurrentTime interface with invalid parameters
4339 */
4340 HWTEST_F(PlayerServerUnitTest, Player_GetCurrentTime_002, TestSize.Level0)
4341 {
4342 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4343 int32_t time = 0;
4344 server->lastOpStatus_ = PLAYER_INITIALIZED;
4345 server->isLiveStream_ = true;
4346 EXPECT_EQ(MSERR_OK, server->GetCurrentTime(time));
4347 }
4348
4349 /**
4350 * @tc.name : Test GetPlaybackInfo API
4351 * @tc.number: Player_GetPlaybackInfo_001
4352 * @tc.desc : Test Player GetPlaybackInfo
4353 */
4354 HWTEST_F(PlayerServerUnitTest, Player_GetPlaybackInfo_001, TestSize.Level0)
4355 {
4356 Format playbackInfo;
4357 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4358 sptr<Surface> videoSurface = player_->GetVideoSurface();
4359 ASSERT_NE(nullptr, videoSurface);
4360 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4361 EXPECT_EQ(MSERR_OK, player_->Prepare());
4362 EXPECT_EQ(MSERR_OK, player_->Play());
4363 EXPECT_EQ(MSERR_OK, player_->GetPlaybackInfo(playbackInfo));
4364 }
4365
4366 /**
4367 * @tc.name : Test GetPlaybackInfo API
4368 * @tc.number: Player_GetPlaybackInfo_002
4369 * @tc.desc : Test Player GetPlaybackInfo
4370 */
4371 HWTEST_F(PlayerServerUnitTest, Player_GetPlaybackInfo_002, TestSize.Level2)
4372 {
4373 Format playbackInfo;
4374 int32_t duration = 0;
4375 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4376 EXPECT_NE(MSERR_OK, player_->GetPlaybackInfo(playbackInfo));
4377 sptr<Surface> videoSurface = player_->GetVideoSurface();
4378 ASSERT_NE(nullptr, videoSurface);
4379 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4380 EXPECT_NE(MSERR_OK, player_->GetPlaybackInfo(playbackInfo));
4381 EXPECT_EQ(MSERR_OK, player_->Prepare());
4382 EXPECT_EQ(MSERR_OK, player_->GetPlaybackInfo(playbackInfo));
4383 EXPECT_EQ(MSERR_OK, player_->Play());
4384 EXPECT_EQ(MSERR_OK, player_->GetPlaybackInfo(playbackInfo));
4385 EXPECT_EQ(MSERR_OK, player_->Pause());
4386 EXPECT_EQ(MSERR_OK, player_->GetPlaybackInfo(playbackInfo));
4387 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
4388 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
4389 EXPECT_EQ(MSERR_OK, player_->Play());
4390 sleep(PLAYING_TIME_2_SEC);
4391 EXPECT_EQ(MSERR_OK, player_->GetPlaybackInfo(playbackInfo));
4392 EXPECT_EQ(MSERR_OK, player_->Stop());
4393 EXPECT_NE(MSERR_OK, player_->GetPlaybackInfo(playbackInfo));
4394 EXPECT_EQ(MSERR_OK, player_->Reset());
4395 EXPECT_NE(MSERR_OK, player_->GetPlaybackInfo(playbackInfo));
4396 }
4397
4398 /**
4399 * @tc.name : Test GetSubtitleTrackInfo API
4400 * @tc.number: Player_GetSubtitleTrackInfo_001
4401 * @tc.desc : Test Player GetSubtitleTrackInfo
4402 */
4403 HWTEST_F(PlayerServerUnitTest, Player_GetSubtitleTrackInfo_001, TestSize.Level0)
4404 {
4405 std::vector<Format> subtitleTrackInfo;
4406 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4407 sptr<Surface> videoSurface = player_->GetVideoSurface();
4408 ASSERT_NE(nullptr, videoSurface);
4409 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4410 EXPECT_EQ(MSERR_OK, player_->Prepare());
4411 EXPECT_EQ(MSERR_OK, player_->Play());
4412 EXPECT_EQ(MSERR_OK, player_->GetSubtitleTrackInfo(subtitleTrackInfo));
4413 }
4414
4415 /**
4416 * @tc.name : Test GetSubtitleTrackInfo API
4417 * @tc.number: Player_GetSubtitleTrackInfo_002
4418 * @tc.desc : Test Player GetSubtitleTrackInfo
4419 */
4420 HWTEST_F(PlayerServerUnitTest, Player_GetSubtitleTrackInfo_002, TestSize.Level2)
4421 {
4422 std::vector<Format> subtitleTrackInfo;
4423 int32_t duration = 0;
4424 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4425 EXPECT_NE(MSERR_OK, player_->GetSubtitleTrackInfo(subtitleTrackInfo));
4426 sptr<Surface> videoSurface = player_->GetVideoSurface();
4427 ASSERT_NE(nullptr, videoSurface);
4428 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4429 EXPECT_NE(MSERR_OK, player_->GetSubtitleTrackInfo(subtitleTrackInfo));
4430 EXPECT_EQ(MSERR_OK, player_->Prepare());
4431 EXPECT_EQ(MSERR_OK, player_->GetSubtitleTrackInfo(subtitleTrackInfo));
4432 EXPECT_EQ(MSERR_OK, player_->Play());
4433 EXPECT_EQ(MSERR_OK, player_->GetSubtitleTrackInfo(subtitleTrackInfo));
4434 EXPECT_EQ(MSERR_OK, player_->Pause());
4435 EXPECT_EQ(MSERR_OK, player_->GetSubtitleTrackInfo(subtitleTrackInfo));
4436 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
4437 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
4438 EXPECT_EQ(MSERR_OK, player_->Play());
4439 sleep(PLAYING_TIME_2_SEC);
4440 EXPECT_EQ(MSERR_OK, player_->GetSubtitleTrackInfo(subtitleTrackInfo));
4441 EXPECT_EQ(MSERR_OK, player_->Stop());
4442 EXPECT_NE(MSERR_OK, player_->GetSubtitleTrackInfo(subtitleTrackInfo));
4443 EXPECT_EQ(MSERR_OK, player_->Reset());
4444 EXPECT_NE(MSERR_OK, player_->GetSubtitleTrackInfo(subtitleTrackInfo));
4445 }
4446
4447 /**
4448 * @tc.name : Test SetRenderFirstFrame API
4449 * @tc.number: Player_SetRenderFirstFrame_001
4450 * @tc.desc : Test Player SetRenderFirstFrame
4451 */
4452 HWTEST_F(PlayerServerUnitTest, Player_SetRenderFirstFrame_001, TestSize.Level0)
4453 {
4454 bool display = false;
4455 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE2));
4456 EXPECT_EQ(MSERR_OK, player_->SetRenderFirstFrame(display));
4457 EXPECT_EQ(MSERR_OK, player_->Prepare());
4458 EXPECT_NE(MSERR_OK, player_->SetRenderFirstFrame(display));
4459 EXPECT_EQ(MSERR_OK, player_->Play());
4460 EXPECT_NE(MSERR_OK, player_->SetRenderFirstFrame(display));
4461 EXPECT_EQ(MSERR_OK, player_->Reset());
4462 display = true;
4463 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE2));
4464 EXPECT_EQ(MSERR_OK, player_->SetRenderFirstFrame(display));
4465 EXPECT_EQ(MSERR_OK, player_->Prepare());
4466 EXPECT_NE(MSERR_OK, player_->SetRenderFirstFrame(display));
4467 EXPECT_EQ(MSERR_OK, player_->Play());
4468 EXPECT_NE(MSERR_OK, player_->SetRenderFirstFrame(display));
4469 }
4470
4471 /**
4472 * @tc.name : Test SetRenderFirstFrame API
4473 * @tc.number: Player_SetRenderFirstFrame_002
4474 * @tc.desc : Test Player SetRenderFirstFrame invalid playerEngine
4475 */
4476 HWTEST_F(PlayerServerUnitTest, Player_SetRenderFirstFrame_002, TestSize.Level0)
4477 {
4478 bool display = false;
4479 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4480 server->lastOpStatus_ = PLAYER_INITIALIZED;
4481 EXPECT_EQ(MSERR_OK, server->SetRenderFirstFrame(display));
4482 }
4483
4484 /**
4485 * @tc.name : Test PreparedHandleEos API
4486 * @tc.number: Player_PreparedHandleEos_001
4487 * @tc.desc : Test Player PreparedHandleEos
4488 */
4489 HWTEST_F(PlayerServerUnitTest, Player_PreparedHandleEos_001, TestSize.Level0)
4490 {
4491 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4492 (void)server->Init();
4493 ASSERT_EQ(MSERR_OK, server->SetSource(VIDEO_FILE1));
4494 EXPECT_EQ(MSERR_OK, server->Prepare());
4495 EXPECT_EQ(MSERR_OK, server->Play());
4496 EXPECT_EQ(MSERR_OK, server->SetLooping(true));
4497 EXPECT_EQ(true, server->IsLooping());
4498 server->PreparedHandleEos();
4499 EXPECT_NE(server->lastOpStatus_, PLAYER_PLAYBACK_COMPLETE);
4500 EXPECT_EQ(MSERR_OK, server->SetLooping(false));
4501 EXPECT_EQ(false, server->IsLooping());
4502 server->PreparedHandleEos();
4503 EXPECT_EQ(server->lastOpStatus_, PLAYER_PLAYBACK_COMPLETE);
4504 server->Release();
4505 }
4506
4507 /**
4508 * @tc.name : Test HandleEos API
4509 * @tc.number: Player_HandleEos_001
4510 * @tc.desc : Test Player HandleEos
4511 */
4512 HWTEST_F(PlayerServerUnitTest, Player_HandleEos_001, TestSize.Level0)
4513 {
4514 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4515 server->HandleEos();
4516 EXPECT_EQ(server->disableNextSeekDone_, false);
4517 }
4518
4519 /**
4520 * @tc.name : Test HandleInterruptEvent API
4521 * @tc.number: Player_HandleInterruptEvent_001
4522 * @tc.desc : Test Player HandleInterruptEvent
4523 */
4524 HWTEST_F(PlayerServerUnitTest, Player_HandleInterruptEvent_001, TestSize.Level0)
4525 {
4526 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4527 server->interruptEventState_ = PLAYER_PREPARING;
4528 Format infoBody;
4529 infoBody.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_TYPE, -1);
4530 infoBody.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_FORCE, -1);
4531 infoBody.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_HINT, -1);
4532 server->HandleInterruptEvent(infoBody);
4533 EXPECT_EQ(server->interruptEventState_, PLAYER_PREPARING);
4534
4535 infoBody.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_FORCE, OHOS::AudioStandard::INTERRUPT_FORCE);
4536 server->HandleInterruptEvent(infoBody);
4537 EXPECT_EQ(server->interruptEventState_, PLAYER_PREPARING);
4538 }
4539
4540 /**
4541 * @tc.name : Test BackGroundChangeState API
4542 * @tc.number: Player_BackGroundChangeState_001
4543 * @tc.desc : Test Player BackGroundChangeState
4544 */
4545 HWTEST_F(PlayerServerUnitTest, Player_BackGroundChangeState_001, TestSize.Level0)
4546 {
4547 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4548 (void)server->Init();
4549 ASSERT_EQ(MSERR_OK, server->SetSource(VIDEO_FILE1));
4550 EXPECT_EQ(MSERR_OK, server->Prepare());
4551 EXPECT_EQ(MSERR_OK, server->Play());
4552 EXPECT_EQ(MSERR_OK, server->BackGroundChangeState(PLAYER_PAUSED, true));
4553 EXPECT_EQ(MSERR_OK, server->BackGroundChangeState(PLAYER_STARTED, true));
4554 EXPECT_EQ(MSERR_OK, server->Stop());
4555 EXPECT_NE(MSERR_OK, server->BackGroundChangeState(PLAYER_STOPPED, true));
4556 }
4557
4558 /**
4559 * @tc.name : Test PlayerState API
4560 * @tc.number: Player_PlayerState_001
4561 * @tc.desc : Test Player PlayerState
4562 */
4563 HWTEST_F(PlayerServerUnitTest, Player_PlayerState_001, TestSize.Level0)
4564 {
4565 std::shared_ptr<PlayerServer> server_ = std::make_shared<PlayerServer>();
4566 (void)server_->Init();
4567 server_->lastOpStatus_ = PLAYER_STATE_ERROR;
4568 EXPECT_EQ(false, server_->IsCompleted());
4569 EXPECT_EQ(false, server_->IsPrepared());
4570 EXPECT_EQ(false, server_->IsPlaying());
4571
4572 server_->lastOpStatus_ = PLAYER_PLAYBACK_COMPLETE;
4573 EXPECT_EQ(true, server_->IsCompleted());
4574 EXPECT_EQ(false, server_->IsPrepared());
4575 EXPECT_EQ(false, server_->IsPlaying());
4576
4577 server_->lastOpStatus_ = PLAYER_STARTED;
4578 EXPECT_EQ(false, server_->IsCompleted());
4579 EXPECT_EQ(false, server_->IsPrepared());
4580 EXPECT_EQ(true, server_->IsPlaying());
4581 }
4582
4583 /**
4584 * @tc.name : Test AddSubSource API
4585 * @tc.number: Player_AddSubSource_003
4586 * @tc.desc : Test Player AddSubSource
4587 */
4588 HWTEST_F(PlayerServerUnitTest, Player_AddSubSource_003, TestSize.Level0)
4589 {
4590 std::shared_ptr<PlayerServer> server_ = std::make_shared<PlayerServer>();
4591 (void)server_->Init();
4592 server_->subtitleTrackNum_ = 10;
4593 EXPECT_NE(MSERR_OK, server_->AddSubSource(SUBTITLE_SRT_FIELE));
4594 EXPECT_NE(MSERR_OK, server_->AddSubSource(0, 0, 0));
4595 }
4596
4597 /**
4598 * @tc.name : Test AddSubSource API
4599 * @tc.number: Player_AddSubSource_004
4600 * @tc.desc : Test Player AddSubSource invalid subtitleTrackNum
4601 */
4602 HWTEST_F(PlayerServerUnitTest, Player_AddSubSource_004, TestSize.Level0)
4603 {
4604 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4605 ASSERT_EQ(MSERR_OK, server->SetSource(VIDEO_FILE1));
4606 server->subtitleTrackNum_ = 10;
4607 EXPECT_NE(MSERR_OK, server->AddSubSource(SUBTITLE_SRT_FIELE));
4608 EXPECT_NE(MSERR_OK, server->AddSubSource(0, 0, 0));
4609 }
4610
4611 /**
4612 * @tc.name : Test PrepareInReleasing API
4613 * @tc.number: Player_PrepareInReleasing_001
4614 * @tc.desc : Test Player PrepareInReleasing
4615 */
4616 HWTEST_F(PlayerServerUnitTest, Player_PrepareInReleasing_001, TestSize.Level0)
4617 {
4618 std::shared_ptr<PlayerServer> server_ = std::make_shared<PlayerServer>();
4619 (void)server_->Init();
4620 ASSERT_EQ(MSERR_OK, server_->SetSource(VIDEO_FILE1));
4621 EXPECT_EQ(MSERR_OK, server_->Prepare());
4622 EXPECT_EQ(MSERR_OK, server_->Play());
4623 EXPECT_EQ(MSERR_OK, server_->Stop());
4624 server_->inReleasing_ = true;
4625 EXPECT_NE(MSERR_OK, server_->Prepare());
4626 EXPECT_NE(MSERR_OK, server_->PrepareAsync());
4627 }
4628
4629 /**
4630 * @tc.name : Test media error
4631 * @tc.number: Player_Media_Error_002
4632 * @tc.desc : Test Player Media Error
4633 */
4634 HWTEST_F(PlayerServerUnitTest, Player_Media_Error_002, TestSize.Level0)
4635 {
4636 for (MediaServiceErrCode code = MSERR_IO_CANNOT_FIND_HOST; code <= MSERR_IO_UNSUPPORTTED_REQUEST;
4637 code = (MediaServiceErrCode)(code + 1)) {
4638 MediaServiceErrCodeTest(code);
4639 }
4640 MediaServiceErrCodeTest(MSERR_EXTEND_START);
4641
4642 for (auto code = MSERR_EXT_API14_IO_CANNOT_FIND_HOST;
4643 code <= MSERR_EXT_API14_IO_UNSUPPORTTED_REQUEST; code = (MediaServiceExtErrCodeAPI9)(code + 1)) {
4644 EXPECT_EQ(MSEXTERRCODE_API9_INFOS.at(code), MSExtAVErrorToString(code));
4645 MediaServiceExtErrCodeAPI9Test(code);
4646 }
4647 }
4648
4649 /**
4650 * @tc.name : Test SetPlayRangeWithMode
4651 * @tc.number: Player_SetPlayRangeWithMode_001
4652 * @tc.desc : Test Player SetPlayRangeWithMode interface
4653 */
4654 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRangeWithMode_001, TestSize.Level0)
4655 {
4656 int32_t duration = 0;
4657 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4658 sptr<Surface> videoSurface = player_->GetVideoSurface();
4659 ASSERT_NE(nullptr, videoSurface);
4660 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4661 EXPECT_EQ(MSERR_OK, player_->SetPlayRange(0, 600));
4662 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4663 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
4664 EXPECT_EQ(MSERR_OK, player_->Play());
4665 EXPECT_TRUE(player_->IsPlaying());
4666 EXPECT_EQ(MSERR_OK, player_->Pause());
4667 EXPECT_EQ(MSERR_OK, player_->SetPlayRangeWithMode(0, duration, SEEK_PREVIOUS_SYNC));
4668 EXPECT_EQ(MSERR_OK, player_->Play());
4669 EXPECT_EQ(MSERR_OK, player_->Pause());
4670 }
4671
4672 /**
4673 * @tc.name : Test SetPlayRangeWithMode
4674 * @tc.number: Player_SetPlayRangeWithMode_002
4675 * @tc.desc : Test Player SetPlayRangeWithMode interface
4676 */
4677 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRangeWithMode_002, TestSize.Level0)
4678 {
4679 int32_t duration = 0;
4680 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4681 sptr<Surface> videoSurface = player_->GetVideoSurface();
4682 ASSERT_NE(nullptr, videoSurface);
4683 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4684 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4685 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
4686 EXPECT_EQ(MSERR_OK, player_->Play());
4687 EXPECT_TRUE(player_->IsPlaying());
4688 EXPECT_EQ(MSERR_OK, player_->Pause());
4689 EXPECT_EQ(MSERR_OK, player_->SetPlayRangeWithMode(0, duration, SEEK_CLOSEST_SYNC));
4690 EXPECT_EQ(MSERR_OK, player_->Play());
4691 EXPECT_EQ(MSERR_OK, player_->Pause());
4692 }
4693
4694 /**
4695 * @tc.name : Test SetPlayRangeWithMode
4696 * @tc.number: Player_SetPlayRangeWithMode_003
4697 * @tc.desc : Test Player SetPlayRangeWithMode interface
4698 */
4699 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRangeWithMode_003, TestSize.Level0)
4700 {
4701 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4702 sptr<Surface> videoSurface = player_->GetVideoSurface();
4703 ASSERT_NE(nullptr, videoSurface);
4704 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4705 EXPECT_EQ(MSERR_OK, player_->SetPlayRangeWithMode(0, 600, SEEK_CONTINOUS));
4706 ASSERT_NE(MSERR_OK, player_->PrepareAsync());
4707 EXPECT_EQ(MSERR_INVALID_OPERATION, player_->Play());
4708 EXPECT_EQ(MSERR_INVALID_OPERATION, player_->Pause());
4709 EXPECT_EQ(MSERR_INVALID_OPERATION, player_->SetPlayRangeWithMode(0, 600, SEEK_CONTINOUS));
4710 }
4711
4712 /**
4713 * @tc.name : Test SetPlayRangeWithMode
4714 * @tc.number: Player_SetPlayRangeWithMode_004
4715 * @tc.desc : Test Player SetPlayRangeWithMode interface
4716 */
4717 HWTEST_F(PlayerServerUnitTest, Player_SetPlayRangeWithMode_004, TestSize.Level0)
4718 {
4719 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4720 sptr<Surface> videoSurface = player_->GetVideoSurface();
4721 ASSERT_NE(nullptr, videoSurface);
4722 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4723 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4724 EXPECT_EQ(MSERR_OK, player_->SetPlayRangeWithMode(0, 600, SEEK_CONTINOUS));
4725 }
4726
4727 /**
4728 * @tc.name : Test InnerOnInfo
4729 * @tc.number: Player_InnerOnInfo_001
4730 * @tc.desc : Test Player InnerOnInfo interface
4731 */
4732 HWTEST_F(PlayerServerUnitTest, Player_InnerOnInfo_001, TestSize.Level0)
4733 {
4734 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4735 Format infoBody;
4736 PlayerOnInfoType type = INFO_TYPE_IS_LIVE_STREAM;
4737 server->InnerOnInfo(type, 0, infoBody, 0);
4738 EXPECT_EQ(server->isLiveStream_, true);
4739 }
4740
4741 /**
4742 * @tc.name : Test InnerOnInfo
4743 * @tc.number: Player_InnerOnInfo_002
4744 * @tc.desc : Test Player InnerOnInfo interface
4745 */
4746 HWTEST_F(PlayerServerUnitTest, Player_InnerOnInfo_002, TestSize.Level0)
4747 {
4748 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4749 Format infoBody;
4750 PlayerOnInfoType type = INFO_TYPE_DEFAULTTRACK;
4751 server->InnerOnInfo(type, 1, infoBody, 0);
4752 EXPECT_NE(server->isLiveStream_, true);
4753 type = INFO_TYPE_TRACK_DONE;
4754 server->InnerOnInfo(type, 1, infoBody, 0);
4755 EXPECT_NE(server->isLiveStream_, true);
4756 type = INFO_TYPE_ADD_SUBTITLE_DONE;
4757 server->InnerOnInfo(type, 1, infoBody, 0);
4758 EXPECT_NE(server->isLiveStream_, true);
4759 }
4760
4761 /**
4762 * @tc.name : Test InnerOnInfo
4763 * @tc.number: Player_InnerOnInfo_003
4764 * @tc.desc : Test Player InnerOnInfo interface
4765 */
4766 HWTEST_F(PlayerServerUnitTest, Player_InnerOnInfo_003, TestSize.Level0)
4767 {
4768 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4769 std::shared_ptr<PlayerCallbackTest> callback = std::make_shared<PlayerCallbackTest>();
4770 server->SetPlayerCallback(callback);
4771 Format infoBody;
4772 PlayerOnInfoType type = INFO_TYPE_SEEKDONE;
4773 server->InnerOnInfo(type, 0, infoBody, 0);
4774 EXPECT_EQ(callback->seekDoneFlag_, true);
4775
4776 server->isBackgroundChanged_ = true;
4777 callback->seekDoneFlag_ = false;
4778 server->InnerOnInfo(type, 0, infoBody, 0);
4779 EXPECT_EQ(callback->seekDoneFlag_, true);
4780
4781 type = INFO_TYPE_STATE_CHANGE;
4782 server->InnerOnInfo(type, 2, infoBody, 0);
4783 EXPECT_EQ(callback->state_, PLAYER_INITIALIZED);
4784
4785 server->isBackgroundCb_ = true;
4786 server->isBackgroundChanged_ = true;
4787 server->InnerOnInfo(type, 1, infoBody, 0);
4788 EXPECT_FALSE(server->isBackgroundCb_);
4789 }
4790
4791 /**
4792 * @tc.name : Test GetStatusDescription
4793 * @tc.number: Player_GetStatusDescription_001
4794 * @tc.desc : Test Player GetStatusDescription interface
4795 */
4796 HWTEST_F(PlayerServerUnitTest, Player_GetStatusDescription_001, TestSize.Level0)
4797 {
4798 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4799 EXPECT_EQ(server->GetStatusDescription(-1), "PLAYER_STATUS_ILLEGAL");
4800 EXPECT_EQ(server->GetStatusDescription(10), "PLAYER_STATUS_ILLEGAL");
4801 }
4802
4803 /**
4804 * @tc.name : Test ChangeState
4805 * @tc.number: Player_ChangeState_001
4806 * @tc.desc : Test Player ChangeState interface
4807 */
4808 HWTEST_F(PlayerServerUnitTest, Player_ChangeState_001, TestSize.Level0)
4809 {
4810 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4811 std::shared_ptr<PlayerServerState> state = nullptr;
4812 server->ChangeState(state);
4813 EXPECT_EQ(server->currState_, state);
4814 }
4815
4816 /**
4817 * @tc.name : Test CheckSeek
4818 * @tc.number: Player_CheckSeek_001
4819 * @tc.desc : Test Player CheckSeek interface
4820 */
4821 HWTEST_F(PlayerServerUnitTest, Player_CheckSeek_001, TestSize.Level0)
4822 {
4823 std::shared_ptr<PlayerServer> server = std::make_shared<PlayerServer>();
4824 server->SetSource(VIDEO_FILE1);
4825 server->lastOpStatus_ = PLAYER_PREPARING;
4826 PlayerSeekMode mode = SEEK_PREVIOUS_SYNC;
4827 server->isLiveStream_ = true;
4828 EXPECT_EQ(server->CheckSeek(0, mode), MSERR_INVALID_OPERATION);
4829 }
4830
4831
4832 /**
4833 * @tc.name : Test SeekContinuous in prepared with seek -1
4834 * @tc.number: Player_SeekContinuous_007
4835 * @tc.desc : Test Player SeekContinuous
4836 */
4837 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_007, TestSize.Level0)
4838 {
4839 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4840 sptr<Surface> videoSurface = player_->GetVideoSurface();
4841 ASSERT_NE(nullptr, videoSurface);
4842 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4843 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4844 for (int i = 0; i < 10; i++) {
4845 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
4846 usleep(SEEK_CONTINUOUS_WAIT_US);
4847 }
4848 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
4849 EXPECT_EQ(MSERR_OK, player_->Play());
4850 }
4851
4852 /**
4853 * @tc.name : Test SeekContinuous in playing with seek -1
4854 * @tc.number: Player_SeekContinuous_008
4855 * @tc.desc : Test Player SeekContinuous
4856 */
4857 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_008, TestSize.Level0)
4858 {
4859 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4860 sptr<Surface> videoSurface = player_->GetVideoSurface();
4861 ASSERT_NE(nullptr, videoSurface);
4862 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4863 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4864 EXPECT_EQ(MSERR_OK, player_->Play());
4865 sleep(PLAYING_TIME_2_SEC);
4866 for (int i = 0; i < 30; i++) {
4867 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
4868 usleep(SEEK_CONTINUOUS_WAIT_US);
4869 }
4870 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
4871 EXPECT_EQ(MSERR_OK, player_->Stop());
4872 }
4873
4874 /**
4875 * @tc.name : Test SeekContinuous in paused with seek -1
4876 * @tc.number: Player_SeekContinuous_009
4877 * @tc.desc : Test Player SeekContinuous
4878 */
4879 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_009, TestSize.Level0)
4880 {
4881 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4882 sptr<Surface> videoSurface = player_->GetVideoSurface();
4883 ASSERT_NE(nullptr, videoSurface);
4884 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4885 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4886 EXPECT_EQ(MSERR_OK, player_->Play());
4887 sleep(PLAYING_TIME_2_SEC);
4888 EXPECT_EQ(MSERR_OK, player_->Pause());
4889 for (int i = 0; i < 30; i++) {
4890 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
4891 usleep(SEEK_CONTINUOUS_WAIT_US);
4892 }
4893 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
4894 EXPECT_EQ(MSERR_OK, player_->Play());
4895 EXPECT_EQ(MSERR_OK, player_->Stop());
4896 }
4897
4898 /**
4899 * @tc.name : Test SeekContinuous in completed with seek -1
4900 * @tc.number: Player_SeekContinuous_010
4901 * @tc.desc : Test Player SeekContinuous
4902 */
4903 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_010, TestSize.Level0)
4904 {
4905 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4906 sptr<Surface> videoSurface = player_->GetVideoSurface();
4907 ASSERT_NE(nullptr, videoSurface);
4908 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4909 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4910 EXPECT_EQ(MSERR_OK, player_->Play());
4911 sleep(PLAYING_TIME_2_SEC);
4912 EXPECT_EQ(MSERR_OK, player_->Seek(9000, SEEK_PREVIOUS_SYNC));
4913 sleep(PLAYING_TIME_10_SEC);
4914 for (int i = 0; i < 30; i++) {
4915 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
4916 usleep(SEEK_CONTINUOUS_WAIT_US);
4917 }
4918 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
4919 EXPECT_EQ(MSERR_OK, player_->Play());
4920 EXPECT_EQ(MSERR_OK, player_->Stop());
4921 }
4922
4923 /**
4924 * @tc.name : Test SeekContinuous backward with seek -1
4925 * @tc.number: Player_SeekContinuous_011
4926 * @tc.desc : Test Player SeekContinuous
4927 */
4928 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_011, TestSize.Level0)
4929 {
4930 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4931 sptr<Surface> videoSurface = player_->GetVideoSurface();
4932 ASSERT_NE(nullptr, videoSurface);
4933 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4934 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4935 EXPECT_EQ(MSERR_OK, player_->Play());
4936 sleep(PLAYING_TIME_2_SEC);
4937 for (int i = 0; i < 30; i++) {
4938 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
4939 usleep(SEEK_CONTINUOUS_WAIT_US);
4940 }
4941 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
4942 EXPECT_EQ(MSERR_OK, player_->Stop());
4943 }
4944
4945 /**
4946 * @tc.name : Test SeekContinuous forward and backward with seek -1
4947 * @tc.number: Player_SeekContinuous_012
4948 * @tc.desc : Test Player SeekContinuous
4949 */
4950 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_012, TestSize.Level0)
4951 {
4952 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
4953 sptr<Surface> videoSurface = player_->GetVideoSurface();
4954 ASSERT_NE(nullptr, videoSurface);
4955 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4956 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4957 EXPECT_EQ(MSERR_OK, player_->Play());
4958 sleep(PLAYING_TIME_2_SEC);
4959 for (int i = 0; i < 30; i++) {
4960 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
4961 usleep(SEEK_CONTINUOUS_WAIT_US);
4962 }
4963 for (int i = 0; i < 30; i++) {
4964 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
4965 usleep(SEEK_CONTINUOUS_WAIT_US);
4966 }
4967 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
4968 EXPECT_EQ(MSERR_OK, player_->Stop());
4969 }
4970
4971 /**
4972 * @tc.name : Test SeekContinuous in prepared mkv
4973 * @tc.number: Player_SeekContinuous_013
4974 * @tc.desc : Test Player SeekContinuous
4975 */
4976 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_013, TestSize.Level0)
4977 {
4978 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
4979 sptr<Surface> videoSurface = player_->GetVideoSurface();
4980 ASSERT_NE(nullptr, videoSurface);
4981 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
4982 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
4983 for (int i = 0; i < 10; i++) {
4984 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
4985 usleep(SEEK_CONTINUOUS_WAIT_US);
4986 }
4987 EXPECT_EQ(MSERR_OK, player_->Play());
4988 }
4989
4990 /**
4991 * @tc.name : Test SeekContinuous in playing mkv
4992 * @tc.number: Player_SeekContinuous_014
4993 * @tc.desc : Test Player SeekContinuous
4994 */
4995 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_014, TestSize.Level0)
4996 {
4997 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
4998 sptr<Surface> videoSurface = player_->GetVideoSurface();
4999 ASSERT_NE(nullptr, videoSurface);
5000 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5001 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5002 EXPECT_EQ(MSERR_OK, player_->Play());
5003 sleep(PLAYING_TIME_2_SEC);
5004 for (int i = 0; i < 30; i++) {
5005 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
5006 usleep(SEEK_CONTINUOUS_WAIT_US);
5007 }
5008 EXPECT_EQ(MSERR_OK, player_->Play());
5009 EXPECT_EQ(MSERR_OK, player_->Stop());
5010 }
5011
5012 /**
5013 * @tc.name : Test SeekContinuous in paused mkv
5014 * @tc.number: Player_SeekContinuous_015
5015 * @tc.desc : Test Player SeekContinuous
5016 */
5017 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_015, TestSize.Level0)
5018 {
5019 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
5020 sptr<Surface> videoSurface = player_->GetVideoSurface();
5021 ASSERT_NE(nullptr, videoSurface);
5022 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5023 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5024 EXPECT_EQ(MSERR_OK, player_->Play());
5025 sleep(PLAYING_TIME_2_SEC);
5026 EXPECT_EQ(MSERR_OK, player_->Pause());
5027 for (int i = 0; i < 30; i++) {
5028 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
5029 usleep(SEEK_CONTINUOUS_WAIT_US);
5030 }
5031 EXPECT_EQ(MSERR_OK, player_->Play());
5032 EXPECT_EQ(MSERR_OK, player_->Stop());
5033 }
5034
5035 /**
5036 * @tc.name : Test SeekContinuous in completed mkv
5037 * @tc.number: Player_SeekContinuous_016
5038 * @tc.desc : Test Player SeekContinuous
5039 */
5040 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_016, TestSize.Level0)
5041 {
5042 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
5043 sptr<Surface> videoSurface = player_->GetVideoSurface();
5044 ASSERT_NE(nullptr, videoSurface);
5045 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5046 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5047 EXPECT_EQ(MSERR_OK, player_->Play());
5048 sleep(PLAYING_TIME_2_SEC);
5049 EXPECT_EQ(MSERR_OK, player_->Seek(9000, SEEK_PREVIOUS_SYNC));
5050 sleep(PLAYING_TIME_10_SEC);
5051 for (int i = 0; i < 30; i++) {
5052 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
5053 usleep(SEEK_CONTINUOUS_WAIT_US);
5054 }
5055 EXPECT_EQ(MSERR_OK, player_->Play());
5056 EXPECT_EQ(MSERR_OK, player_->Stop());
5057 }
5058
5059 /**
5060 * @tc.name : Test SeekContinuous backward
5061 * @tc.number: Player_SeekContinuous_017 mkv
5062 * @tc.desc : Test Player SeekContinuous
5063 */
5064 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_017, TestSize.Level0)
5065 {
5066 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
5067 sptr<Surface> videoSurface = player_->GetVideoSurface();
5068 ASSERT_NE(nullptr, videoSurface);
5069 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5070 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5071 EXPECT_EQ(MSERR_OK, player_->Play());
5072 sleep(PLAYING_TIME_2_SEC);
5073 for (int i = 0; i < 30; i++) {
5074 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
5075 usleep(SEEK_CONTINUOUS_WAIT_US);
5076 }
5077 EXPECT_EQ(MSERR_OK, player_->Play());
5078 EXPECT_EQ(MSERR_OK, player_->Stop());
5079 }
5080
5081 /**
5082 * @tc.name : Test SeekContinuous forward and backward mkv
5083 * @tc.number: Player_SeekContinuous_018
5084 * @tc.desc : Test Player SeekContinuous
5085 */
5086 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_018, TestSize.Level0)
5087 {
5088 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
5089 sptr<Surface> videoSurface = player_->GetVideoSurface();
5090 ASSERT_NE(nullptr, videoSurface);
5091 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5092 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5093 EXPECT_EQ(MSERR_OK, player_->Play());
5094 sleep(PLAYING_TIME_2_SEC);
5095 for (int i = 0; i < 30; i++) {
5096 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
5097 usleep(SEEK_CONTINUOUS_WAIT_US);
5098 }
5099 for (int i = 0; i < 30; i++) {
5100 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
5101 usleep(SEEK_CONTINUOUS_WAIT_US);
5102 }
5103 EXPECT_EQ(MSERR_OK, player_->Play());
5104 EXPECT_EQ(MSERR_OK, player_->Stop());
5105 }
5106
5107 /**
5108 * @tc.name : Test SeekContinuous in prepared mkv with seek -1
5109 * @tc.number: Player_SeekContinuous_019
5110 * @tc.desc : Test Player SeekContinuous
5111 */
5112 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_019, TestSize.Level0)
5113 {
5114 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
5115 sptr<Surface> videoSurface = player_->GetVideoSurface();
5116 ASSERT_NE(nullptr, videoSurface);
5117 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5118 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5119 for (int i = 0; i < 10; i++) {
5120 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
5121 usleep(SEEK_CONTINUOUS_WAIT_US);
5122 }
5123 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
5124 EXPECT_EQ(MSERR_OK, player_->Play());
5125 }
5126
5127 /**
5128 * @tc.name : Test SeekContinuous in playing mkv with seek -1
5129 * @tc.number: Player_SeekContinuous_020
5130 * @tc.desc : Test Player SeekContinuous
5131 */
5132 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_020, TestSize.Level0)
5133 {
5134 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
5135 sptr<Surface> videoSurface = player_->GetVideoSurface();
5136 ASSERT_NE(nullptr, videoSurface);
5137 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5138 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5139 EXPECT_EQ(MSERR_OK, player_->Play());
5140 sleep(PLAYING_TIME_2_SEC);
5141 for (int i = 0; i < 30; i++) {
5142 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
5143 usleep(SEEK_CONTINUOUS_WAIT_US);
5144 }
5145 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
5146 EXPECT_EQ(MSERR_OK, player_->Stop());
5147 }
5148
5149 /**
5150 * @tc.name : Test SeekContinuous in paused mkv with seek -1
5151 * @tc.number: Player_SeekContinuous_021
5152 * @tc.desc : Test Player SeekContinuous
5153 */
5154 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_021, TestSize.Level0)
5155 {
5156 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
5157 sptr<Surface> videoSurface = player_->GetVideoSurface();
5158 ASSERT_NE(nullptr, videoSurface);
5159 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5160 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5161 EXPECT_EQ(MSERR_OK, player_->Play());
5162 sleep(PLAYING_TIME_2_SEC);
5163 EXPECT_EQ(MSERR_OK, player_->Pause());
5164 for (int i = 0; i < 30; i++) {
5165 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
5166 usleep(SEEK_CONTINUOUS_WAIT_US);
5167 }
5168 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
5169 EXPECT_EQ(MSERR_OK, player_->Play());
5170 EXPECT_EQ(MSERR_OK, player_->Stop());
5171 }
5172
5173 /**
5174 * @tc.name : Test SeekContinuous in completed with seek -1
5175 * @tc.number: Player_SeekContinuous_022
5176 * @tc.desc : Test Player SeekContinuous
5177 */
5178 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_022, TestSize.Level0)
5179 {
5180 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
5181 sptr<Surface> videoSurface = player_->GetVideoSurface();
5182 ASSERT_NE(nullptr, videoSurface);
5183 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5184 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5185 EXPECT_EQ(MSERR_OK, player_->Play());
5186 sleep(PLAYING_TIME_2_SEC);
5187 EXPECT_EQ(MSERR_OK, player_->Seek(9000, SEEK_PREVIOUS_SYNC));
5188 sleep(PLAYING_TIME_10_SEC);
5189 for (int i = 0; i < 30; i++) {
5190 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(i * 100));
5191 usleep(SEEK_CONTINUOUS_WAIT_US);
5192 }
5193 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
5194 EXPECT_EQ(MSERR_OK, player_->Play());
5195 EXPECT_EQ(MSERR_OK, player_->Stop());
5196 }
5197
5198 /**
5199 * @tc.name : Test SeekContinuous backward mkv with seek -1
5200 * @tc.number: Player_SeekContinuous_023
5201 * @tc.desc : Test Player SeekContinuous
5202 */
5203 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_023, TestSize.Level0)
5204 {
5205 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
5206 sptr<Surface> videoSurface = player_->GetVideoSurface();
5207 ASSERT_NE(nullptr, videoSurface);
5208 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5209 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5210 EXPECT_EQ(MSERR_OK, player_->Play());
5211 sleep(PLAYING_TIME_2_SEC);
5212 for (int i = 0; i < 30; i++) {
5213 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
5214 usleep(SEEK_CONTINUOUS_WAIT_US);
5215 }
5216 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
5217 EXPECT_EQ(MSERR_OK, player_->Stop());
5218 }
5219
5220 /**
5221 * @tc.name : Test SeekContinuous forward and backward mkv with seek -1
5222 * @tc.number: Player_SeekContinuous_024
5223 * @tc.desc : Test Player SeekContinuous
5224 */
5225 HWTEST_F(PlayerServerUnitTest, Player_SeekContinuous_024, TestSize.Level0)
5226 {
5227 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE3));
5228 sptr<Surface> videoSurface = player_->GetVideoSurface();
5229 ASSERT_NE(nullptr, videoSurface);
5230 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
5231 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
5232 EXPECT_EQ(MSERR_OK, player_->Play());
5233 sleep(PLAYING_TIME_2_SEC);
5234 for (int i = 0; i < 30; i++) {
5235 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
5236 usleep(SEEK_CONTINUOUS_WAIT_US);
5237 }
5238 for (int i = 0; i < 30; i++) {
5239 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(9000 - i * 100));
5240 usleep(SEEK_CONTINUOUS_WAIT_US);
5241 }
5242 EXPECT_EQ(MSERR_OK, player_->SeekContinuous(-1));
5243 EXPECT_EQ(MSERR_OK, player_->Stop());
5244 }
5245 } // namespace Media
5246 } // namespace OHOS
5247