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 
21 using namespace testing;
22 using namespace testing::ext;
23 
24 namespace OHOS {
25 namespace Rosen {
26 class DisplayDumperTest : public testing::Test {
27 public:
28     static void SetUpTestCase();
29     static void TearDownTestCase();
30     void SetUp() override;
31     void TearDown() override;
32 };
33 
SetUpTestCase()34 void DisplayDumperTest::SetUpTestCase()
35 {
36 }
37 
TearDownTestCase()38 void DisplayDumperTest::TearDownTestCase()
39 {
40 }
41 
SetUp()42 void DisplayDumperTest::SetUp()
43 {
44 }
45 
TearDown()46 void DisplayDumperTest::TearDown()
47 {
48 }
49 
50 namespace {
51 /**
52  * @tc.name: Dump01
53  * @tc.desc: Dump
54  * @tc.type: FUNC
55  */
56 HWTEST_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  */
73 HWTEST_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  */
90 HWTEST_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  */
109 HWTEST_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  */
128 HWTEST_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  */
149 HWTEST_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  */
170 HWTEST_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  */
191 HWTEST_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  */
212 HWTEST_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  */
233 HWTEST_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  */
254 HWTEST_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  */
277 HWTEST_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  */
293 HWTEST_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  */
309 HWTEST_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  */
325 HWTEST_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  */
341 HWTEST_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  */
358 HWTEST_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  */
386 HWTEST_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  */
407 HWTEST_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  */
424 HWTEST_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  */
450 HWTEST_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  */
467 HWTEST_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  */
496 HWTEST_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 }