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
18 #include "avcast_controller_callback_client.h"
19 #include "avcontroller_callback_client.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace AVSession {
25 class AVControllerCallbackClientTest : public testing::Test {
26 public:
27 static void SetUpTestCase();
28 static void TearDownTestCase();
29 void SetUp() override;
30 void TearDown() override;
31 };
32
SetUpTestCase()33 void AVControllerCallbackClientTest::SetUpTestCase()
34 {}
35
TearDownTestCase()36 void AVControllerCallbackClientTest::TearDownTestCase()
37 {}
38
SetUp()39 void AVControllerCallbackClientTest::SetUp()
40 {}
41
TearDown()42 void AVControllerCallbackClientTest::TearDown()
43 {}
44
45 class AVControllerCallbackDemo : public AVControllerCallback {
46 public:
OnAVCallMetaDataChange(const AVCallMetaData & avCallMetaData)47 void OnAVCallMetaDataChange(const AVCallMetaData& avCallMetaData) override {}
48
OnAVCallStateChange(const AVCallState & avCallState)49 void OnAVCallStateChange(const AVCallState& avCallState) override {}
50
OnSessionDestroy()51 void OnSessionDestroy() override {}
52
OnPlaybackStateChange(const AVPlaybackState & state)53 void OnPlaybackStateChange(const AVPlaybackState& state) override {}
54
OnMetaDataChange(const AVMetaData & data)55 void OnMetaDataChange(const AVMetaData& data) override {}
56
OnActiveStateChange(bool isActive)57 void OnActiveStateChange(bool isActive) override {}
58
OnValidCommandChange(const std::vector<int32_t> & cmds)59 void OnValidCommandChange(const std::vector<int32_t>& cmds) override {}
60
OnOutputDeviceChange(const int32_t connectionState,const OutputDeviceInfo & outputDeviceInfo)61 void OnOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& outputDeviceInfo) override {}
62
OnSessionEventChange(const std::string & event,const AAFwk::WantParams & args)63 void OnSessionEventChange(const std::string& event, const AAFwk::WantParams& args) override {}
64
OnQueueItemsChange(const std::vector<AVQueueItem> & items)65 void OnQueueItemsChange(const std::vector<AVQueueItem>& items) override {}
66
OnQueueTitleChange(const std::string & title)67 void OnQueueTitleChange(const std::string& title) override {}
68
OnExtrasChange(const AAFwk::WantParams & extras)69 void OnExtrasChange(const AAFwk::WantParams& extras) override {}
70
OnCustomData(const OHOS::AAFwk::WantParams & data)71 void OnCustomData(const OHOS::AAFwk::WantParams& data) override {};
72
~AVControllerCallbackDemo()73 ~AVControllerCallbackDemo() override {}
74 };
75
76 /**
77 * @tc.name: OnSessionDestroy001
78 * @tc.desc: test OnSessionDestroy
79 * @tc.type: FUNC
80 * @tc.require:
81 */
82 HWTEST_F(AVControllerCallbackClientTest, OnSessionDestroy001, TestSize.Level0)
83 {
84 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
85 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
86 std::make_shared<AVControllerCallbackClient>(ptr);
87 EXPECT_NE(aVControllerCallbackClient, nullptr);
88 aVControllerCallbackClient->OnSessionDestroy();
89 }
90
91 /**
92 * @tc.name: OnAVCallMetaDataChange001
93 * @tc.desc: test OnAVCallMetaDataChange
94 * @tc.type: FUNC
95 * @tc.require:
96 */
97 HWTEST_F(AVControllerCallbackClientTest, OnAVCallMetaDataChange001, TestSize.Level0)
98 {
99 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
100 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
101 std::make_shared<AVControllerCallbackClient>(ptr);
102 EXPECT_NE(aVControllerCallbackClient, nullptr);
103 AVCallMetaData data;
104 aVControllerCallbackClient->OnAVCallMetaDataChange(data);
105 }
106
107 /**
108 * @tc.name: OnAVCallStateChange001
109 * @tc.desc: test OnAVCallStateChange
110 * @tc.type: FUNC
111 * @tc.require:
112 */
113 HWTEST_F(AVControllerCallbackClientTest, OnAVCallStateChange001, TestSize.Level0)
114 {
115 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
116 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
117 std::make_shared<AVControllerCallbackClient>(ptr);
118 EXPECT_NE(aVControllerCallbackClient, nullptr);
119 AVCallState state;
120 aVControllerCallbackClient->OnAVCallStateChange(state);
121 }
122
123 /**
124 * @tc.name: OnPlaybackStateChange001
125 * @tc.desc: test OnPlaybackStateChange
126 * @tc.type: FUNC
127 * @tc.require:
128 */
129 HWTEST_F(AVControllerCallbackClientTest, OnPlaybackStateChange001, TestSize.Level0)
130 {
131 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
132 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
133 std::make_shared<AVControllerCallbackClient>(ptr);
134 EXPECT_NE(aVControllerCallbackClient, nullptr);
135 AVPlaybackState avplaybackState;
136 aVControllerCallbackClient->OnPlaybackStateChange(avplaybackState);
137 }
138
139 /**
140 * @tc.name: OnPlaybackStateChange002
141 * @tc.desc: test OnPlaybackStateChange
142 * @tc.type: FUNC
143 * @tc.require:
144 */
145 HWTEST_F(AVControllerCallbackClientTest, OnPlaybackStateChange002, TestSize.Level0)
146 {
147 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
148 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
149 std::make_shared<AVControllerCallbackClient>(ptr);
150 EXPECT_NE(aVControllerCallbackClient, nullptr);
151 AVPlaybackState avplaybackState;
__anon714ee7000102(const AVPlaybackState& state) 152 aVControllerCallbackClient->AddListenerForPlaybackState([](const AVPlaybackState& state) {});
153 aVControllerCallbackClient->OnPlaybackStateChange(avplaybackState);
154 }
155
156 /**
157 * @tc.name: OnMetaDataChange001
158 * @tc.desc: test OnMetaDataChange
159 * @tc.type: FUNC
160 * @tc.require:
161 */
162 HWTEST_F(AVControllerCallbackClientTest, OnMetaDataChange001, TestSize.Level0)
163 {
164 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
165 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
166 std::make_shared<AVControllerCallbackClient>(ptr);
167 EXPECT_NE(aVControllerCallbackClient, nullptr);
168 AVMetaData data;
169 aVControllerCallbackClient->OnMetaDataChange(data);
170 }
171
172 /**
173 * @tc.name: OnActiveStateChange001
174 * @tc.desc: test OnActiveStateChange
175 * @tc.type: FUNC
176 * @tc.require:
177 */
178 HWTEST_F(AVControllerCallbackClientTest, OnActiveStateChange001, TestSize.Level0)
179 {
180 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
181 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
182 std::make_shared<AVControllerCallbackClient>(ptr);
183 EXPECT_NE(aVControllerCallbackClient, nullptr);
184 bool isActive = true;
185 aVControllerCallbackClient->OnActiveStateChange(isActive);
186 }
187
188 /**
189 * @tc.name: OnValidCommandChange001
190 * @tc.desc: test OnValidCommandChange
191 * @tc.type: FUNC
192 * @tc.require:
193 */
194 HWTEST_F(AVControllerCallbackClientTest, OnValidCommandChange001, TestSize.Level0)
195 {
196 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
197 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
198 std::make_shared<AVControllerCallbackClient>(ptr);
199 EXPECT_NE(aVControllerCallbackClient, nullptr);
200 std::vector<int32_t> cmds = {1, 2, 3};
201 aVControllerCallbackClient->OnValidCommandChange(cmds);
202 }
203
204 /**
205 * @tc.name: OnOutputDeviceChange001
206 * @tc.desc: test OnOutputDeviceChange
207 * @tc.type: FUNC
208 * @tc.require:
209 */
210 HWTEST_F(AVControllerCallbackClientTest, OnOutputDeviceChange001, TestSize.Level0)
211 {
212 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
213 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
214 std::make_shared<AVControllerCallbackClient>(ptr);
215 EXPECT_NE(aVControllerCallbackClient, nullptr);
216 int32_t connectionState = 1;
217 OutputDeviceInfo info;
218 aVControllerCallbackClient->OnOutputDeviceChange(connectionState, info);
219 }
220
221 /**
222 * @tc.name: OnSessionEventChange001
223 * @tc.desc: test OnSessionEventChange
224 * @tc.type: FUNC
225 * @tc.require:
226 */
227 HWTEST_F(AVControllerCallbackClientTest, OnSessionEventChange001, TestSize.Level0)
228 {
229 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
230 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
231 std::make_shared<AVControllerCallbackClient>(ptr);
232 EXPECT_NE(aVControllerCallbackClient, nullptr);
233 std::string event = "";
234 AAFwk::WantParams args;
235 aVControllerCallbackClient->OnSessionEventChange(event, args);
236 }
237
238 /**
239 * @tc.name: OnQueueItemsChange001
240 * @tc.desc: test OnQueueItemsChange
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(AVControllerCallbackClientTest, OnQueueItemsChange001, TestSize.Level0)
245 {
246 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
247 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
248 std::make_shared<AVControllerCallbackClient>(ptr);
249 EXPECT_NE(aVControllerCallbackClient, nullptr);
250 std::vector<AVQueueItem> items;
251 aVControllerCallbackClient->OnQueueItemsChange(items);
252 }
253
254 /**
255 * @tc.name: OnQueueTitleChange001
256 * @tc.desc: test OnQueueTitleChange
257 * @tc.type: FUNC
258 * @tc.require:
259 */
260 HWTEST_F(AVControllerCallbackClientTest, OnQueueTitleChange001, TestSize.Level0)
261 {
262 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
263 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
264 std::make_shared<AVControllerCallbackClient>(ptr);
265 EXPECT_NE(aVControllerCallbackClient, nullptr);
266 std::string title = "test";
267 aVControllerCallbackClient->OnQueueTitleChange(title);
268 }
269
270 /**
271 * @tc.name: OnExtrasChange001
272 * @tc.desc: test OnExtrasChange
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 HWTEST_F(AVControllerCallbackClientTest, OnExtrasChange001, TestSize.Level0)
277 {
278 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
279 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
280 std::make_shared<AVControllerCallbackClient>(ptr);
281 EXPECT_NE(aVControllerCallbackClient, nullptr);
282 AAFwk::WantParams extras;
283 aVControllerCallbackClient->OnExtrasChange(extras);
284 }
285
286 /**
287 * @tc.name: OnCustomData001
288 * @tc.desc: test OnCustomData
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(AVControllerCallbackClientTest, OnCustomData001, TestSize.Level0)
293 {
294 std::shared_ptr<AVControllerCallbackDemo> ptr = std::make_shared<AVControllerCallbackDemo>();
295 std::shared_ptr<AVControllerCallbackClient> aVControllerCallbackClient =
296 std::make_shared<AVControllerCallbackClient>(ptr);
297 EXPECT_NE(aVControllerCallbackClient, nullptr);
298 AAFwk::WantParams data;
299 aVControllerCallbackClient->OnCustomData(data);
300 }
301
302 } // namespace AVSession
303 } // namespace OHOS