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 <unistd.h>
17 #include <sys/stat.h>
18 #include "screen_capture_server_function_unittest.h"
19 #include "ui_extension_ability_connection.h"
20 #include "image_source.h"
21 #include "image_type.h"
22 #include "pixel_map.h"
23 #include "media_log.h"
24 #include "media_errors.h"
25 #include "media_utils.h"
26 #include "uri_helper.h"
27 #include "media_dfx.h"
28 #include "scope_guard.h"
29 #include "param_wrapper.h"
30 
31 using namespace testing::ext;
32 using namespace OHOS::Media::ScreenCaptureTestParam;
33 using namespace OHOS::Media;
34 
35 namespace {
36 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_SCREENCAPTURE, "ScreenCaptureServerFunctionTest"};
37 constexpr int32_t FLIE_CREATE_FLAGS = 0777;
38 static const std::string BUTTON_NAME_MIC = "mic";
39 static const std::string BUTTON_NAME_STOP = "stop";
40 static const int32_t MAX_SESSION_PER_UID = 8;
41 }
42 
43 namespace OHOS {
44 namespace Media {
45 
SetHapPermission()46 void ScreenCaptureServerFunctionTest::SetHapPermission()
47 {
48     Security::AccessToken::HapInfoParams info = {
49         .userID = 100, // 100 UserID
50         .bundleName = "com.ohos.test.screencapturetdd",
51         .instIndex = 0, // 0 index
52         .appIDDesc = "com.ohos.test.screencapturetdd",
53         .isSystemApp = true
54     };
55     Security::AccessToken::HapPolicyParams policy = {
56         .apl = Security::AccessToken::APL_SYSTEM_BASIC,
57         .domain = "test.domain.screencapturetdd",
58         .permList = {},
59         .permStateList = {
60             {
61                 .permissionName = "ohos.permission.MICROPHONE",
62                 .isGeneral = true,
63                 .resDeviceID = { "local" },
64                 .grantStatus = { Security::AccessToken::PermissionState::PERMISSION_GRANTED },
65                 .grantFlags = { 1 }
66             },
67             {
68                 .permissionName = "ohos.permission.READ_MEDIA",
69                 .isGeneral = true,
70                 .resDeviceID = { "local" },
71                 .grantStatus = { Security::AccessToken::PermissionState::PERMISSION_GRANTED },
72                 .grantFlags = { 1 }
73             },
74             {
75                 .permissionName = "ohos.permission.WRITE_MEDIA",
76                 .isGeneral = true,
77                 .resDeviceID = { "local" },
78                 .grantStatus = { Security::AccessToken::PermissionState::PERMISSION_GRANTED },
79                 .grantFlags = { 1 }
80             },
81             {
82                 .permissionName = "ohos.permission.KEEP_BACKGROUND_RUNNING",
83                 .isGeneral = true,
84                 .resDeviceID = { "local" },
85                 .grantStatus = { Security::AccessToken::PermissionState::PERMISSION_GRANTED },
86                 .grantFlags = { 1 }
87             }
88         }
89     };
90     Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
91     tokenIdEx = Security::AccessToken::AccessTokenKit::AllocHapToken(info, policy);
92     int ret = SetSelfTokenID(tokenIdEx.tokenIDEx);
93     if (ret != 0) {
94         MEDIA_LOGE("Set hap token failed, err: %{public}d", ret);
95     }
96 }
97 
SetUp()98 void ScreenCaptureServerFunctionTest::SetUp()
99 {
100     SetHapPermission();
101     std::shared_ptr<IScreenCaptureService> tempServer_ = ScreenCaptureServer::Create();
102     screenCaptureServer_ = std::static_pointer_cast<ScreenCaptureServer>(tempServer_);
103     ASSERT_NE(screenCaptureServer_, nullptr);
104 }
105 
TearDown()106 void ScreenCaptureServerFunctionTest::TearDown()
107 {
108     screenCaptureServer_->Release();
109     screenCaptureServer_ = nullptr;
110 }
111 
SetInvalidConfig()112 int32_t ScreenCaptureServerFunctionTest::SetInvalidConfig()
113 {
114     AudioCaptureInfo micCapinfo = {
115         .audioSampleRate = 0,
116         .audioChannels = 0,
117         .audioSource = SOURCE_DEFAULT
118     };
119 
120     AudioCaptureInfo innerCapInfo = {
121         .audioSampleRate = 0,
122         .audioChannels = 0,
123         .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT,
124     };
125 
126     VideoCaptureInfo videocapinfo = {
127         .videoFrameWidth = 720,
128         .videoFrameHeight = 1280,
129         .videoSource = VIDEO_SOURCE_SURFACE_RGBA
130     };
131 
132     VideoEncInfo videoEncInfo = {
133         .videoCodec = VideoCodecFormat::H264,
134         .videoBitrate = 2000000,
135         .videoFrameRate = 30
136     };
137 
138     AudioInfo audioInfo = {
139         .micCapInfo = micCapinfo,
140         .innerCapInfo = innerCapInfo,
141     };
142 
143     VideoInfo videoInfo = {
144         .videoCapInfo = videocapinfo,
145         .videoEncInfo = videoEncInfo
146     };
147 
148     config_ = {
149         .captureMode = CAPTURE_HOME_SCREEN,
150         .dataType = ORIGINAL_STREAM,
151         .audioInfo = audioInfo,
152         .videoInfo = videoInfo
153     };
154     return MSERR_OK;
155 }
156 
SetValidConfig()157 int32_t ScreenCaptureServerFunctionTest::SetValidConfig()
158 {
159     AudioCaptureInfo micCapinfo = {
160         .audioSampleRate = 16000,
161         .audioChannels = 2,
162         .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT
163     };
164 
165     AudioCaptureInfo innerCapInfo = {
166         .audioSampleRate = 16000,
167         .audioChannels = 2,
168         .audioSource = AudioCaptureSourceType::ALL_PLAYBACK,
169     };
170 
171     VideoCaptureInfo videocapinfo = {
172         .videoFrameWidth = 720,
173         .videoFrameHeight = 1280,
174         .videoSource = VIDEO_SOURCE_SURFACE_RGBA
175     };
176 
177     VideoEncInfo videoEncInfo = {
178         .videoCodec = VideoCodecFormat::H264,
179         .videoBitrate = 2000000,
180         .videoFrameRate = 30
181     };
182 
183     AudioInfo audioInfo = {
184         .micCapInfo = micCapinfo,
185         .innerCapInfo = innerCapInfo,
186     };
187 
188     VideoInfo videoInfo = {
189         .videoCapInfo = videocapinfo,
190         .videoEncInfo = videoEncInfo
191     };
192 
193     config_ = {
194         .captureMode = CAPTURE_HOME_SCREEN,
195         .dataType = ORIGINAL_STREAM,
196         .audioInfo = audioInfo,
197         .videoInfo = videoInfo
198     };
199     return MSERR_OK;
200 }
201 
SetInvalidConfigFile(RecorderInfo & recorderInfo)202 int32_t ScreenCaptureServerFunctionTest::SetInvalidConfigFile(RecorderInfo &recorderInfo)
203 {
204     AudioEncInfo audioEncInfo = {
205         .audioBitrate = 48000,
206         .audioCodecformat = AudioCodecFormat::AAC_LC
207     };
208 
209     VideoCaptureInfo videoCapInfo = {
210         .videoFrameWidth = 720,
211         .videoFrameHeight = 1080,
212         .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
213     };
214 
215     VideoEncInfo videoEncInfo = {
216         .videoCodec = VideoCodecFormat::H264,
217         .videoBitrate = 2000000,
218         .videoFrameRate = 30
219     };
220 
221     AudioCaptureInfo innerCapInfo = {
222         .audioSampleRate = 0,
223         .audioChannels = 0,
224         .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT,
225     };
226 
227     AudioCaptureInfo micCapinfo = {
228         .audioSampleRate = 0,
229         .audioChannels = 0,
230         .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT,
231     };
232 
233     AudioInfo audioInfo = {
234         .micCapInfo = micCapinfo,
235         .innerCapInfo = innerCapInfo,
236         .audioEncInfo = audioEncInfo
237     };
238 
239     VideoInfo videoInfo = {
240         .videoCapInfo = videoCapInfo,
241         .videoEncInfo = videoEncInfo
242     };
243 
244     config_ = {
245         .captureMode = CaptureMode::CAPTURE_HOME_SCREEN,
246         .dataType = DataType::CAPTURE_FILE,
247         .audioInfo = audioInfo,
248         .videoInfo = videoInfo,
249         .recorderInfo = recorderInfo
250     };
251     return MSERR_OK;
252 }
253 
SetValidConfigFile(RecorderInfo & recorderInfo)254 int32_t ScreenCaptureServerFunctionTest::SetValidConfigFile(RecorderInfo &recorderInfo)
255 {
256     AudioEncInfo audioEncInfo = {
257         .audioBitrate = 48000,
258         .audioCodecformat = AudioCodecFormat::AAC_LC
259     };
260 
261     VideoCaptureInfo videoCapInfo = {
262         .videoFrameWidth = 720,
263         .videoFrameHeight = 1080,
264         .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
265     };
266 
267     VideoEncInfo videoEncInfo = {
268         .videoCodec = VideoCodecFormat::H264,
269         .videoBitrate = 2000000,
270         .videoFrameRate = 30
271     };
272 
273     AudioCaptureInfo micCapinfo = {
274         .audioSampleRate = 16000,
275         .audioChannels = 2,
276         .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT
277     };
278 
279     AudioCaptureInfo innerCapInfo = {
280         .audioSampleRate = 16000,
281         .audioChannels = 2,
282         .audioSource = AudioCaptureSourceType::ALL_PLAYBACK,
283     };
284 
285     AudioInfo audioInfo = {
286         .micCapInfo = micCapinfo,
287         .innerCapInfo = innerCapInfo,
288         .audioEncInfo = audioEncInfo
289     };
290 
291     VideoInfo videoInfo = {
292         .videoCapInfo = videoCapInfo,
293         .videoEncInfo = videoEncInfo
294     };
295 
296     config_ = {
297         .captureMode = CaptureMode::CAPTURE_HOME_SCREEN,
298         .dataType = DataType::CAPTURE_FILE,
299         .audioInfo = audioInfo,
300         .videoInfo = videoInfo,
301         .recorderInfo = recorderInfo
302     };
303     return MSERR_OK;
304 }
305 
SetRecorderInfo(std::string name,RecorderInfo & recorderInfo)306 int32_t ScreenCaptureServerFunctionTest::SetRecorderInfo(std::string name,
307     RecorderInfo &recorderInfo)
308 {
309     OpenFileFd(name);
310     recorderInfo.url = "fd://" + std::to_string(outputFd_);
311     recorderInfo.fileFormat = "mp4";
312     return MSERR_OK;
313 }
314 
315 static const std::string SCREEN_CAPTURE_ROOT_DIR = "/data/test/media/";
316 
OpenFileFd(std::string name)317 void ScreenCaptureServerFunctionTest::OpenFileFd(std::string name)
318 {
319     if (outputFd_ != -1) {
320         (void)::close(outputFd_);
321         outputFd_ = -1;
322     }
323     outputFd_ = open((SCREEN_CAPTURE_ROOT_DIR + name).c_str(), O_RDWR | O_CREAT, FLIE_CREATE_FLAGS);
324 }
325 
InitFileScreenCaptureServer()326 int32_t ScreenCaptureServerFunctionTest::InitFileScreenCaptureServer()
327 {
328     int32_t ret = screenCaptureServer_->SetCaptureMode(config_.captureMode);
329     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetCaptureMode failed");
330     ret = screenCaptureServer_->SetDataType(config_.dataType);
331     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetDataType failed");
332     ret = screenCaptureServer_->SetRecorderInfo(config_.recorderInfo);
333     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetRecorderInfo failed");
334     const std::string fdHead = "fd://";
335     CHECK_AND_RETURN_RET_LOG(config_.recorderInfo.url.find(fdHead) != std::string::npos, MSERR_INVALID_VAL,
336         "check url failed");
337     int32_t outputFd = -1;
338     std::string inputFd = config_.recorderInfo.url.substr(fdHead.size());
339     CHECK_AND_RETURN_RET_LOG(StrToInt(inputFd, outputFd) == true && outputFd >= 0, MSERR_INVALID_VAL,
340         "open file failed");
341     ret = screenCaptureServer_->SetOutputFile(outputFd);
342     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetOutputFile failed");
343     ret = screenCaptureServer_->InitAudioEncInfo(config_.audioInfo.audioEncInfo);
344     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "InitAudioEncInfo failed");
345     ret = screenCaptureServer_->InitAudioCap(config_.audioInfo.micCapInfo);
346     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "init micAudioCap failed");
347     ret = screenCaptureServer_->InitAudioCap(config_.audioInfo.innerCapInfo);
348     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "init innerCapInfo failed, innerCapInfo should be valid");
349 
350     ret = screenCaptureServer_->InitVideoEncInfo(config_.videoInfo.videoEncInfo);
351     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "InitVideoEncInfo failed");
352     ret = screenCaptureServer_->InitVideoCap(config_.videoInfo.videoCapInfo);
353     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "InitVideoCap failed");
354     return MSERR_OK;
355 }
356 
InitStreamScreenCaptureServer()357 int32_t ScreenCaptureServerFunctionTest::InitStreamScreenCaptureServer()
358 {
359     int32_t ret = screenCaptureServer_->SetCaptureMode(config_.captureMode);
360     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetCaptureMode failed");
361     ret = screenCaptureServer_->SetDataType(config_.dataType);
362     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetDataType failed");
363     ret = screenCaptureServer_->InitAudioCap(config_.audioInfo.micCapInfo);
364     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "init micAudioCap failed");
365     ret = screenCaptureServer_->InitAudioCap(config_.audioInfo.innerCapInfo);
366     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "init innerCapInfo failed, innerCapInfo should be valid");
367     ret = screenCaptureServer_->InitVideoCap(config_.videoInfo.videoCapInfo);
368     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "InitVideoCap failed");
369     return MSERR_OK;
370 }
371 
StartFileAudioCapture()372 int32_t ScreenCaptureServerFunctionTest::StartFileAudioCapture()
373 {
374     screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
375         AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
376     screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
377     screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
378     MEDIA_LOGI("StartFileAudioCapture start");
379     int32_t ret = screenCaptureServer_->StartFileInnerAudioCapture();
380     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "StartFileInnerAudioCapture failed, ret:%{public}d,"
381         "dataType:%{public}d", ret, screenCaptureServer_->captureConfig_.dataType);
382     ret = screenCaptureServer_->StartFileMicAudioCapture();
383     if (ret != MSERR_OK) {
384         MEDIA_LOGE("StartFileMicAudioCapture failed");
385     }
386     return ret;
387 }
388 
StartStreamAudioCapture()389 int32_t ScreenCaptureServerFunctionTest::StartStreamAudioCapture()
390 {
391     screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
392         AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
393     screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
394     screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
395     MEDIA_LOGI("StartStreamAudioCapture start");
396     int32_t ret = screenCaptureServer_->StartStreamInnerAudioCapture();
397     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "StartFileInnerAudioCapture failed, ret:%{public}d,"
398         "dataType:%{public}d", ret, screenCaptureServer_->captureConfig_.dataType);
399     ret = screenCaptureServer_->StartStreamMicAudioCapture();
400     if (ret != MSERR_OK) {
401         MEDIA_LOGE("StartFileMicAudioCapture failed");
402     }
403     MEDIA_LOGI("StartStreamAudioCapture end");
404     return ret;
405 }
406 
407 // videoCapInfo and innerCapInfo IGNORE
408 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_001, TestSize.Level2)
409 {
410     SetInvalidConfig();
411     config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
412     config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
413     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
414     ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
415 }
416 
417 // audioSampleRate INVALID
418 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_002, TestSize.Level2)
419 {
420     SetInvalidConfig();
421     config_.audioInfo.micCapInfo.audioSampleRate = 12345;
422     config_.audioInfo.micCapInfo.audioChannels = 2;
423     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
424     config_.audioInfo.innerCapInfo.audioSampleRate = 54321;
425     config_.audioInfo.innerCapInfo.audioChannels = 2;
426     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
427     ASSERT_NE(InitStreamScreenCaptureServer(), MSERR_OK);
428 }
429 
430 // videoCapInfo INVALID
431 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_003, TestSize.Level2)
432 {
433     SetInvalidConfig();
434     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
435     config_.audioInfo.micCapInfo.audioChannels = 2;
436     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
437     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
438     config_.audioInfo.innerCapInfo.audioChannels = 2;
439     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
440     config_.videoInfo.videoCapInfo.videoFrameWidth = -1;
441     config_.videoInfo.videoCapInfo.videoFrameHeight = -1;
442     ASSERT_NE(InitStreamScreenCaptureServer(), MSERR_OK);
443 }
444 
445 // dataType INVALID
446 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_004, TestSize.Level2)
447 {
448     SetInvalidConfig();
449     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
450     config_.audioInfo.micCapInfo.audioChannels = 2;
451     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
452     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
453     config_.audioInfo.innerCapInfo.audioChannels = 2;
454     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
455     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
456     screenCaptureServer_->captureConfig_.dataType = DataType::INVAILD;
457     ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
458 }
459 
460 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_005, TestSize.Level2)
461 {
462     SetInvalidConfig();
463     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
464     config_.audioInfo.micCapInfo.audioChannels = 2;
465     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
466     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
467     config_.audioInfo.innerCapInfo.audioChannels = 2;
468     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
469     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
470     screenCaptureServer_->isSurfaceMode_ = true;
471     screenCaptureServer_->surface_ = nullptr;
472     ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
473 }
474 
475 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_006, TestSize.Level2)
476 {
477     SetInvalidConfig();
478     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
479     config_.audioInfo.micCapInfo.audioChannels = 2;
480     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
481     config_.audioInfo.innerCapInfo.audioSampleRate = 1;
482     config_.audioInfo.innerCapInfo.audioChannels = 2;
483     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
484     screenCaptureServer_->captureConfig_ = config_;
485     ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
486 }
487 
488 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_001, TestSize.Level2)
489 {
490     RecorderInfo recorderInfo;
491     SetRecorderInfo("capture_file_params_invalid_001.mp4", recorderInfo);
492     SetInvalidConfigFile(recorderInfo);
493     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
494     config_.audioInfo.micCapInfo.audioChannels = 2;
495     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
496     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
497     config_.audioInfo.innerCapInfo.audioChannels = 2;
498     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
499     config_.videoInfo.videoCapInfo.videoFrameWidth = -1;
500     config_.videoInfo.videoCapInfo.videoFrameHeight = -1;
501     ASSERT_NE(InitFileScreenCaptureServer(), MSERR_OK);
502 }
503 
504 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_002, TestSize.Level2)
505 {
506     RecorderInfo recorderInfo;
507     SetRecorderInfo("capture_file_params_invalid_002.mp4", recorderInfo);
508     SetInvalidConfigFile(recorderInfo);
509     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
510     config_.audioInfo.micCapInfo.audioChannels = 2;
511     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
512     config_.audioInfo.innerCapInfo.audioSampleRate = 1;
513     config_.audioInfo.innerCapInfo.audioChannels = 2;
514     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
515     ASSERT_NE(InitFileScreenCaptureServer(), MSERR_OK);
516 }
517 
518 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_003, TestSize.Level2)
519 {
520     RecorderInfo recorderInfo;
521     SetRecorderInfo("capture_file_params_invalid_003.mp4", recorderInfo);
522     SetInvalidConfigFile(recorderInfo);
523     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
524     config_.audioInfo.micCapInfo.audioChannels = 2;
525     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
526     config_.audioInfo.innerCapInfo.audioSampleRate = 8000;
527     config_.audioInfo.innerCapInfo.audioChannels = 2;
528     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
529     ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
530     ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
531 }
532 
533 // videoCapInfo Ignored, is valid
534 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_004, TestSize.Level2)
535 {
536     RecorderInfo recorderInfo;
537     SetRecorderInfo("capture_file_params_invalid_004.mp4", recorderInfo);
538     SetInvalidConfigFile(recorderInfo);
539     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
540     config_.audioInfo.micCapInfo.audioChannels = 2;
541     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
542     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
543     config_.audioInfo.innerCapInfo.audioChannels = 2;
544     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
545     config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
546     config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
547     screenCaptureServer_->captureConfig_ = config_;
548     ASSERT_EQ(screenCaptureServer_->CheckAllParams(), MSERR_OK);
549 }
550 
551 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_005, TestSize.Level2)
552 {
553     RecorderInfo recorderInfo;
554     SetRecorderInfo("capture_file_params_invalid_005.mp4", recorderInfo);
555     SetInvalidConfigFile(recorderInfo);
556     config_.audioInfo.micCapInfo.audioSampleRate = -1;
557     config_.audioInfo.micCapInfo.audioChannels = 2;
558     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
559     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
560     config_.audioInfo.innerCapInfo.audioChannels = 2;
561     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
562     screenCaptureServer_->captureConfig_ = config_;
563     ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
564 }
565 
566 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_006, TestSize.Level2)
567 {
568     RecorderInfo recorderInfo;
569     SetRecorderInfo("capture_file_params_invalid_006.mp4", recorderInfo);
570     SetInvalidConfigFile(recorderInfo);
571     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
572     config_.audioInfo.micCapInfo.audioChannels = 2;
573     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
574     config_.audioInfo.innerCapInfo.audioSampleRate = -1;
575     config_.audioInfo.innerCapInfo.audioChannels = 2;
576     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
577     screenCaptureServer_->captureConfig_ = config_;
578     ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
579 }
580 
581 // micCapInfo Ignored, is valid
582 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_007, TestSize.Level2)
583 {
584     RecorderInfo recorderInfo;
585     SetRecorderInfo("capture_file_params_invalid_007.mp4", recorderInfo);
586     SetInvalidConfigFile(recorderInfo);
587     config_.audioInfo.micCapInfo.audioSampleRate = 0;
588     config_.audioInfo.micCapInfo.audioChannels = 0;
589     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
590     config_.audioInfo.innerCapInfo.audioChannels = 2;
591     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
592     screenCaptureServer_->captureConfig_ = config_;
593     ASSERT_EQ(screenCaptureServer_->CheckAllParams(), MSERR_OK);
594 }
595 
596 // audioChannels is different
597 HWTEST_F(ScreenCaptureServerFunctionTest, capture_file_params_invalid_008, TestSize.Level2)
598 {
599     RecorderInfo recorderInfo;
600     SetRecorderInfo("capture_file_params_invalid_008.mp4", recorderInfo);
601     SetInvalidConfigFile(recorderInfo);
602     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
603     config_.audioInfo.micCapInfo.audioChannels = 1;
604     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
605     config_.audioInfo.innerCapInfo.audioChannels = 2;
606     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
607     screenCaptureServer_->captureConfig_ = config_;
608     ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
609 }
610 
611 HWTEST_F(ScreenCaptureServerFunctionTest, StartPrivacyWindow_001, TestSize.Level2)
612 {
613     ASSERT_NE(screenCaptureServer_->StartPrivacyWindow(), MSERR_OK);
614 }
615 
616 HWTEST_F(ScreenCaptureServerFunctionTest, GetMissionIds_001, TestSize.Level2)
617 {
618     SetInvalidConfig();
619     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
620     config_.audioInfo.micCapInfo.audioChannels = 2;
621     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
622     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
623     config_.audioInfo.innerCapInfo.audioChannels = 2;
624     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
625     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
626     ASSERT_EQ(screenCaptureServer_->GetMissionIds(screenCaptureServer_->missionIds_), MSERR_OK);
627 }
628 
629 HWTEST_F(ScreenCaptureServerFunctionTest, GetMissionIds_002, TestSize.Level2)
630 {
631     SetInvalidConfig();
632     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
633     config_.audioInfo.micCapInfo.audioChannels = 2;
634     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
635     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
636     config_.audioInfo.innerCapInfo.audioChannels = 2;
637     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
638     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
639     screenCaptureServer_->captureConfig_.videoInfo.videoCapInfo.taskIDs.push_back(1);
640     screenCaptureServer_->captureConfig_.videoInfo.videoCapInfo.taskIDs.push_back(2);
641     ASSERT_EQ(screenCaptureServer_->GetMissionIds(screenCaptureServer_->missionIds_), MSERR_OK);
642 }
643 
644 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_001, TestSize.Level2)
645 {
646     SetInvalidConfig();
647     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
648     config_.audioInfo.micCapInfo.audioChannels = 2;
649     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
650     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
651     config_.audioInfo.innerCapInfo.audioChannels = 2;
652     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
653     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
654     ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
655     std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
656     screenCaptureServer_->captureCallback_->OnRendererStateChange(audioRendererChangeInfos);
657     screenCaptureServer_->audioSource_->VoIPStateUpdate(audioRendererChangeInfos);
658     screenCaptureServer_->audioSource_->isInVoIPCall_ = true;
659     screenCaptureServer_->audioSource_->VoIPStateUpdate(audioRendererChangeInfos);
660     sleep(RECORDER_TIME);
661     ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
662 }
663 
664 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_002, TestSize.Level2)
665 {
666     SetInvalidConfig();
667     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
668     config_.audioInfo.micCapInfo.audioChannels = 2;
669     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
670     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
671     config_.audioInfo.innerCapInfo.audioChannels = 2;
672     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
673     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
674     ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
675     std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
676     screenCaptureServer_->audioSource_->SpeakerStateUpdate(audioRendererChangeInfos);
677     screenCaptureServer_->audioSource_->HasSpeakerStream(audioRendererChangeInfos);
678     sleep(RECORDER_TIME);
679     ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
680 }
681 
682 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_001, TestSize.Level2)
683 {
684     SetInvalidConfig();
685     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
686     config_.audioInfo.micCapInfo.audioChannels = 2;
687     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
688     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
689     config_.audioInfo.innerCapInfo.audioChannels = 2;
690     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
691     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
692     int32_t sessionId = 0;
693     std::string choice = "{\"choice\": \"false\", \"displayId\": -1, \"missionId\": -1}";
694     ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
695 }
696 
697 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_002, TestSize.Level2)
698 {
699     SetInvalidConfig();
700     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
701     config_.audioInfo.micCapInfo.audioChannels = 2;
702     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
703     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
704     config_.audioInfo.innerCapInfo.audioChannels = 2;
705     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
706     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
707     int32_t sessionId = 0;
708     std::string choice = "{\"choice\": \"true\", \"displayId\": -1, \"missionId\": -1}";
709     ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
710 }
711 
712 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_003, TestSize.Level2)
713 {
714     SetInvalidConfig();
715     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
716     config_.audioInfo.micCapInfo.audioChannels = 2;
717     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
718     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
719     config_.audioInfo.innerCapInfo.audioChannels = 2;
720     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
721     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
722     int32_t sessionId = -1;
723     std::string choice = "{\"choice\": \"true\", \"displayId\": -1, \"missionId\": -1}";
724     ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
725 }
726 
727 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_004, TestSize.Level2)
728 {
729     SetInvalidConfig();
730     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
731     config_.audioInfo.micCapInfo.audioChannels = 2;
732     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
733     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
734     config_.audioInfo.innerCapInfo.audioChannels = 2;
735     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
736     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
737     int32_t sessionId = 0;
738     std::string choice = "{\"choice\": \"12345\", \"displayId\": -1, \"missionId\": -1}";
739     ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
740 }
741 
742 HWTEST_F(ScreenCaptureServerFunctionTest, CheckScreenCapturePermission_001, TestSize.Level2)
743 {
744     SetInvalidConfig();
745     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
746     config_.audioInfo.micCapInfo.audioChannels = 2;
747     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
748     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
749     config_.audioInfo.innerCapInfo.audioChannels = 2;
750     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
751     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
752     ASSERT_EQ(screenCaptureServer_->CheckScreenCapturePermission(), false);
753 }
754 
755 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_001, TestSize.Level2)
756 {
757     SetInvalidConfig();
758     config_.videoInfo.videoEncInfo.videoCodec = VIDEO_CODEC_FORMAT_BUTT;
759     ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
760 }
761 
762 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_002, TestSize.Level2)
763 {
764     SetInvalidConfig();
765     config_.videoInfo.videoEncInfo.videoBitrate = screenCaptureServer_->VIDEO_BITRATE_MIN - 1;
766     ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
767 }
768 
769 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_003, TestSize.Level2)
770 {
771     SetInvalidConfig();
772     config_.videoInfo.videoEncInfo.videoBitrate = screenCaptureServer_->VIDEO_BITRATE_MAX + 1;
773     ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
774 }
775 
776 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_004, TestSize.Level2)
777 {
778     SetInvalidConfig();
779     config_.videoInfo.videoEncInfo.videoFrameRate = screenCaptureServer_->VIDEO_FRAME_RATE_MIN - 1;
780     ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
781 }
782 
783 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_005, TestSize.Level2)
784 {
785     SetInvalidConfig();
786     config_.videoInfo.videoEncInfo.videoFrameRate = screenCaptureServer_->VIDEO_FRAME_RATE_MAX + 1;
787     ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
788 }
789 
790 HWTEST_F(ScreenCaptureServerFunctionTest, SetOutputFile_001, TestSize.Level2)
791 {
792     ASSERT_NE(screenCaptureServer_->SetOutputFile(-1), MSERR_OK);
793 }
794 
795 HWTEST_F(ScreenCaptureServerFunctionTest, OnStartScreenCapture_001, TestSize.Level2)
796 {
797     SetInvalidConfig();
798     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
799     config_.audioInfo.micCapInfo.audioChannels = 2;
800     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
801     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
802     config_.audioInfo.innerCapInfo.audioChannels = 2;
803     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
804     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
805     ASSERT_NE(screenCaptureServer_->OnStartScreenCapture(), MSERR_OK);
806 }
807 
808 HWTEST_F(ScreenCaptureServerFunctionTest, OnStartScreenCapture_002, TestSize.Level2)
809 {
810     RecorderInfo recorderInfo;
811     SetRecorderInfo("on_start_screen_capture_unittest_002.mp4", recorderInfo);
812     SetInvalidConfigFile(recorderInfo);
813     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
814     config_.audioInfo.micCapInfo.audioChannels = 2;
815     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
816     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
817     config_.audioInfo.innerCapInfo.audioChannels = 2;
818     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
819     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
820     ASSERT_NE(screenCaptureServer_->OnStartScreenCapture(), MSERR_OK);
821 }
822 
823 HWTEST_F(ScreenCaptureServerFunctionTest, SetScreenScaleMode_001, TestSize.Level2)
824 {
825     ASSERT_NE(screenCaptureServer_->SetScreenScaleMode(), MSERR_OK);
826 }
827 
828 HWTEST_F(ScreenCaptureServerFunctionTest, Create_001, TestSize.Level2)
829 {
830     std::vector<std::shared_ptr<IScreenCaptureService>> tempServers(MAX_SESSION_PER_UID - 1, nullptr);
831     std::vector<std::shared_ptr<ScreenCaptureServer>> screenCaptureServers(MAX_SESSION_PER_UID - 1, nullptr);
832 
833     for (int i = 0; i < MAX_SESSION_PER_UID - 1; ++i) {
834         tempServers[i] = ScreenCaptureServer::Create();
835         screenCaptureServers[i] = std::static_pointer_cast<ScreenCaptureServer>(tempServers[i]);
836         ASSERT_NE(screenCaptureServers[i], nullptr);
837     }
838     std::shared_ptr<IScreenCaptureService> tempServer2 = ScreenCaptureServer::Create();
839     ASSERT_EQ(tempServer2, nullptr);
840     for (int i = 0; i < MAX_SESSION_PER_UID - 1; ++i) {
841         screenCaptureServers[i]->Release();
842         screenCaptureServers[i] = nullptr;
843         tempServers[i] = nullptr;
844     }
845 }
846 
847 HWTEST_F(ScreenCaptureServerFunctionTest, RequestUserPrivacyAuthority_001, TestSize.Level2)
848 {
849     screenCaptureServer_->appInfo_.appUid = ROOT_UID;
850 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION
851     screenCaptureServer_->isPrivacyAuthorityEnabled_ = true;
852 #endif
853     ASSERT_EQ(screenCaptureServer_->RequestUserPrivacyAuthority(), MSERR_OK);
854 }
855 
856 HWTEST_F(ScreenCaptureServerFunctionTest, RequestUserPrivacyAuthority_002, TestSize.Level2)
857 {
858     screenCaptureServer_->appInfo_.appUid = ROOT_UID;
859 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION
860     screenCaptureServer_->isPrivacyAuthorityEnabled_ = true;
861     screenCaptureServer_->appName_ = ScreenRecorderBundleName;
862 #endif
863     ASSERT_EQ(screenCaptureServer_->RequestUserPrivacyAuthority(), MSERR_OK);
864 }
865 
866 HWTEST_F(ScreenCaptureServerFunctionTest, RequestUserPrivacyAuthority_003, TestSize.Level2)
867 {
868     screenCaptureServer_->appInfo_.appUid = ROOT_UID + 1;
869 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION
870     screenCaptureServer_->isPrivacyAuthorityEnabled_ = true;
871 #endif
872     ASSERT_NE(screenCaptureServer_->RequestUserPrivacyAuthority(), MSERR_OK);
873 }
874 
875 HWTEST_F(ScreenCaptureServerFunctionTest, RequestUserPrivacyAuthority_004, TestSize.Level2)
876 {
877     screenCaptureServer_->appInfo_.appUid = ROOT_UID + 1;
878 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION
879     screenCaptureServer_->isPrivacyAuthorityEnabled_ = true;
880     screenCaptureServer_->appName_ = ScreenRecorderBundleName;
881 #endif
882     ASSERT_NE(screenCaptureServer_->RequestUserPrivacyAuthority(), MSERR_OK);
883 }
884 
885 HWTEST_F(ScreenCaptureServerFunctionTest, OnReceiveUserPrivacyAuthority_001, TestSize.Level2)
886 {
887     screenCaptureServer_->screenCaptureCb_ = std::make_shared<ScreenCaptureServerUnittestCallback>();
888     ASSERT_NE(screenCaptureServer_->OnReceiveUserPrivacyAuthority(false), MSERR_OK);
889     screenCaptureServer_->screenCaptureCb_ = nullptr;
890 }
891 
892 HWTEST_F(ScreenCaptureServerFunctionTest, OnReceiveUserPrivacyAuthority_002, TestSize.Level2)
893 {
894     screenCaptureServer_->screenCaptureCb_ = std::make_shared<ScreenCaptureServerUnittestCallback>();
895     screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTING;
896     ASSERT_NE(screenCaptureServer_->OnReceiveUserPrivacyAuthority(false), MSERR_OK);
897     screenCaptureServer_->screenCaptureCb_ = nullptr;
898 }
899 
900 HWTEST_F(ScreenCaptureServerFunctionTest, OnReceiveUserPrivacyAuthority_003, TestSize.Level2)
901 {
902     screenCaptureServer_->screenCaptureCb_ = std::make_shared<ScreenCaptureServerUnittestCallback>();
903     screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTING;
904     ASSERT_NE(screenCaptureServer_->OnReceiveUserPrivacyAuthority(true), MSERR_OK);
905     screenCaptureServer_->screenCaptureCb_ = nullptr;
906 }
907 
908 HWTEST_F(ScreenCaptureServerFunctionTest, RepeatStartAudioCapture_001, TestSize.Level2)
909 {
910     SetInvalidConfig();
911     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
912     config_.audioInfo.micCapInfo.audioChannels = 2;
913     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
914     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
915     config_.audioInfo.innerCapInfo.audioChannels = 2;
916     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
917     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
918     ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
919     ASSERT_NE(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK);
920 }
921 
922 HWTEST_F(ScreenCaptureServerFunctionTest, RepeatResumeAudioCapture_001, TestSize.Level2)
923 {
924     SetInvalidConfig();
925     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
926     config_.audioInfo.micCapInfo.audioChannels = 2;
927     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
928     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
929     config_.audioInfo.innerCapInfo.audioChannels = 2;
930     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
931     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
932     ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
933     ASSERT_NE(screenCaptureServer_->innerAudioCapture_->Resume(), MSERR_OK);
934 }
935 
936 HWTEST_F(ScreenCaptureServerFunctionTest, RepeatPauseAudioCapture_001, TestSize.Level2)
937 {
938     SetInvalidConfig();
939     config_.audioInfo.micCapInfo.audioSampleRate = 16000;
940     config_.audioInfo.micCapInfo.audioChannels = 2;
941     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
942     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
943     config_.audioInfo.innerCapInfo.audioChannels = 2;
944     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
945     ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
946     ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
947     ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Pause(), MSERR_OK);
948     ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Pause(), MSERR_OK);
949 }
950 
951 HWTEST_F(ScreenCaptureServerFunctionTest, UpdatePrivacyUsingPermissionState_001, TestSize.Level2)
952 {
953     screenCaptureServer_->appInfo_.appUid = ROOT_UID;
954     ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(START_VIDEO), true);
955     ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(STOP_VIDEO), true);
956 }
957 
958 HWTEST_F(ScreenCaptureServerFunctionTest, UpdatePrivacyUsingPermissionState_002, TestSize.Level2)
959 {
960     screenCaptureServer_->appInfo_.appUid = ROOT_UID + 1;
961     ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(START_VIDEO), false);
962     ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(STOP_VIDEO), false);
963 }
964 
965 HWTEST_F(ScreenCaptureServerFunctionTest, StartScreenCaptureWithSurface_001, TestSize.Level2)
966 {
967     screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
968     ASSERT_NE(screenCaptureServer_->StartScreenCaptureWithSurface(nullptr, true), MSERR_OK);
969 }
970 } // Media
971 } // OHOS