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 <securec.h>
17
18 #include <gtest/gtest.h>
19 #include <unistd.h>
20 #include "disc_coap.h"
21 #include "softbus_error_code.h"
22 #include "softbus_adapter_mem.h"
23 #include "disc_manager.h"
24
25 using namespace testing::ext;
26 namespace OHOS {
27
28 static DiscoveryFuncInterface *g_discCoapFuncInterface = NULL;
29
30 class DiscCoapTest : public testing::Test {
31 public:
DiscCoapTest()32 DiscCoapTest()
33 {}
~DiscCoapTest()34 ~DiscCoapTest()
35 {}
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
SetUp()38 void SetUp() override {}
TearDown()39 void TearDown() override {}
40 };
41
SetUpTestCase(void)42 void DiscCoapTest::SetUpTestCase(void)
43 {}
44
TearDownTestCase(void)45 void DiscCoapTest::TearDownTestCase(void)
46 {}
47
48 static DiscInnerCallback g_discInnerCb = {
49 .OnDeviceFound = NULL
50 };
51
52 /*
53 * @tc.name: testCoapPublish
54 * @tc.desc: test CoapPublish
55 * @tc.type: FUNC
56 * @tc.require:
57 */
58 HWTEST_F(DiscCoapTest, testCoapPublish001, TestSize.Level1)
59 {
60 int32_t ret;
61 bool ranging = true;
62
63 PublishOption *option = (PublishOption*)SoftBusMalloc(sizeof(PublishOption));
64 ASSERT_TRUE(option != nullptr);
65 memset_s(option, sizeof(PublishOption), 0, sizeof(PublishOption));
66
67 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
68 ret = g_discCoapFuncInterface->Publish(NULL);
69 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
70
71 ranging = false;
72 ret = g_discCoapFuncInterface->Publish(option);
73 EXPECT_EQ(ret, SOFTBUS_OK);
74
75 SoftBusFree(option);
76 }
77
78 /*
79 * @tc.name: testCoapUnPublish
80 * @tc.desc: test CoapUnPublish
81 * @tc.type: FUNC
82 * @tc.require:
83 */
84 HWTEST_F(DiscCoapTest, testCoapUnPublish001, TestSize.Level1)
85 {
86 int32_t ret;
87
88 PublishOption *option = (PublishOption*)SoftBusMalloc(sizeof(PublishOption));
89 ASSERT_TRUE(option != nullptr);
90 memset_s(option, sizeof(PublishOption), 0, sizeof(PublishOption));
91
92 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
93 ret = g_discCoapFuncInterface->Unpublish(NULL);
94 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
95
96 ret = g_discCoapFuncInterface->Unpublish(option);
97 EXPECT_EQ(ret, SOFTBUS_OK);
98
99 SoftBusFree(option);
100 }
101
102 /*
103 * @tc.name: testCoapStartScan
104 * @tc.desc: test CoapStartScan
105 * @tc.type: FUNC
106 * @tc.require:
107 */
108 HWTEST_F(DiscCoapTest, testCoapStartScan001, TestSize.Level1)
109 {
110 int32_t ret;
111
112 PublishOption *option = (PublishOption*)SoftBusMalloc(sizeof(PublishOption));
113 ASSERT_TRUE(option != nullptr);
114 memset_s(option, sizeof(PublishOption), 0, sizeof(PublishOption));
115
116 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
117 ret = g_discCoapFuncInterface->StartScan(NULL);
118 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
119
120 ret = g_discCoapFuncInterface->StartScan(option);
121 EXPECT_EQ(ret, SOFTBUS_OK);
122
123 SoftBusFree(option);
124 }
125
126 /*
127 * @tc.name: testCoapStopScan
128 * @tc.desc: test CoapStopScan
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(DiscCoapTest, testCoapStopScan001, TestSize.Level1)
133 {
134 int32_t ret;
135 bool ranging = true;
136
137 PublishOption *option = (PublishOption*)SoftBusMalloc(sizeof(PublishOption));
138 ASSERT_TRUE(option != nullptr);
139 memset_s(option, sizeof(PublishOption), 0, sizeof(PublishOption));
140
141 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
142 ret = g_discCoapFuncInterface->StopScan(NULL);
143 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
144
145 ret = g_discCoapFuncInterface->StopScan(option);
146
147 ranging = false;
148 ret = g_discCoapFuncInterface->StopScan(option);
149 EXPECT_EQ(ret, SOFTBUS_OK);
150
151 SoftBusFree(option);
152 }
153
154 /*
155 * @tc.name: testCoapStartAdvertise
156 * @tc.desc: test CoapStartAdvertise
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160 HWTEST_F(DiscCoapTest, testCoapStartAdvertise001, TestSize.Level1)
161 {
162 int32_t ret;
163
164 SubscribeOption *option = (SubscribeOption*)SoftBusMalloc(sizeof(SubscribeOption));
165 ASSERT_TRUE(option != nullptr);
166 memset_s(option, sizeof(SubscribeOption), 0, sizeof(SubscribeOption));
167
168 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
169 ret = g_discCoapFuncInterface->StartAdvertise(NULL);
170 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
171
172 ret = g_discCoapFuncInterface->StartAdvertise(option);
173 EXPECT_EQ(ret, SOFTBUS_OK);
174
175 SoftBusFree(option);
176 }
177
178 /*
179 * @tc.name: testCoapStopAdvertise
180 * @tc.desc: test CoapStopAdvertise
181 * @tc.type: FUNC
182 * @tc.require:
183 */
184 HWTEST_F(DiscCoapTest, testCoapStopAdvertise001, TestSize.Level1)
185 {
186 int32_t ret;
187
188 SubscribeOption *option = (SubscribeOption*)SoftBusMalloc(sizeof(SubscribeOption));
189 ASSERT_TRUE(option != nullptr);
190 memset_s(option, sizeof(SubscribeOption), 0, sizeof(SubscribeOption));
191
192 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
193 ret = g_discCoapFuncInterface->StopAdvertise(NULL);
194 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
195
196 ret = g_discCoapFuncInterface->StopAdvertise(option);
197 EXPECT_EQ(ret, SOFTBUS_OK);
198
199 SoftBusFree(option);
200 }
201
202 /*
203 * @tc.name: testCoapSubscribe
204 * @tc.desc: test CoapSubscribe
205 * @tc.type: FUNC
206 * @tc.require:
207 */
208 HWTEST_F(DiscCoapTest, testCoapSubscribe001, TestSize.Level1)
209 {
210 int32_t ret;
211
212 SubscribeOption *option = (SubscribeOption*)SoftBusMalloc(sizeof(SubscribeOption));
213 ASSERT_TRUE(option != nullptr);
214 memset_s(option, sizeof(SubscribeOption), 0, sizeof(SubscribeOption));
215
216 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
217 ret = g_discCoapFuncInterface->Subscribe(NULL);
218 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
219
220 ret = g_discCoapFuncInterface->Subscribe(option);
221 EXPECT_EQ(ret, SOFTBUS_OK);
222
223 SoftBusFree(option);
224 }
225
226 /*
227 * @tc.name: testCoapUnsubscribe
228 * @tc.desc: test CoapUnsubscribe
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(DiscCoapTest, testCoapUnsubscribe001, TestSize.Level1)
233 {
234 int32_t ret;
235
236 SubscribeOption *option = (SubscribeOption*)SoftBusMalloc(sizeof(SubscribeOption));
237 ASSERT_TRUE(option != nullptr);
238 memset_s(option, sizeof(SubscribeOption), 0, sizeof(SubscribeOption));
239
240 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
241 ret = g_discCoapFuncInterface->Unsubscribe(NULL);
242 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
243
244 ret = g_discCoapFuncInterface->Unsubscribe(option);
245 EXPECT_EQ(ret, SOFTBUS_OK);
246
247 SoftBusFree(option);
248 }
249 }