1/*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include <gtest/gtest.h>
17#include "display_dumper.h"
18#include "display_manager_service.h"
19#include "scene_board_judgement.h"
20
21using namespace testing;
22using namespace testing::ext;
23
24namespace OHOS {
25namespace Rosen {
26class DisplayDumperTest : public testing::Test {
27public:
28    static void SetUpTestCase();
29    static void TearDownTestCase();
30    void SetUp() override;
31    void TearDown() override;
32};
33
34void DisplayDumperTest::SetUpTestCase()
35{
36}
37
38void DisplayDumperTest::TearDownTestCase()
39{
40}
41
42void DisplayDumperTest::SetUp()
43{
44}
45
46void DisplayDumperTest::TearDown()
47{
48}
49
50namespace {
51/**
52 * @tc.name: Dump01
53 * @tc.desc: Dump
54 * @tc.type: FUNC
55 */
56HWTEST_F(DisplayDumperTest, Dump01, Function | SmallTest | Level1)
57{
58    sptr<DisplayDumper> displayDumper;
59    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
60        DisplayManagerService::GetInstance().abstractScreenController_,
61        DisplayManagerService::GetInstance().mutex_);
62    int fd = 1;
63    std::vector<std::u16string> args;
64    DMError ret = displayDumper->Dump(fd, args);
65    ASSERT_EQ(ret, DMError::DM_OK);
66}
67
68/**
69 * @tc.name: Dump02
70 * @tc.desc: Dump fd less 0
71 * @tc.type: FUNC
72 */
73HWTEST_F(DisplayDumperTest, Dump02, Function | SmallTest | Level1)
74{
75    sptr<DisplayDumper> displayDumper;
76    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
77        DisplayManagerService::GetInstance().abstractScreenController_,
78        DisplayManagerService::GetInstance().mutex_);
79    int fd = -1;
80    std::vector<std::u16string> args;
81    DMError ret = displayDumper->Dump(fd, args);
82    ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
83}
84
85/**
86 * @tc.name: Dump03
87 * @tc.desc: Dump one param with '-h'
88 * @tc.type: FUNC
89 */
90HWTEST_F(DisplayDumperTest, Dump03, Function | SmallTest | Level1)
91{
92    sptr<DisplayDumper> displayDumper;
93    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
94        DisplayManagerService::GetInstance().abstractScreenController_,
95        DisplayManagerService::GetInstance().mutex_);
96    int fd = 3;
97    std::vector<std::u16string> args;
98    const std::u16string DUMP_HELP = u"-h";
99    args.emplace_back(DUMP_HELP);
100    DMError ret = displayDumper->Dump(fd, args);
101    ASSERT_TRUE(ret == DMError::DM_OK || ret == DMError::DM_ERROR_UNKNOWN);
102}
103
104/**
105 * @tc.name: Dump04
106 * @tc.desc: Dump one param with '-x'
107 * @tc.type: FUNC
108 */
109HWTEST_F(DisplayDumperTest, Dump04, Function | SmallTest | Level1)
110{
111    sptr<DisplayDumper> displayDumper;
112    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
113        DisplayManagerService::GetInstance().abstractScreenController_,
114        DisplayManagerService::GetInstance().mutex_);
115    int fd = 4;
116    std::vector<std::u16string> args;
117    const std::u16string DUMP_HELP = u"-x";
118    args.emplace_back(DUMP_HELP);
119    DMError ret = displayDumper->Dump(fd, args);
120    ASSERT_TRUE(ret == DMError::DM_OK || ret == DMError::DM_ERROR_UNKNOWN);
121}
122
123/**
124 * @tc.name: Dump05
125 * @tc.desc: Dump two param with '-s -a'
126 * @tc.type: FUNC
127 */
128HWTEST_F(DisplayDumperTest, Dump05, Function | SmallTest | Level1)
129{
130    sptr<DisplayDumper> displayDumper;
131    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
132        DisplayManagerService::GetInstance().abstractScreenController_,
133        DisplayManagerService::GetInstance().mutex_);
134    int fd = 5;
135    std::vector<std::u16string> args;
136    const std::u16string DUMP_SCREEN = u"-s";
137    const std::u16string DUMP_ALL = u"-a";
138    args.emplace_back(DUMP_SCREEN);
139    args.emplace_back(DUMP_ALL);
140    DMError ret = displayDumper->Dump(fd, args);
141    ASSERT_TRUE(ret == DMError::DM_OK || ret == DMError::DM_ERROR_UNKNOWN);
142}
143
144/**
145 * @tc.name: Dump06
146 * @tc.desc: Dump two param with '-d -a'
147 * @tc.type: FUNC
148 */
149HWTEST_F(DisplayDumperTest, Dump06, Function | SmallTest | Level1)
150{
151    sptr<DisplayDumper> displayDumper;
152    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
153        DisplayManagerService::GetInstance().abstractScreenController_,
154        DisplayManagerService::GetInstance().mutex_);
155    int fd = 6;
156    std::vector<std::u16string> args;
157    const std::u16string DUMP_DISPLAY = u"-d";
158    const std::u16string DUMP_ALL = u"-a";
159    args.emplace_back(DUMP_DISPLAY);
160    args.emplace_back(DUMP_ALL);
161    DMError ret = displayDumper->Dump(fd, args);
162    ASSERT_TRUE(ret == DMError::DM_OK || ret == DMError::DM_ERROR_UNKNOWN);
163}
164
165/**
166 * @tc.name: Dump07
167 * @tc.desc: Dump two param with '-s 1'
168 * @tc.type: FUNC
169 */
170HWTEST_F(DisplayDumperTest, Dump071, Function | SmallTest | Level1)
171{
172    sptr<DisplayDumper> displayDumper;
173    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
174        DisplayManagerService::GetInstance().abstractScreenController_,
175        DisplayManagerService::GetInstance().mutex_);
176    int fd = 71;
177    std::vector<std::u16string> args;
178    const std::u16string DUMP_SCREEN = u"-s";
179    const std::u16string DUMP_NUMBER = u"0";
180    args.emplace_back(DUMP_SCREEN);
181    args.emplace_back(DUMP_NUMBER);
182    DMError ret = displayDumper->Dump(fd, args);
183    ASSERT_TRUE(ret == DMError::DM_OK || ret == DMError::DM_ERROR_UNKNOWN);
184}
185
186/**
187 * @tc.name: Dump07
188 * @tc.desc: Dump two param with '-s -1'
189 * @tc.type: FUNC
190 */
191HWTEST_F(DisplayDumperTest, Dump07, Function | SmallTest | Level1)
192{
193    sptr<DisplayDumper> displayDumper;
194    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
195        DisplayManagerService::GetInstance().abstractScreenController_,
196        DisplayManagerService::GetInstance().mutex_);
197    int fd = 7;
198    std::vector<std::u16string> args;
199    const std::u16string DUMP_SCREEN = u"-s";
200    const std::u16string DUMP_NUMBER = u"-1";
201    args.emplace_back(DUMP_SCREEN);
202    args.emplace_back(DUMP_NUMBER);
203    DMError ret = displayDumper->Dump(fd, args);
204    ASSERT_TRUE(ret == DMError::DM_OK || ret == DMError::DM_ERROR_UNKNOWN);
205}
206
207/**
208 * @tc.name: Dump08
209 * @tc.desc: Dump two param with '-d 1'
210 * @tc.type: FUNC
211 */
212HWTEST_F(DisplayDumperTest, Dump08, Function | SmallTest | Level1)
213{
214    sptr<DisplayDumper> displayDumper;
215    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
216        DisplayManagerService::GetInstance().abstractScreenController_,
217        DisplayManagerService::GetInstance().mutex_);
218    int fd = 8;
219    std::vector<std::u16string> args;
220    const std::u16string DUMP_DISPLAY = u"-d";
221    const std::u16string DUMP_NUMBER = u"1";
222    args.emplace_back(DUMP_DISPLAY);
223    args.emplace_back(DUMP_NUMBER);
224    DMError ret = displayDumper->Dump(fd, args);
225    ASSERT_TRUE(ret == DMError::DM_OK || ret == DMError::DM_ERROR_UNKNOWN);
226}
227
228/**
229 * @tc.name: Dump09
230 * @tc.desc: Dump two param with '-d -1'
231 * @tc.type: FUNC
232 */
233HWTEST_F(DisplayDumperTest, Dump09, Function | SmallTest | Level1)
234{
235    sptr<DisplayDumper> displayDumper;
236    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
237        DisplayManagerService::GetInstance().abstractScreenController_,
238        DisplayManagerService::GetInstance().mutex_);
239    int fd = 9;
240    std::vector<std::u16string> args;
241    const std::u16string DUMP_DISPLAY = u"-d";
242    const std::u16string DUMP_NUMBER = u"-1";
243    args.emplace_back(DUMP_DISPLAY);
244    args.emplace_back(DUMP_NUMBER);
245    DMError ret = displayDumper->Dump(fd, args);
246    ASSERT_TRUE(ret == DMError::DM_OK || ret == DMError::DM_ERROR_UNKNOWN);
247}
248
249/**
250 * @tc.name: Dump10
251 * @tc.desc: Dump three param with '-d -a 1'
252 * @tc.type: FUNC
253 */
254HWTEST_F(DisplayDumperTest, Dump10, Function | SmallTest | Level1)
255{
256    sptr<DisplayDumper> displayDumper;
257    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
258        DisplayManagerService::GetInstance().abstractScreenController_,
259        DisplayManagerService::GetInstance().mutex_);
260    int fd = 10;
261    std::vector<std::u16string> args;
262    const std::u16string DUMP_DISPLAY = u"-d";
263    const std::u16string DUMP_ALL = u"-a";
264    const std::u16string DUMP_NUMBER = u"1";
265    args.emplace_back(DUMP_DISPLAY);
266    args.emplace_back(DUMP_ALL);
267    args.emplace_back(DUMP_NUMBER);
268    DMError ret = displayDumper->Dump(fd, args);
269    ASSERT_TRUE(ret == DMError::DM_OK || ret == DMError::DM_ERROR_UNKNOWN);
270}
271
272/**
273 * @tc.name: IsValidDigitString01
274 * @tc.desc: IsValidDigitString "06w"
275 * @tc.type: FUNC
276 */
277HWTEST_F(DisplayDumperTest, IsValidDigitString01, Function | SmallTest | Level1)
278{
279    sptr<DisplayDumper> displayDumper;
280    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
281        DisplayManagerService::GetInstance().abstractScreenController_,
282        DisplayManagerService::GetInstance().mutex_);
283    std::string idStr = "06w";
284    bool ret = displayDumper->IsValidDigitString(idStr);
285    ASSERT_EQ(ret, false);
286}
287
288/**
289 * @tc.name: IsValidDigitString02
290 * @tc.desc: IsValidDigitString "96+"
291 * @tc.type: FUNC
292 */
293HWTEST_F(DisplayDumperTest, IsValidDigitString02, Function | SmallTest | Level1)
294{
295    sptr<DisplayDumper> displayDumper;
296    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
297        DisplayManagerService::GetInstance().abstractScreenController_,
298        DisplayManagerService::GetInstance().mutex_);
299    std::string idStr = "96+";
300    bool ret = displayDumper->IsValidDigitString(idStr);
301    ASSERT_EQ(ret, false);
302}
303
304/**
305 * @tc.name: IsValidDigitString03
306 * @tc.desc: IsValidDigitString empty
307 * @tc.type: FUNC
308 */
309HWTEST_F(DisplayDumperTest, IsValidDigitString03, Function | SmallTest | Level1)
310{
311    sptr<DisplayDumper> displayDumper;
312    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
313        DisplayManagerService::GetInstance().abstractScreenController_,
314        DisplayManagerService::GetInstance().mutex_);
315    std::string idStr;
316    bool ret = displayDumper->IsValidDigitString(idStr);
317    ASSERT_EQ(ret, false);
318}
319
320/**
321 * @tc.name: DumpAllScreenInfo01
322 * @tc.desc: DumpAllScreenInfo
323 * @tc.type: FUNC
324 */
325HWTEST_F(DisplayDumperTest, DumpAllScreenInfo01, Function | SmallTest | Level1)
326{
327    sptr<DisplayDumper> displayDumper;
328    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
329        DisplayManagerService::GetInstance().abstractScreenController_,
330        DisplayManagerService::GetInstance().mutex_);
331    std::string dumpInfo;
332    displayDumper->DumpAllScreenInfo(dumpInfo);
333    ASSERT_NE(dumpInfo.size(), 0);
334}
335
336/**
337 * @tc.name: DumpScreenInfo01
338 * @tc.desc: DumpScreenInfo
339 * @tc.type: FUNC
340 */
341HWTEST_F(DisplayDumperTest, DumpScreenInfo01, Function | SmallTest | Level1)
342{
343    sptr<DisplayDumper> displayDumper;
344    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
345        DisplayManagerService::GetInstance().abstractScreenController_,
346        DisplayManagerService::GetInstance().mutex_);
347    sptr<AbstractScreenGroup> screenGroup = nullptr;
348    std::string dumpInfo;
349    DMError result = displayDumper->DumpScreenInfo(screenGroup, dumpInfo);
350    EXPECT_EQ(result, DMError::DM_ERROR_NULLPTR);
351}
352
353/**
354 * @tc.name: DumpScreenInfo02
355 * @tc.desc: DumpScreenInfo
356 * @tc.type: FUNC
357 */
358HWTEST_F(DisplayDumperTest, DumpScreenInfo02, Function | SmallTest | Level1)
359{
360    sptr<DisplayDumper> displayDumper;
361    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
362        DisplayManagerService::GetInstance().abstractScreenController_,
363        DisplayManagerService::GetInstance().mutex_);
364    std::string name = "testDisplay";
365    sptr<SupportedScreenModes> info = new SupportedScreenModes();
366    info->width_ = 100;
367    info->height_ = 200;
368    sptr<AbstractScreen> absScreen = new AbstractScreen(DisplayManagerService::GetInstance().abstractScreenController_,
369        name, 0, 0);
370    absScreen->activeIdx_ = 0;
371    absScreen->modes_.clear();
372    absScreen->modes_ = { { info } };
373    absScreen->groupDmsId_ = SCREEN_ID_INVALID;
374    sptr<AbstractScreenGroup> screenGroup = new AbstractScreenGroup(
375        DisplayManagerService::GetInstance().abstractScreenController_, 0, 0, name, ScreenCombination::SCREEN_ALONE);
376    std::string dumpInfo;
377    DMError result = displayDumper->DumpScreenInfo(screenGroup, dumpInfo);
378    EXPECT_EQ(result, DMError::DM_OK);
379}
380
381/**
382 * @tc.name: TransferTypeToString
383 * @tc.desc: TransferTypeToString
384 * @tc.type: FUNC
385 */
386HWTEST_F(DisplayDumperTest, TransferTypeToString, Function | SmallTest | Level1)
387{
388    sptr<DisplayDumper> displayDumper;
389    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
390        DisplayManagerService::GetInstance().abstractScreenController_,
391        DisplayManagerService::GetInstance().mutex_);
392    ScreenType type = ScreenType::REAL;
393    EXPECT_STREQ(displayDumper->TransferTypeToString(type).c_str(), "REAL");
394
395    type = ScreenType::VIRTUAL;
396    EXPECT_STREQ(displayDumper->TransferTypeToString(type).c_str(), "VIRTUAL");
397
398    type = ScreenType::UNDEFINED;
399    EXPECT_STREQ(displayDumper->TransferTypeToString(type).c_str(), "UNDEFINED");
400}
401
402/**
403 * @tc.name: GetScreenInfo01
404 * @tc.desc: GetScreenInfo
405 * @tc.type: FUNC
406 */
407HWTEST_F(DisplayDumperTest, GetScreenInfo01, Function | SmallTest | Level1)
408{
409    sptr<DisplayDumper> displayDumper;
410    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
411        DisplayManagerService::GetInstance().abstractScreenController_,
412        DisplayManagerService::GetInstance().mutex_);
413    std::ostringstream oss;
414    displayDumper->GetScreenInfo(nullptr, oss);
415    std::string result = oss.str();
416    ASSERT_EQ(result.size(), 0);
417}
418
419/**
420 * @tc.name: GetScreenInfo02
421 * @tc.desc: GetScreenInfo
422 * @tc.type: FUNC
423 */
424HWTEST_F(DisplayDumperTest, GetScreenInfo02, Function | SmallTest | Level1)
425{
426    sptr<DisplayDumper> displayDumper;
427    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
428        DisplayManagerService::GetInstance().abstractScreenController_,
429        DisplayManagerService::GetInstance().mutex_);
430    std::ostringstream oss;
431    std::string name = "testDisplay";
432    sptr<SupportedScreenModes> info = new SupportedScreenModes();
433    info->width_ = 100;
434    info->height_ = 200;
435    sptr<AbstractScreen> absScreen = new AbstractScreen(DisplayManagerService::GetInstance().abstractScreenController_,
436        name, 0, 0);
437    absScreen->activeIdx_ = 0;
438    absScreen->modes_.clear();
439    absScreen->modes_ = { { info } };
440    displayDumper->GetScreenInfo(absScreen, oss);
441    std::string result = oss.str();
442    ASSERT_EQ(result.size(), 165);
443}
444
445/**
446 * @tc.name: GetDisplayInfo01
447 * @tc.desc: GetDisplayInfo
448 * @tc.type: FUNC
449 */
450HWTEST_F(DisplayDumperTest, GetDisplayInfo01, Function | SmallTest | Level1)
451{
452    sptr<DisplayDumper> displayDumper;
453    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
454        DisplayManagerService::GetInstance().abstractScreenController_,
455        DisplayManagerService::GetInstance().mutex_);
456    std::ostringstream oss;
457    displayDumper->GetDisplayInfo(nullptr, oss);
458    std::string result = oss.str();
459    ASSERT_EQ(result.size(), 0);
460}
461
462/**
463 * @tc.name: GetDisplayInfo02
464 * @tc.desc: GetDisplayInfo
465 * @tc.type: FUNC
466 */
467HWTEST_F(DisplayDumperTest, GetDisplayInfo02, Function | SmallTest | Level1)
468{
469    sptr<DisplayDumper> displayDumper;
470    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
471        DisplayManagerService::GetInstance().abstractScreenController_,
472        DisplayManagerService::GetInstance().mutex_);
473    std::ostringstream oss;
474
475    std::string name = "testDisplay";
476    sptr<SupportedScreenModes> info = new SupportedScreenModes();
477    info->width_ = 100;
478    info->height_ = 200;
479    sptr<AbstractScreen> absScreen = new AbstractScreen(DisplayManagerService::GetInstance().abstractScreenController_,
480        name, 0, 0);
481    absScreen->activeIdx_ = 0;
482    absScreen->modes_.clear();
483    absScreen->modes_ = { { info } };
484    sptr<AbstractDisplay> absDisplay = new AbstractDisplay(0, info, absScreen);
485    displayDumper->GetDisplayInfo(absDisplay, oss);
486    std::string result = oss.str();
487
488    EXPECT_EQ(result.size(), 109);
489}
490
491/**
492 * @tc.name: ShowIllegalArgsInfo
493 * @tc.desc: ShowIllegalArgsInfo
494 * @tc.type: FUNC
495 */
496HWTEST_F(DisplayDumperTest, ShowIllegalArgsInfo, Function | SmallTest | Level1)
497{
498    sptr<DisplayDumper> displayDumper;
499    displayDumper = new DisplayDumper(DisplayManagerService::GetInstance().abstractDisplayController_,
500        DisplayManagerService::GetInstance().abstractScreenController_,
501        DisplayManagerService::GetInstance().mutex_);
502
503    std::string dumpInfo = "DTtest";
504    DMError errCode = DMError::DM_OK;
505    displayDumper->ShowIllegalArgsInfo(dumpInfo, errCode);
506
507    EXPECT_NE(displayDumper, nullptr);
508}
509}
510}
511}