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 <gtest/gtest.h>
17 #include "avsession_errors.h"
18 #include "avsession_log.h"
19 #include "collaboration_manager_utils.h"
20 #include "collaboration_manager.h"
21
22 using namespace testing::ext;
23 using namespace OHOS::AVSession;
24
25 class CollaborationManagerTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28 static void TearDownTestCase(void);
29 void SetUp();
30 void TearDown();
31 };
32
SetUpTestCase()33 void CollaborationManagerTest::SetUpTestCase()
34 {
35 }
36
TearDownTestCase()37 void CollaborationManagerTest::TearDownTestCase()
38 {
39 }
40
SetUp()41 void CollaborationManagerTest::SetUp()
42 {
43 }
44
TearDown()45 void CollaborationManagerTest::TearDown()
46 {
47 }
48
49 /**
50 * @tc.name: RegisterLifecycleCallback001
51 * @tc.desc: Test RegisterLifecycleCallback
52 * @tc.type: FUNC
53 */
54 static HWTEST_F(CollaborationManagerTest, RegisterLifecycleCallback001, testing::ext::TestSize.Level1)
55 {
56 SLOGI("RegisterLifecycleCallback001, start");
57 int32_t ret = CollaborationManager::GetInstance().RegisterLifecycleCallback();
58 EXPECT_EQ(ret, AVSESSION_ERROR);
59 SLOGI("RegisterLifecycleCallback001, end");
60 }
61
62 /**
63 * @tc.name: RegisterLifecycleCallback002
64 * @tc.desc: Test RegisterLifecycleCallback
65 * @tc.type: FUNC
66 */
67 static HWTEST_F(CollaborationManagerTest, RegisterLifecycleCallback002, testing::ext::TestSize.Level1)
68 {
69 SLOGI("RegisterLifecycleCallback002, start");
__anond1ad2b220102(const char* serviceName, ServiceCollaborationManager_Callback* callback) 70 auto registerLifecycleCallback = [](const char* serviceName, ServiceCollaborationManager_Callback* callback) {
71 return static_cast<int32_t>(0);
72 };
73 CollaborationManager::GetInstance().exportapi_.ServiceCollaborationManager_RegisterLifecycleCallback
74 = registerLifecycleCallback;
75 int32_t ret = CollaborationManager::GetInstance().RegisterLifecycleCallback();
76 EXPECT_EQ(ret, AVSESSION_SUCCESS);
77 SLOGI("RegisterLifecycleCallback002, end");
78 }
79
80
81 /**
82 * @tc.name: RegisterLifecycleCallback003
83 * @tc.desc: Test RegisterLifecycleCallback
84 * @tc.type: FUNC
85 */
86 static HWTEST_F(CollaborationManagerTest, RegisterLifecycleCallback003, testing::ext::TestSize.Level1)
87 {
88 SLOGI("RegisterLifecycleCallback003, start");
__anond1ad2b220202(const char* serviceName, ServiceCollaborationManager_Callback* callback) 89 auto registerLifecycleCallback = [](const char* serviceName, ServiceCollaborationManager_Callback* callback) {
90 return static_cast<int32_t>(1);
91 };
92 CollaborationManager::GetInstance().exportapi_.ServiceCollaborationManager_RegisterLifecycleCallback
93 = registerLifecycleCallback;
94 int32_t ret = CollaborationManager::GetInstance().RegisterLifecycleCallback();
95 EXPECT_EQ(ret, AVSESSION_ERROR);
96 SLOGI("RegisterLifecycleCallback003, end");
97 }
98
99 /**
100 * @tc.name: RegisterLifecycleCallback004
101 * @tc.desc: Test RegisterLifecycleCallback
102 * @tc.type: FUNC
103 */
104 static HWTEST_F(CollaborationManagerTest, RegisterLifecycleCallback004, testing::ext::TestSize.Level0)
105 {
106 SLOGI("RegisterLifecycleCallback004, start");
107 CollaborationManager::GetInstance().exportapi_.ServiceCollaborationManager_RegisterLifecycleCallback
108 = nullptr;
109 int32_t ret = CollaborationManager::GetInstance().RegisterLifecycleCallback();
110 EXPECT_EQ(ret, AVSESSION_ERROR);
111 SLOGI("RegisterLifecycleCallback004, end");
112 }
113
114 /**
115 * @tc.name: UnRegisterLifecycleCallback001
116 * @tc.desc: Test UnRegisterLifecycleCallback
117 * @tc.type: FUNC
118 */
119 static HWTEST_F(CollaborationManagerTest, UnRegisterLifecycleCallback001, testing::ext::TestSize.Level1)
120 {
121 SLOGI("UnRegisterLifecycleCallback001, start");
122 int32_t ret = CollaborationManager::GetInstance().UnRegisterLifecycleCallback();
123 EXPECT_EQ(ret, AVSESSION_ERROR);
124 SLOGI("UnRegisterLifecycleCallback001, end");
125 }
126
127 /**
128 * @tc.name: UnRegisterLifecycleCallback002
129 * @tc.desc: Test UnRegisterLifecycleCallback
130 * @tc.type: FUNC
131 */
132 static HWTEST_F(CollaborationManagerTest, UnRegisterLifecycleCallback002, testing::ext::TestSize.Level1)
133 {
134 SLOGI("UnRegisterLifecycleCallback002, start");
__anond1ad2b220302(const char* serviceName) 135 auto unRegisterLifecycleCallback = [](const char* serviceName) {
136 return static_cast<int32_t>(0);
137 };
138 CollaborationManager::GetInstance().exportapi_.ServiceCollaborationManager_UnRegisterLifecycleCallback
139 = unRegisterLifecycleCallback;
140 int32_t ret = CollaborationManager::GetInstance().UnRegisterLifecycleCallback();
141 EXPECT_EQ(ret, AVSESSION_SUCCESS);
142 SLOGI("UnRegisterLifecycleCallback002, end");
143 }
144
145 /**
146 * @tc.name: UnRegisterLifecycleCallback003
147 * @tc.desc: Test UnRegisterLifecycleCallback
148 * @tc.type: FUNC
149 */
150 static HWTEST_F(CollaborationManagerTest, UnRegisterLifecycleCallback003, testing::ext::TestSize.Level1)
151 {
152 SLOGI("UnRegisterLifecycleCallback003, start");
__anond1ad2b220402(const char* serviceName) 153 auto unRegisterLifecycleCallback = [](const char* serviceName) {
154 return static_cast<int32_t>(1);
155 };
156 CollaborationManager::GetInstance().exportapi_.ServiceCollaborationManager_UnRegisterLifecycleCallback
157 = unRegisterLifecycleCallback;
158 int32_t ret = CollaborationManager::GetInstance().UnRegisterLifecycleCallback();
159 EXPECT_EQ(ret, AVSESSION_ERROR);
160 SLOGI("UnRegisterLifecycleCallback003, end");
161 }
162
163 /**
164 * @tc.name: PublishServiceState001
165 * @tc.desc: Test PublishServiceState
166 * @tc.type: FUNC
167 */
168 static HWTEST_F(CollaborationManagerTest, PublishServiceState001, testing::ext::TestSize.Level1)
169 {
170 SLOGI("PublishServiceState001, start");
171 const char* peerNetworkId = "";
172 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
173 int32_t ret = CollaborationManager::GetInstance().PublishServiceState(peerNetworkId, state);
174 EXPECT_EQ(ret, AVSESSION_ERROR);
175 SLOGI("PublishServiceState001, end");
176 }
177
178 /**
179 * @tc.name: PublishServiceState002
180 * @tc.desc: Test PublishServiceState
181 * @tc.type: FUNC
182 */
183 static HWTEST_F(CollaborationManagerTest, PublishServiceState002, testing::ext::TestSize.Level1)
184 {
185 SLOGI("PublishServiceState002, start");
186 const char* peerNetworkId = "";
187 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
188 auto publishServiceState = [](const char* peerNetworkId, const char* serviceName,
__anond1ad2b220502(const char* peerNetworkId, const char* serviceName, const char* extraInfo, ServiceCollaborationManagerBussinessStatus state) 189 const char* extraInfo, ServiceCollaborationManagerBussinessStatus state) {
190 return static_cast<int32_t>(0);
191 };
192 CollaborationManager::GetInstance().exportapi_.ServiceCollaborationManager_PublishServiceState
193 = publishServiceState;
194 int32_t ret = CollaborationManager::GetInstance().PublishServiceState(peerNetworkId, state);
195 EXPECT_EQ(ret, AVSESSION_SUCCESS);
196 SLOGI("PublishServiceState002, end");
197 }
198
199 /**
200 * @tc.name: PublishServiceState003
201 * @tc.desc: Test PublishServiceState
202 * @tc.type: FUNC
203 */
204 static HWTEST_F(CollaborationManagerTest, PublishServiceState003, testing::ext::TestSize.Level1)
205 {
206 SLOGI("PublishServiceState003, start");
207 const char* peerNetworkId = "";
208 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
209 auto publishServiceState = [](const char* peerNetworkId, const char* serviceName,
__anond1ad2b220602(const char* peerNetworkId, const char* serviceName, const char* extraInfo, ServiceCollaborationManagerBussinessStatus state) 210 const char* extraInfo, ServiceCollaborationManagerBussinessStatus state) {
211 return static_cast<int32_t>(1);
212 };
213 CollaborationManager::GetInstance().exportapi_.ServiceCollaborationManager_PublishServiceState
214 = publishServiceState;
215 int32_t ret = CollaborationManager::GetInstance().PublishServiceState(peerNetworkId, state);
216 EXPECT_EQ(ret, AVSESSION_ERROR);
217 SLOGI("PublishServiceState003, end");
218 }
219
220 /**
221 * @tc.name: ApplyAdvancedResource001
222 * @tc.desc: Test ApplyAdvancedResource
223 * @tc.type: FUNC
224 */
225 static HWTEST_F(CollaborationManagerTest, ApplyAdvancedResource001, testing::ext::TestSize.Level1)
226 {
227 SLOGI("ApplyAdvancedResource001, start");
228 const char* peerNetworkId = "";
229 int32_t ret = CollaborationManager::GetInstance().ApplyAdvancedResource(peerNetworkId);
230 EXPECT_EQ(ret, AVSESSION_ERROR);
231 SLOGI("ApplyAdvancedResource001, end");
232 }
233
234 /**
235 * @tc.name: ApplyAdvancedResource002
236 * @tc.desc: Test ApplyAdvancedResource
237 * @tc.type: FUNC
238 */
239 static HWTEST_F(CollaborationManagerTest, ApplyAdvancedResource002, testing::ext::TestSize.Level1)
240 {
241 SLOGI("ApplyAdvancedResource002, start");
242 const char* peerNetworkId = "";
243 auto applyAdvancedResource = [](const char* peerNetworkId, const char* serviceName,
244 ServiceCollaborationManager_ResourceRequestInfoSets* resourceRequest,
__anond1ad2b220702(const char* peerNetworkId, const char* serviceName, ServiceCollaborationManager_ResourceRequestInfoSets* resourceRequest, ServiceCollaborationManager_Callback* callback) 245 ServiceCollaborationManager_Callback* callback) {
246 return static_cast<int32_t>(0);
247 };
248 CollaborationManager::GetInstance().exportapi_.ServiceCollaborationManager_ApplyAdvancedResource
249 = applyAdvancedResource;
250 int32_t ret = CollaborationManager::GetInstance().ApplyAdvancedResource(peerNetworkId);
251 EXPECT_EQ(ret, AVSESSION_SUCCESS);
252 SLOGI("ApplyAdvancedResource002, end");
253 }
254
255 /**
256 * @tc.name: ApplyAdvancedResource003
257 * @tc.desc: Test ApplyAdvancedResource
258 * @tc.type: FUNC
259 */
260 static HWTEST_F(CollaborationManagerTest, ApplyAdvancedResource003, testing::ext::TestSize.Level1)
261 {
262 SLOGI("ApplyAdvancedResource003, start");
263 const char* peerNetworkId = "";
264 auto applyAdvancedResource = [](const char* peerNetworkId, const char* serviceName,
265 ServiceCollaborationManager_ResourceRequestInfoSets* resourceRequest,
__anond1ad2b220802(const char* peerNetworkId, const char* serviceName, ServiceCollaborationManager_ResourceRequestInfoSets* resourceRequest, ServiceCollaborationManager_Callback* callback) 266 ServiceCollaborationManager_Callback* callback) {
267 return static_cast<int32_t>(1);
268 };
269 CollaborationManager::GetInstance().exportapi_.ServiceCollaborationManager_ApplyAdvancedResource
270 = applyAdvancedResource;
271 int32_t ret = CollaborationManager::GetInstance().ApplyAdvancedResource(peerNetworkId);
272 EXPECT_EQ(ret, AVSESSION_ERROR);
273 SLOGI("ApplyAdvancedResource003, end");
274 }