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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "system_load.h"
20 #include "dfs_error.h"
21 #include "parameters.h"
22 #include "utils_log.h"
23 #include "res_sched_client.h"
24
25 namespace OHOS::FileManagement::CloudSync::Test {
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace std;
29
30 class SytemLoadTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36 shared_ptr<SystemLoadStatus> SystemLoadStatus_ = nullptr;
37 shared_ptr<SystemLoadListener> SystemLoadListener_ = nullptr;
38 };
39
SetUpTestCase(void)40 void SytemLoadTest::SetUpTestCase(void)
41 {
42 GTEST_LOG_(INFO) << "SetUpTestCase";
43 }
44
TearDownTestCase(void)45 void SytemLoadTest::TearDownTestCase(void)
46 {
47 GTEST_LOG_(INFO) << "TearDownTestCase";
48 }
49
SetUp(void)50 void SytemLoadTest::SetUp(void)
51 {
52 GTEST_LOG_(INFO) << "SetUp";
53 SystemLoadStatus_ = make_shared<SystemLoadStatus>();
54 SystemLoadListener_ = make_shared<SystemLoadListener>();
55 }
56
TearDown(void)57 void SytemLoadTest::TearDown(void)
58 {
59 GTEST_LOG_(INFO) << "TearDown";
60 SystemLoadStatus_ = nullptr;
61 SystemLoadListener_ = nullptr;
62 }
63
64 /**
65 * @tc.name: RegisterSystemloadCallbackTest
66 * @tc.desc: Verify the RegisterSystemloadCallback function
67 * @tc.type: FUNC
68 * @tc.require: I6JPKG
69 */
70 HWTEST_F(SytemLoadTest, RegisterSystemloadCallbackTest, TestSize.Level1)
71 {
72 GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest Start";
73 try {
74 std::shared_ptr<CloudFile::DataSyncManager> dataSyncManager;
75 SystemLoadStatus_->RegisterSystemloadCallback(dataSyncManager);
76 } catch (...) {
77 EXPECT_TRUE(false);
78 GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest FAILED";
79 }
80 GTEST_LOG_(INFO) << "RegisterSystemloadCallbackTest End";
81 }
82
83 /**
84 * @tc.name: OnSystemloadLevelTest001
85 * @tc.desc: Verify the OnSystemloadLevel function
86 * @tc.type: FUNC
87 * @tc.require: I6JPKG
88 */
89 HWTEST_F(SytemLoadTest, OnSystemloadLevelTest001, TestSize.Level1)
90 {
91 GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 Start";
92 try {
93 int32_t level = 10;
94 SystemLoadListener_->OnSystemloadLevel(level);
95 } catch (...) {
96 EXPECT_TRUE(false);
97 GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 FAILED";
98 }
99 GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 End";
100 }
101
102 /**
103 * @tc.name: OnSystemloadLevelTest002
104 * @tc.desc: Verify the OnSystemloadLevel function
105 * @tc.type: FUNC
106 * @tc.require: I6JPKG
107 */
108 HWTEST_F(SytemLoadTest, OnSystemloadLevelTest002, TestSize.Level1)
109 {
110 GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 Start";
111 try {
112 int32_t level = 1;
113 std::shared_ptr<CloudFile::DataSyncManager> dataSyncManager;
114 SystemLoadListener_->dataSyncManager_ = make_shared<CloudFile::DataSyncManager>();
115 SystemLoadListener_->OnSystemloadLevel(level);
116 } catch (...) {
117 EXPECT_TRUE(false);
118 GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 FAILED";
119 }
120 GTEST_LOG_(INFO) << "OnSystemloadLevelTest001 End";
121 }
122
123 /**
124 * @tc.name: OnSystemloadLevelTest003
125 * @tc.desc: Verify the OnSystemloadLevel function
126 * @tc.type: FUNC
127 * @tc.require: I6JPKG
128 */
129 HWTEST_F(SytemLoadTest, OnSystemloadLevelTest003, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "OnSystemloadLevelTest003 Start";
132 try {
133 int32_t level = 1;
134 system::SetParameter(TEMPERATURE_SYSPARAM_SYNC, "true");
135 auto dataSyncManager = std::make_shared<CloudFile::DataSyncManager>();
136 SystemLoadListener_->SetDataSycner(dataSyncManager);
137 SystemLoadListener_->OnSystemloadLevel(level);
138 } catch (...) {
139 EXPECT_TRUE(false);
140 GTEST_LOG_(INFO) << "OnSystemloadLevelTest003 FAILED";
141 }
142 GTEST_LOG_(INFO) << "OnSystemloadLevelTest003 End";
143 }
144
145 /**
146 * @tc.name: OnSystemloadLevelTest004
147 * @tc.desc: Verify the OnSystemloadLevel function
148 * @tc.type: FUNC
149 * @tc.require: I6JPKG
150 */
151 HWTEST_F(SytemLoadTest, OnSystemloadLevelTest004, TestSize.Level1)
152 {
153 GTEST_LOG_(INFO) << "OnSystemloadLevelTest004 Start";
154 try {
155 int32_t level = 1;
156 system::SetParameter(TEMPERATURE_SYSPARAM_THUMB, "true");
157 auto dataSyncManager = std::make_shared<CloudFile::DataSyncManager>();
158 SystemLoadListener_->SetDataSycner(dataSyncManager);
159 SystemLoadListener_->OnSystemloadLevel(level);
160 } catch (...) {
161 EXPECT_TRUE(false);
162 GTEST_LOG_(INFO) << "OnSystemloadLevelTest004 FAILED";
163 }
164 GTEST_LOG_(INFO) << "OnSystemloadLevelTest004 End";
165 }
166
167 /**
168 * @tc.name: IsLoadStatusUnderHotTest001
169 * @tc.desc: Verify the IsLoadStatusUnderHot function
170 * @tc.type: FUNC
171 * @tc.require: I6JPKG
172 */
173 HWTEST_F(SytemLoadTest, IsLoadStatusUnderHotTest001, TestSize.Level1)
174 {
175 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 Start";
176 try {
177 SystemLoadStatus_->Setload(10);
178 bool ret = SystemLoadStatus_->IsLoadStatusUnderHot();
179 EXPECT_EQ(ret, false);
180 } catch (...) {
181 EXPECT_TRUE(false);
182 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 FAILED";
183 }
184 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 End";
185 }
186
187 /**
188 * @tc.name: IsLoadStatusUnderHotTest002
189 * @tc.desc: Verify the IsLoadStatusUnderHot function
190 * @tc.type: FUNC
191 * @tc.require: I6JPKG
192 */
193 HWTEST_F(SytemLoadTest, IsLoadStatusUnderHotTest002, TestSize.Level1)
194 {
195 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 Start";
196 try {
197 SystemLoadStatus_->Setload(10);
198 bool ret = SystemLoadStatus_->IsLoadStatusUnderHot();
199 EXPECT_EQ(ret, false);
200 } catch (...) {
201 EXPECT_TRUE(false);
202 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 FAILED";
203 }
204 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 End";
205 }
206
207 /**
208 * @tc.name: IsLoadStatusUnderHotTest003
209 * @tc.desc: Verify the IsLoadStatusUnderHot function
210 * @tc.type: FUNC
211 * @tc.require: I6JPKG
212 */
213 HWTEST_F(SytemLoadTest, IsLoadStatusUnderHotTest003, TestSize.Level1)
214 {
215 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 Start";
216 try {
217 SystemLoadStatus_->Setload(1);
218 bool ret = SystemLoadStatus_->IsLoadStatusUnderHot();
219 EXPECT_EQ(ret, true);
220 } catch (...) {
221 EXPECT_TRUE(false);
222 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 FAILED";
223 }
224 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest001 End";
225 }
226
227 /**
228 * @tc.name: IsLoadStatusUnderHotTest004
229 * @tc.desc: Verify the IsLoadStatusUnderHot function
230 * @tc.type: FUNC
231 * @tc.require: I6JPKG
232 */
233 HWTEST_F(SytemLoadTest, IsLoadStatusUnderHotTest004, TestSize.Level1)
234 {
235 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest004 Start";
236 SystemLoadStatus_->Setload(10);
237 STOPPED_TYPE process = STOPPED_IN_THUMB;
238 bool ret = SystemLoadStatus_->IsLoadStatusUnderHot(process);
239 EXPECT_EQ(ret, false);
240 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest004 End";
241 }
242
243 /**
244 * @tc.name: IsLoadStatusUnderHotTest005
245 * @tc.desc: Verify the IsLoadStatusUnderHot function
246 * @tc.type: FUNC
247 * @tc.require: I6JPKG
248 */
249 HWTEST_F(SytemLoadTest, IsLoadStatusUnderHotTest005, TestSize.Level1)
250 {
251 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest005 Start";
252 SystemLoadStatus_->Setload(10);
253 STOPPED_TYPE process = STOPPED_IN_SYNC;
254 bool ret = SystemLoadStatus_->IsLoadStatusUnderHot(process);
255 EXPECT_EQ(ret, false);
256 GTEST_LOG_(INFO) << "IsLoadStatusUnderHotTest005 End";
257 }
258
259 HWTEST_F(SytemLoadTest, IsLoadStatusUnderNormalTest001, TestSize.Level1)
260 {
261 SystemLoadStatus_->Setload(SYSTEMLOADLEVEL_NORMAL);
262 bool ret = SystemLoadStatus_->IsLoadStatusUnderNormal(STOPPED_TYPE::STOPPED_IN_SYNC);
263 EXPECT_TRUE(ret);
264 }
265
266 HWTEST_F(SytemLoadTest, IsLoadStatusUnderNormalTest002, TestSize.Level1)
267 {
268 SystemLoadStatus_->Setload(SYSTEMLOADLEVEL_NORMAL + 1);
269 bool ret = SystemLoadStatus_->IsLoadStatusUnderNormal(STOPPED_TYPE::STOPPED_IN_SYNC);
270 EXPECT_FALSE(ret);
271 }
272
273 } // namespace OHOS::FileManagement::CloudSync::Test