1 /*
2 * Copyright (c) 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 #include "net_manager_constants.h"
19 #include "net_supplier_callback_base.h"
20 #include "net_supplier_callback_stub.h"
21
22 namespace OHOS {
23 namespace NetManagerStandard {
24 namespace {
25 using namespace testing::ext;
26 class NetSupplierCallbackStubTestCb : public NetSupplierCallbackStub {
27 public:
28 NetSupplierCallbackStubTestCb() = default;
~NetSupplierCallbackStubTestCb()29 ~NetSupplierCallbackStubTestCb() {}
30
RequestNetwork(const std::string & ident,const std::set<NetCap> & netCaps)31 int32_t RequestNetwork(const std::string &ident, const std::set<NetCap> &netCaps) override
32 {
33 return 0;
34 }
35
ReleaseNetwork(const std::string & ident,const std::set<NetCap> & netCaps)36 int32_t ReleaseNetwork(const std::string &ident, const std::set<NetCap> &netCaps) override
37 {
38 return 0;
39 }
40 };
41
42 class NetSupplierCallbackBaseTestCb : public NetSupplierCallbackBase {
43 public:
44 ~NetSupplierCallbackBaseTestCb() = default;
45
RequestNetwork(const std::string & ident,const std::set<NetCap> & netCaps)46 int32_t RequestNetwork(const std::string &ident, const std::set<NetCap> &netCaps) override
47 {
48 return NETMANAGER_SUCCESS;
49 };
50
ReleaseNetwork(const std::string & ident,const std::set<NetCap> & netCaps)51 int32_t ReleaseNetwork(const std::string &ident, const std::set<NetCap> &netCaps) override
52 {
53 return NETMANAGER_SUCCESS;
54 };
55 };
56 } // namespace
57
58 class NetSupplierCallbackStubTest : public testing::Test {
59 public:
60 static void SetUpTestCase();
61 static void TearDownTestCase();
62 void SetUp();
63 void TearDown();
64
65 static inline std::shared_ptr<NetSupplierCallbackStubTestCb> supplierCbStub_ = nullptr;
66 };
67
SetUpTestCase()68 void NetSupplierCallbackStubTest::SetUpTestCase()
69 {
70 supplierCbStub_ = std::make_shared<NetSupplierCallbackStubTestCb>();
71 sptr<NetSupplierCallbackBase> callback = new (std::nothrow) NetSupplierCallbackBaseTestCb();
72 supplierCbStub_->RegisterSupplierCallbackImpl(callback);
73 }
74
TearDownTestCase()75 void NetSupplierCallbackStubTest::TearDownTestCase() {}
76
SetUp()77 void NetSupplierCallbackStubTest::SetUp() {}
78
TearDown()79 void NetSupplierCallbackStubTest::TearDown() {}
80
81 HWTEST_F(NetSupplierCallbackStubTest, RequestNetwork001, TestSize.Level1)
82 {
83 std::string ident = "testsupid";
84 std::set<NetCap> netCaps;
85 netCaps.insert(NetCap::NET_CAPABILITY_NOT_METERED);
86 MessageParcel data;
87 if (!data.WriteInterfaceToken(NetSupplierCallbackStub::GetDescriptor())) {
88 return;
89 }
90 if (!data.WriteString(ident)) {
91 return;
92 }
93 uint32_t size = static_cast<uint32_t>(netCaps.size());
94 if (!data.WriteUint32(size)) {
95 return;
96 }
97 for (auto netCap : netCaps) {
98 data.WriteInt32(static_cast<uint32_t>(netCap));
99 }
100
101 MessageParcel reply;
102 MessageOption option;
103 int32_t ret = supplierCbStub_->OnRemoteRequest(100, data, reply, option);
104 EXPECT_NE(ret, NETMANAGER_SUCCESS);
105
106 ret = supplierCbStub_->OnRemoteRequest(
107 static_cast<uint32_t>(SupplierInterfaceCode::NET_SUPPLIER_REQUEST_NETWORK), data, reply, option);
108 EXPECT_NE(ret, NETMANAGER_SUCCESS);
109
110 MessageParcel dataOk;
111 if (!dataOk.WriteInterfaceToken(NetSupplierCallbackStub::GetDescriptor())) {
112 return;
113 }
114 if (!dataOk.WriteString(ident)) {
115 return;
116 }
117 size = static_cast<uint32_t>(netCaps.size());
118 if (!dataOk.WriteUint32(size)) {
119 return;
120 }
121 for (auto netCap : netCaps) {
122 dataOk.WriteInt32(static_cast<uint32_t>(netCap));
123 }
124 ret = supplierCbStub_->OnRemoteRequest(
125 static_cast<uint32_t>(SupplierInterfaceCode::NET_SUPPLIER_REQUEST_NETWORK), dataOk, reply, option);
126 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
127 }
128
129 HWTEST_F(NetSupplierCallbackStubTest, ReleaseNetwork001, TestSize.Level1)
130 {
131 std::string ident = "testsupid";
132 std::set<NetCap> netCaps;
133 netCaps.insert(NetCap::NET_CAPABILITY_NOT_METERED);
134 MessageParcel data;
135 if (!data.WriteInterfaceToken(NetSupplierCallbackStub::GetDescriptor())) {
136 return;
137 }
138 if (!data.WriteString(ident)) {
139 return;
140 }
141 uint32_t size = static_cast<uint32_t>(netCaps.size());
142 if (!data.WriteUint32(size)) {
143 return;
144 }
145 for (auto netCap : netCaps) {
146 data.WriteInt32(static_cast<uint32_t>(netCap));
147 }
148
149 MessageParcel reply;
150 MessageOption option;
151 int32_t ret = supplierCbStub_->OnRemoteRequest(
152 static_cast<uint32_t>(SupplierInterfaceCode::NET_SUPPLIER_RELEASE_NETWORK), data, reply, option);
153 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
154 }
155 } // namespace NetManagerStandard
156 } // namespace OHOS