1 /*
2 * Copyright (c) 2022-2023 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
18 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22 #include "net_stats_database_defines.h"
23 #include "net_manager_constants.h"
24 #include "net_stats_cached.h"
25 #include "net_stats_history.h"
26 #include "net_stats_constants.h"
27 #include "net_stats_database_helper.h"
28 namespace OHOS {
29 namespace NetManagerStandard {
30 namespace {
31 using namespace testing::ext;
32 constexpr int32_t TEST_UID = 1;
33 #define DTEST_LOG std::cout << __func__ << ":" << __LINE__ << ":"
34 } // namespace
35
36 class NetStatsCachedTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp();
41 void TearDown();
42 static inline auto instance_ = std::make_shared<NetStatsCached>();
43 };
44
SetUpTestCase()45 void NetStatsCachedTest::SetUpTestCase() {}
46
TearDownTestCase()47 void NetStatsCachedTest::TearDownTestCase() {}
48
SetUp()49 void NetStatsCachedTest::SetUp() {}
50
TearDown()51 void NetStatsCachedTest::TearDown() {}
52
53 HWTEST_F(NetStatsCachedTest, CacheUidStatsTest001, TestSize.Level1)
54 {
55 auto ret = instance_->CheckUidStor();
56 EXPECT_FALSE(ret);
57 ret = instance_->CheckIfaceStor();
58 EXPECT_FALSE(ret);
59 instance_->CacheUidStats();
60 instance_->CacheIfaceStats();
61 NetStatsInfo info;
62 instance_->stats_.PushUidStats(info);
63 instance_->stats_.PushIfaceStats(info);
64 if (instance_->stats_.GetUidStatsInfo().empty()) {
65 EXPECT_EQ(instance_->stats_.GetCurrentUidStats(), static_cast<uint64_t>(0));
66 } else {
67 EXPECT_GT(instance_->stats_.GetCurrentUidStats(), static_cast<uint64_t>(0));
68 }
69 if (instance_->stats_.GetIfaceStatsInfo().empty()) {
70 EXPECT_EQ(instance_->stats_.GetCurrentIfaceStats(), static_cast<uint64_t>(0));
71 } else {
72 EXPECT_GT(instance_->stats_.GetCurrentIfaceStats(), static_cast<uint64_t>(0));
73 }
74
75 instance_->stats_.ResetUidStats();
76 instance_->stats_.ResetIfaceStats();
77 EXPECT_TRUE(instance_->stats_.GetUidStatsInfo().empty());
78 EXPECT_TRUE(instance_->stats_.GetIfaceStatsInfo().empty());
79 EXPECT_EQ(instance_->stats_.GetCurrentUidStats(), static_cast<uint64_t>(0));
80 EXPECT_EQ(instance_->stats_.GetCurrentIfaceStats(), static_cast<uint64_t>(0));
81 instance_->CacheStats();
82 }
83
84 HWTEST_F(NetStatsCachedTest, StartCachedTest001, TestSize.Level1)
85 {
86 instance_->StartCached();
87 std::vector<NetStatsInfo> allInfo;
88 int32_t uid = 4800;
89 int32_t start = 1;
90 int32_t end = 10;
91 auto history = std::make_unique<NetStatsHistory>();
92 int32_t ret = history->GetHistory(allInfo, uid, start, end);
93 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
94 instance_->GetUidStatsCached(allInfo);
95 instance_->GetIfaceStatsCached(allInfo);
96 instance_->CacheIfaceStats();
97 instance_->WriteStats();
98 uint32_t threshold = 1000;
99 instance_->SetCycleThreshold(threshold);
100 instance_->ForceUpdateStats();
101 instance_->Reset();
102 }
103
104 HWTEST_F(NetStatsCachedTest, WriteIfaceStatsTest001, TestSize.Level1)
105 {
106 instance_->isForce_ = true;
107 instance_->stats_.currentIfaceStats_ = 0;
108 instance_->WriteIfaceStats();
109 instance_->stats_.currentIfaceStats_ = NetStatsCached::DEFAULT_TRAFFIC_STATISTICS_THRESHOLD_BYTES + 1;
110 instance_->WriteIfaceStats();
111 instance_->isForce_ = false;
112 instance_->stats_.currentIfaceStats_ = 0;
113 instance_->WriteIfaceStats();
114 instance_->stats_.currentIfaceStats_ = NetStatsCached::DEFAULT_TRAFFIC_STATISTICS_THRESHOLD_BYTES + 1;
115 instance_->WriteIfaceStats();
116 EXPECT_FALSE(instance_->CheckIfaceStor());
117 }
118
119 HWTEST_F(NetStatsCachedTest, WriteUidStatsTest001, TestSize.Level1)
120 {
121 instance_->isForce_ = true;
122 instance_->stats_.currentUidStats_ = 0;
123 instance_->WriteUidStats();
124 instance_->stats_.currentUidStats_ = NetStatsCached::DEFAULT_TRAFFIC_STATISTICS_THRESHOLD_BYTES + 1;
125 instance_->WriteUidStats();
126 instance_->isForce_ = false;
127 instance_->stats_.currentUidStats_ = 0;
128 instance_->WriteUidStats();
129 instance_->stats_.currentUidStats_ = NetStatsCached::DEFAULT_TRAFFIC_STATISTICS_THRESHOLD_BYTES + 1;
130 instance_->WriteUidStats();
131 EXPECT_FALSE(instance_->CheckUidStor());
132 }
133
134 HWTEST_F(NetStatsCachedTest, WriteUidSimStatsTest001, TestSize.Level1)
135 {
136 instance_->isForce_ = true;
137 instance_->stats_.currentUidSimStats_ = 0;
138 instance_->WriteUidSimStats();
139 instance_->stats_.currentUidSimStats_ = NetStatsCached::DEFAULT_TRAFFIC_STATISTICS_THRESHOLD_BYTES + 1;
140 instance_->WriteUidSimStats();
141 instance_->isForce_ = false;
142 instance_->stats_.currentUidSimStats_ = 0;
143 instance_->WriteUidSimStats();
144 instance_->stats_.currentUidSimStats_ = NetStatsCached::DEFAULT_TRAFFIC_STATISTICS_THRESHOLD_BYTES + 1;
145 instance_->WriteUidSimStats();
146 EXPECT_FALSE(instance_->CheckUidStor());
147 }
148
149 HWTEST_F(NetStatsCachedTest, SetAppStatsTest001, TestSize.Level1)
150 {
151 PushStatsInfo info;
152 info.uid_ = 1001;
153 instance_->SetAppStats(info);
154 }
155
156 HWTEST_F(NetStatsCachedTest, ForceDeleteStatsTest001, TestSize.Level1)
157 {
158 instance_->ForceDeleteStats(TEST_UID);
159 }
160 } // namespace NetManagerStandard
161 } // namespace OHOS
162