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 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK));
55 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
56 EXPECT_EQ(DH_SUCCESS, senderTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK));
57 }
58
59 /**
60 * @tc.name: InitEngine_001
61 * @tc.desc: Verify the InitEngine function.
62 * @tc.type: FUNC
63 * @tc.require: AR000HTAPM
64 */
65 HWTEST_F(AVSenderEngineTransportTest, InitEngine_001, TestSize.Level1)
66 {
67 IAVEngineProvider *providerPtr = nullptr;
68 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->InitEngine(providerPtr));
69 EXPECT_EQ(DH_SUCCESS, senderTrans_->Release());
70 }
71
72 /**
73 * @tc.name: CreateCtrl_001
74 * @tc.desc: Verify the CreateCtrl function.
75 * @tc.type: FUNC
76 * @tc.require: AR000HTAPM
77 */
78 HWTEST_F(AVSenderEngineTransportTest, CreateCtrl_001, TestSize.Level1)
79 {
80 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->CreateCtrl());
81 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
82 senderTrans_->senderAdapter_->chnCreateSuccess_ = true;
83 EXPECT_EQ(DH_SUCCESS, senderTrans_->CreateCtrl());
84 }
85
86 /**
87 * @tc.name: Start_001
88 * @tc.desc: Verify the Start and Stop function.
89 * @tc.type: FUNC
90 * @tc.require: AR000HTAPM
91 */
92 HWTEST_F(AVSenderEngineTransportTest, Start_001, TestSize.Level1)
93 {
94 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->Start());
95 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->Stop());
96 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->Release());
97 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
98 senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
99 EXPECT_EQ(DH_SUCCESS, senderTrans_->Start());
100 EXPECT_EQ(DH_SUCCESS, senderTrans_->Stop());
101 }
102
103 /**
104 * @tc.name: Pause_001
105 * @tc.desc: Verify the Pause function.
106 * @tc.type: FUNC
107 * @tc.require: AR000HTAPM
108 */
109 HWTEST_F(AVSenderEngineTransportTest, Pause_001, TestSize.Level1)
110 {
111 AudioParam localParam;
112 AudioParam remoteParam;
113 size_t bufLen = 4096;
114 std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
115 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Restart(localParam, remoteParam));
116 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Pause());
117 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
118 senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
119 EXPECT_EQ(DH_SUCCESS, senderTrans_->FeedAudioData(audioData));
120 }
121
122 /**
123 * @tc.name: Pause_002
124 * @tc.desc: Verify the Pause function.
125 * @tc.type: FUNC
126 * @tc.require: AR000HTAPM
127 */
128 HWTEST_F(AVSenderEngineTransportTest, Pause_002, TestSize.Level1)
129 {
130 AudioParam localParam;
131 AudioParam remoteParam;
132 size_t bufLen = 4096;
133 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
134 senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
135 std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
136 EXPECT_EQ(DH_SUCCESS, senderTrans_->Restart(localParam, remoteParam));
137 EXPECT_EQ(DH_SUCCESS, senderTrans_->Pause());
138 EXPECT_EQ(DH_SUCCESS, senderTrans_->FeedAudioData(audioData));
139 }
140
141 /**
142 * @tc.name: SendMessage_001
143 * @tc.desc: Verify the SendMessage function.
144 * @tc.type: FUNC
145 * @tc.require: AR000HTAPM
146 */
147 HWTEST_F(AVSenderEngineTransportTest, SendMessage_001, TestSize.Level1)
148 {
149 uint32_t type = 0;
150 std::string content = "content";
151 std::string dstDevId = "dstDevId";
152 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->SendMessage(type, content, dstDevId));
153 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
154 senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
155 EXPECT_EQ(DH_SUCCESS, senderTrans_->SendMessage(type, content, dstDevId));
156 }
157
158 /**
159 * @tc.name: FeedAudioData_001
160 * @tc.desc: Verify the FeedAudioData function.
161 * @tc.type: FUNC
162 * @tc.require: AR000HTAPM
163 */
164 HWTEST_F(AVSenderEngineTransportTest, FeedAudioData_001, TestSize.Level1)
165 {
166 size_t bufLen = 4096;
167 std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
168 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->FeedAudioData(audioData));
169 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
170 senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
171 EXPECT_EQ(DH_SUCCESS, senderTrans_->FeedAudioData(audioData));
172 }
173
174 /**
175 * @tc.name: SetParameter_001
176 * @tc.desc: Verify the SetParameter function.
177 * @tc.type: FUNC
178 * @tc.require: AR000HTAPM
179 */
180 HWTEST_F(AVSenderEngineTransportTest, SetParameter_001, TestSize.Level1)
181 {
182 AVTransEvent event;
183 std::shared_ptr<AVTransMessage> message = nullptr;
184 senderTrans_->OnEngineEvent(event);
185 senderTrans_->OnEngineMessage(message);
186 AudioParam audioParam;
187 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SetParameter(audioParam));
188 senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
189 EXPECT_EQ(DH_SUCCESS, senderTrans_->SetParameter(audioParam));
190 }
191 } // namespace DistributedHardware
192 } // namespace OHOS
193