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
18 #include "net_activate.h"
19 #include "net_conn_callback_stub.h"
20 #include "net_manager_constants.h"
21
22 namespace OHOS {
23 namespace NetManagerStandard {
24 namespace {
25 using namespace testing::ext;
26 constexpr uint32_t INVALID_NET_CAP = 1000;
27 } // namespace
28
29 class NetCapsTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp();
34 void TearDown();
35
36 static inline std::unique_ptr<NetCaps> instance_ = nullptr;
37 };
38
SetUpTestCase()39 void NetCapsTest::SetUpTestCase()
40 {
41 std::set<NetCap> caps = {NetCap::NET_CAPABILITY_MMS,
42 NetCap::NET_CAPABILITY_NOT_METERED,
43 NetCap::NET_CAPABILITY_INTERNET,
44 NetCap::NET_CAPABILITY_VALIDATED,
45 NetCap::NET_CAPABILITY_PORTAL,
46 NetCap::NET_CAPABILITY_INTERNAL_DEFAULT,
47 NetCap::NET_CAPABILITY_END};
48 instance_ = std::make_unique<NetCaps>(caps);
49 }
50
TearDownTestCase()51 void NetCapsTest::TearDownTestCase() {}
52
SetUp()53 void NetCapsTest::SetUp() {}
54
TearDown()55 void NetCapsTest::TearDown() {}
56
57 HWTEST_F(NetCapsTest, ConstructorTest001, TestSize.Level1)
58 {
59 std::unique_ptr<NetCaps> caps = std::make_unique<NetCaps>();
60 EXPECT_NE(caps, nullptr);
61 }
62
63 HWTEST_F(NetCapsTest, ConstructorTest002, TestSize.Level1)
64 {
65 std::set<NetCap> caps = {NetCap::NET_CAPABILITY_MMS,
66 NetCap::NET_CAPABILITY_NOT_METERED,
67 NetCap::NET_CAPABILITY_INTERNET,
68 NetCap::NET_CAPABILITY_NOT_VPN,
69 NetCap::NET_CAPABILITY_VALIDATED,
70 NetCap::NET_CAPABILITY_PORTAL,
71 NetCap::NET_CAPABILITY_INTERNAL_DEFAULT,
72 NetCap::NET_CAPABILITY_END};
73 std::unique_ptr<NetCaps> netCaps = std::make_unique<NetCaps>(caps);
74 EXPECT_NE(netCaps, nullptr);
75 }
76
77 HWTEST_F(NetCapsTest, operatorTest001, TestSize.Level1)
78 {
79 NetCaps lCaps;
80 NetCaps rCaps;
81 EXPECT_TRUE(lCaps == rCaps);
82 }
83
84 HWTEST_F(NetCapsTest, IsValidNetCapTest001, TestSize.Level1)
85 {
86 auto result = instance_->IsValidNetCap(NetCap::NET_CAPABILITY_NOT_VPN);
87 EXPECT_TRUE(result);
88 }
89
90 HWTEST_F(NetCapsTest, IsValidNetCapTest002, TestSize.Level1)
91 {
92 auto result = instance_->IsValidNetCap(static_cast<NetCap>(INVALID_NET_CAP));
93 EXPECT_FALSE(result);
94 }
95
96 HWTEST_F(NetCapsTest, IsValidNetCapTest003, TestSize.Level1)
97 {
98 auto result = instance_->IsValidNetCap(NetCap::NET_CAPABILITY_INTERNAL_DEFAULT);
99 EXPECT_TRUE(result);
100 }
101
102 HWTEST_F(NetCapsTest, InsertNetCapTest001, TestSize.Level1)
103 {
104 instance_->InsertNetCap(NetCap::NET_CAPABILITY_VALIDATED);
105 auto result = instance_->HasNetCap(NetCap::NET_CAPABILITY_VALIDATED);
106 EXPECT_TRUE(result);
107 }
108
109 HWTEST_F(NetCapsTest, InsertNetCapTest002, TestSize.Level1)
110 {
111 instance_->RemoveNetCap(NetCap::NET_CAPABILITY_VALIDATED);
112 auto result = instance_->HasNetCap(NetCap::NET_CAPABILITY_VALIDATED);
113 EXPECT_TRUE(!result);
114 }
115
116 HWTEST_F(NetCapsTest, HasNetCapTest001, TestSize.Level1)
117 {
118 auto result = instance_->HasNetCap(NetCap::NET_CAPABILITY_VALIDATED);
119 EXPECT_TRUE(!result);
120 }
121
122 HWTEST_F(NetCapsTest, HasNetCapTest002, TestSize.Level1)
123 {
124 auto result = instance_->HasNetCap(NetCap::NET_CAPABILITY_NOT_VPN);
125 EXPECT_FALSE(result);
126 }
127
128 HWTEST_F(NetCapsTest, HasNetCapsTest001, TestSize.Level1)
129 {
130 std::set<NetCap> caps;
131 auto result = instance_->HasNetCaps(caps);
132 EXPECT_TRUE(result);
133 }
134
135 HWTEST_F(NetCapsTest, HasNetCapsTest002, TestSize.Level1)
136 {
137 std::set<NetCap> caps = {NetCap::NET_CAPABILITY_NOT_VPN};
138 auto result = instance_->HasNetCaps(caps);
139 EXPECT_FALSE(result);
140 }
141
142 HWTEST_F(NetCapsTest, HasNetCapsTest003, TestSize.Level1)
143 {
144 std::set<NetCap> caps = {NetCap::NET_CAPABILITY_INTERNAL_DEFAULT};
145 auto result = instance_->HasNetCaps(caps);
146 EXPECT_TRUE(result);
147 }
148
149 HWTEST_F(NetCapsTest, ToSetTest001, TestSize.Level1)
150 {
151 auto result = instance_->ToSet();
152 EXPECT_FALSE(result.empty());
153 }
154
155 } // namespace NetManagerStandard
156 } // namespace OHOS