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 "av_sender_engine_transport_test.h"
17
18 #include "daudio_errorcode.h"
19 #include "daudio_log.h"
20 #include "daudio_util.h"
21 #include "engine_test_utils.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace DistributedHardware {
SetUpTestCase(void)27 void AVSenderEngineTransportTest::SetUpTestCase(void) {}
28
TearDownTestCase(void)29 void AVSenderEngineTransportTest::TearDownTestCase(void) {}
30
SetUp(void)31 void AVSenderEngineTransportTest::SetUp(void)
32 {
33 std::string devId = "devId";
34 auto callback = std::make_shared<MockAVSenderTransportCallback>();
35 senderTrans_ = std::make_shared<AVTransSenderTransport>(devId, callback);
36 }
37
TearDown(void)38 void AVSenderEngineTransportTest::TearDown(void)
39 {
40 senderTrans_ = nullptr;
41 }
42
43 /**
44 * @tc.name: Setup_001
45 * @tc.desc: Verify the Setup function.
46 * @tc.type: FUNC
47 * @tc.require: AR000HTAPM
48 */
49 HWTEST_F(AVSenderEngineTransportTest, SetUp_001, TestSize.Level1)
50 {
51 AudioParam localParam;
52 AudioParam remoteParam;
53 std::shared_ptr<IAudioDataTransCallback> callback = nullptr;
54 ASSERT_NE(senderTrans_, nullptr);
55 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK));
56 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
57 EXPECT_EQ(DH_SUCCESS, senderTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK));
58 }
59
60 /**
61 * @tc.name: InitEngine_001
62 * @tc.desc: Verify the InitEngine function.
63 * @tc.type: FUNC
64 * @tc.require: AR000HTAPM
65 */
66 HWTEST_F(AVSenderEngineTransportTest, InitEngine_001, TestSize.Level1)
67 {
68 IAVEngineProvider *providerPtr = nullptr;
69 ASSERT_NE(senderTrans_, nullptr);
70 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->InitEngine(providerPtr));
71 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
72 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->InitEngine(providerPtr));
73 EXPECT_EQ(DH_SUCCESS, senderTrans_->Release());
74 }
75
76 /**
77 * @tc.name: CreateCtrl_001
78 * @tc.desc: Verify the CreateCtrl function.
79 * @tc.type: FUNC
80 * @tc.require: AR000HTAPM
81 */
82 HWTEST_F(AVSenderEngineTransportTest, CreateCtrl_001, TestSize.Level1)
83 {
84 ASSERT_NE(senderTrans_, nullptr);
85 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->CreateCtrl());
86 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
87 senderTrans_->senderAdapter_->chnCreateSuccess_ = true;
88 EXPECT_EQ(DH_SUCCESS, senderTrans_->CreateCtrl());
89 }
90
91 /**
92 * @tc.name: Start_001
93 * @tc.desc: Verify the Start and Stop function.
94 * @tc.type: FUNC
95 * @tc.require: AR000HTAPM
96 */
97 HWTEST_F(AVSenderEngineTransportTest, Start_001, TestSize.Level1)
98 {
99 ASSERT_NE(senderTrans_, nullptr);
100 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Start());
101 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Stop());
102 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Release());
103 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
104 senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
105 EXPECT_EQ(DH_SUCCESS, senderTrans_->Start());
106 EXPECT_EQ(DH_SUCCESS, senderTrans_->Stop());
107 }
108
109 /**
110 * @tc.name: Pause_001
111 * @tc.desc: Verify the Pause function.
112 * @tc.type: FUNC
113 * @tc.require: AR000HTAPM
114 */
115 HWTEST_F(AVSenderEngineTransportTest, Pause_001, TestSize.Level1)
116 {
117 AudioParam localParam;
118 AudioParam remoteParam;
119 size_t bufLen = 4096;
120 std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
121 ASSERT_NE(senderTrans_, nullptr);
122 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Restart(localParam, remoteParam));
123 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Pause());
124 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
125 senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
126 EXPECT_EQ(DH_SUCCESS, senderTrans_->FeedAudioData(audioData));
127 }
128
129 /**
130 * @tc.name: Pause_002
131 * @tc.desc: Verify the Pause function.
132 * @tc.type: FUNC
133 * @tc.require: AR000HTAPM
134 */
135 HWTEST_F(AVSenderEngineTransportTest, Pause_002, TestSize.Level1)
136 {
137 AudioParam localParam;
138 AudioParam remoteParam;
139 size_t bufLen = 4096;
140 ASSERT_NE(senderTrans_, nullptr);
141 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
142 senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
143 std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
144 EXPECT_EQ(DH_SUCCESS, senderTrans_->Restart(localParam, remoteParam));
145 EXPECT_EQ(DH_SUCCESS, senderTrans_->Pause());
146 EXPECT_EQ(DH_SUCCESS, senderTrans_->FeedAudioData(audioData));
147 }
148
149 /**
150 * @tc.name: SendMessage_001
151 * @tc.desc: Verify the SendMessage function.
152 * @tc.type: FUNC
153 * @tc.require: AR000HTAPM
154 */
155 HWTEST_F(AVSenderEngineTransportTest, SendMessage_001, TestSize.Level1)
156 {
157 uint32_t type = 0;
158 std::string content = "content";
159 std::string dstDevId = "dstDevId";
160 ASSERT_NE(senderTrans_, nullptr);
161 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SendMessage(type, content, dstDevId));
162 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
163 senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
164 EXPECT_EQ(DH_SUCCESS, senderTrans_->SendMessage(type, content, dstDevId));
165 }
166
167 /**
168 * @tc.name: FeedAudioData_001
169 * @tc.desc: Verify the FeedAudioData function.
170 * @tc.type: FUNC
171 * @tc.require: AR000HTAPM
172 */
173 HWTEST_F(AVSenderEngineTransportTest, FeedAudioData_001, TestSize.Level1)
174 {
175 size_t bufLen = 4096;
176 std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
177 ASSERT_NE(senderTrans_, nullptr);
178 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->FeedAudioData(audioData));
179 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
180 senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
181 EXPECT_EQ(DH_SUCCESS, senderTrans_->FeedAudioData(audioData));
182 }
183
184 /**
185 * @tc.name: SetParameter_001
186 * @tc.desc: Verify the SetParameter function.
187 * @tc.type: FUNC
188 * @tc.require: AR000HTAPM
189 */
190 HWTEST_F(AVSenderEngineTransportTest, SetParameter_001, TestSize.Level1)
191 {
192 AVTransEvent event;
193 std::shared_ptr<AVTransMessage> message = nullptr;
194 ASSERT_NE(senderTrans_, nullptr);
195 senderTrans_->OnEngineEvent(event);
196 senderTrans_->OnEngineMessage(message);
197 message = std::make_shared<AVTransMessage>();
198 senderTrans_->OnEngineMessage(message);
199 AudioParam audioParam;
200 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SetParameter(audioParam));
201 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
202 EXPECT_EQ(DH_SUCCESS, senderTrans_->SetParameter(audioParam));
203 }
204 } // namespace DistributedHardware
205 } // namespace OHOS