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 "UTTest_dm_dfx.h"
17
18 namespace OHOS {
19 namespace DistributedHardware {
SetUp()20 void DmDfxTest::SetUp()
21 {
22 }
TearDown()23 void DmDfxTest::TearDown()
24 {
25 }
SetUpTestCase()26 void DmDfxTest::SetUpTestCase()
27 {
28 }
TearDownTestCase()29 void DmDfxTest::TearDownTestCase()
30 {
31 }
32
33 namespace {
34
35 /**
36 * @tc.name: ShowHelp_001
37 * @tc.desc: Return DM_OK
38 * @tc.type: FUNC
39 * @tc.require: AR000GHSJK
40 */
41 HWTEST_F(DmDfxTest, ShowHelp_001, testing::ext::TestSize.Level0)
42 {
43 std::string result = "";
44 int32_t ret = HiDumpHelper::GetInstance().ShowHelp(result);
45 EXPECT_EQ(ret, DM_OK);
46 }
47
48 /**
49 * @tc.name: ShowIllealInfomation_001
50 * @tc.desc: Return DM_OK
51 * @tc.type: FUNC
52 * @tc.require: AR000GHSJK
53 */
54 HWTEST_F(DmDfxTest, ShowIllealInfomation_001, testing::ext::TestSize.Level0)
55 {
56 std::string result = "";
57 int32_t ret = HiDumpHelper::GetInstance().ShowIllealInfomation(result);
58 EXPECT_EQ(ret, DM_OK);
59 }
60
61 /**
62 * @tc.name: GetArgsType_001
63 * @tc.desc: Return ERR_DM_FAILED
64 * @tc.type: FUNC
65 * @tc.require: AR000GHSJK
66 */
67 HWTEST_F(DmDfxTest, GetArgsType_001, testing::ext::TestSize.Level0)
68 {
69 std::vector<std::string> args;
70 std::vector<HidumperFlag> Flag;
71 int32_t ret = HiDumpHelper::GetInstance().GetArgsType(args, Flag);
72 EXPECT_EQ(ret, ERR_DM_FAILED);
73 }
74
75 /**
76 * @tc.name: GetArgsType_002
77 * @tc.desc: Return ERR_DM_FAILED
78 * @tc.type: FUNC
79 * @tc.require: AR000GHSJK
80 */
81 HWTEST_F(DmDfxTest, GetArgsType_002, testing::ext::TestSize.Level0)
82 {
83 std::string str = std::string(ARGS_HELP_INFO);
84 std::vector<std::string> args;
85 args.push_back(str);
86 std::vector<HidumperFlag> Flag;
87 int32_t ret = HiDumpHelper::GetInstance().GetArgsType(args, Flag);
88 EXPECT_EQ(ret, ERR_DM_FAILED);
89 }
90
91 /**
92 * @tc.name: SetNodeInfo_001
93 * @tc.desc: HiDumpHelper::GetInstance().nodeInfo_.size() plus 1
94 * @tc.type: FUNC
95 * @tc.require: AR000GHSJK
96 */
97 HWTEST_F(DmDfxTest, SetNodeInfo_001, testing::ext::TestSize.Level0)
98 {
99 DmDeviceInfo deviceInfo;
100 HiDumpHelper::GetInstance().SetNodeInfo(deviceInfo);
101 EXPECT_EQ(HiDumpHelper::GetInstance().nodeInfos_.size(), 1);
102 }
103
104 /**
105 * @tc.name: ShowAllLoadTrustedList_001
106 * @tc.desc: Return DM_OK
107 * @tc.type: FUNC
108 * @tc.require: AR000GHSJK
109 */
110 HWTEST_F(DmDfxTest, ShowAllLoadTrustedList_001, testing::ext::TestSize.Level0)
111 {
112 std::string result = "";
113 int32_t ret = HiDumpHelper::GetInstance().ShowAllLoadTrustedList(result);
114 EXPECT_TRUE(!result.empty());
115 EXPECT_EQ(ret, DM_OK);
116 }
117
118 /**
119 * @tc.name: ShowAllLoadTrustedList_002
120 * @tc.desc: Return DM_OK
121 * @tc.type: FUNC
122 * @tc.require: AR000GHSJK
123 */
124 HWTEST_F(DmDfxTest, ShowAllLoadTrustedList_002, testing::ext::TestSize.Level0)
125 {
126 std::string result = "";
127 DmDeviceInfo deviceInfo;
128 deviceInfo.deviceTypeId = 1;
129 deviceInfo.range = 11;
130 HiDumpHelper::GetInstance().nodeInfos_.push_back(deviceInfo);
131 int32_t ret = HiDumpHelper::GetInstance().ShowAllLoadTrustedList(result);
132 EXPECT_TRUE(!result.empty());
133 EXPECT_EQ(ret, DM_OK);
134 }
135
136 /**
137 * @tc.name: GetDeviceType_001
138 * @tc.desc: set deviceTypeId id 8, Return string is not empty
139 * @tc.type: FUNC
140 * @tc.require: AR000GHSJK
141 */
142 HWTEST_F(DmDfxTest, GetDeviceType_001, testing::ext::TestSize.Level0)
143 {
144 int32_t deviceTypeId = 8;
145 std::string ret = HiDumpHelper::GetInstance().GetDeviceType(deviceTypeId);
146 EXPECT_TRUE(!ret.empty());
147 }
148
149 /**
150 * @tc.name: GetDeviceType_002
151 * @tc.desc: set deviceTypeId id 10000, Return string is not empty
152 * @tc.type: FUNC
153 * @tc.require: AR000GHSJK
154 */
155 HWTEST_F(DmDfxTest, GetDeviceType_002, testing::ext::TestSize.Level0)
156 {
157 int32_t deviceTypeId = 10000;
158 std::string ret = HiDumpHelper::GetInstance().GetDeviceType(deviceTypeId);
159 EXPECT_TRUE(ret.empty());
160 }
161
162 /**
163 * @tc.name: ProcessDump_001
164 * @tc.desc: Return DM_OK
165 * @tc.type: FUNC
166 * @tc.require: AR000GHSJK
167 */
168 HWTEST_F(DmDfxTest, ProcessDump_001, testing::ext::TestSize.Level0)
169 {
170 HidumperFlag flag = HidumperFlag::HIDUMPER_GET_HELP;
171 std::string result;
172 int32_t ret = HiDumpHelper::GetInstance().ProcessDump(flag, result);
173 EXPECT_EQ(ret, DM_OK);
174 }
175
176 /**
177 * @tc.name: ProcessDump_002
178 * @tc.desc: Return DM_OK
179 * @tc.type: FUNC
180 * @tc.require: AR000GHSJK
181 */
182 HWTEST_F(DmDfxTest, ProcessDump_002, testing::ext::TestSize.Level0)
183 {
184 HidumperFlag flag = HidumperFlag::HIDUMPER_GET_TRUSTED_LIST;
185 std::string result;
186 int32_t ret = HiDumpHelper::GetInstance().ProcessDump(flag, result);
187 EXPECT_EQ(ret, DM_OK);
188 }
189
190 /**
191 * @tc.name: ProcessDump_003
192 * @tc.desc: Return DM_OK
193 * @tc.type: FUNC
194 * @tc.require: AR000GHSJK
195 */
196 HWTEST_F(DmDfxTest, ProcessDump_003, testing::ext::TestSize.Level0)
197 {
198 HidumperFlag flag = HidumperFlag::HIDUMPER_UNKNOWN;
199 std::string result;
200 int32_t ret = HiDumpHelper::GetInstance().ProcessDump(flag, result);
201 EXPECT_EQ(ret, DM_OK);
202 }
203
204 /**
205 * @tc.name: HiDump_001
206 * @tc.desc: Return DM_OK
207 * @tc.type: FUNC
208 * @tc.require: AR000GHSJK
209 */
210 HWTEST_F(DmDfxTest, HiDump_001, testing::ext::TestSize.Level0)
211 {
212 std::vector<std::string> args;
213 std::string result;
214 int32_t ret = HiDumpHelper::GetInstance().HiDump(args, result);
215 EXPECT_EQ(ret, DM_OK);
216 }
217
218 /**
219 * @tc.name: HiDump_002
220 * @tc.desc: Return DM_OK
221 * @tc.type: FUNC
222 * @tc.require: AR000GHSJK
223 */
224 HWTEST_F(DmDfxTest, HiDump_002, testing::ext::TestSize.Level0)
225 {
226 std::string str = "argsTest";
227 std::vector<std::string> args;
228 args.push_back(str);
229 std::string result;
230 int32_t ret = HiDumpHelper::GetInstance().HiDump(args, result);
231 EXPECT_EQ(ret, DM_OK);
232 }
233
234 /**
235 * @tc.name: HiDump_003
236 * @tc.desc: Return DM_OK
237 * @tc.type: FUNC
238 * @tc.require: AR000GHSJK
239 */
240 HWTEST_F(DmDfxTest, HiDump_003, testing::ext::TestSize.Level0)
241 {
242 std::string str = std::string(HIDUMPER_GET_TRUSTED_LIST_INFO);
243 std::vector<std::string> args;
244 args.push_back(str);
245 std::string result;
246 int32_t ret = HiDumpHelper::GetInstance().HiDump(args, result);
247 EXPECT_EQ(ret, DM_OK);
248 }
249 } // namespace
250 } // namespace DistributedHardware
251 } // namespace OHOS