1 /*
2 * Copyright (c) 2022-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 "encode_transport_test.h"
17
18 #include <memory>
19
20 #include "audio_data.h"
21 #include "audio_event.h"
22 #include "audio_transport_status.h"
23 #include "audio_transport_status_factory.h"
24 #include "audio_param.h"
25 #include "daudio_errorcode.h"
26 #include "daudio_log.h"
27 #include "daudio_util.h"
28 #include "audio_transport_context.h"
29 #include "mock_audio_data_channel.h"
30 #include "mock_audio_transport_callback.h"
31 #include "securec.h"
32
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace DistributedHardware {
37 const std::string RMT_DEV_ID_TEST = "RemoteDevIdTest";
38 const PortCapType ROLE_TEST = CAP_SPK;
39
SetUpTestCase(void)40 void EncodeTransportTest::SetUpTestCase(void)
41 {
42 }
43
TearDownTestCase(void)44 void EncodeTransportTest::TearDownTestCase(void)
45 {
46 }
47
SetUp(void)48 void EncodeTransportTest::SetUp(void)
49 {
50 transCallback_ = std::make_shared<MockAudioTransportCallback>();
51 encodeTrans_ = std::make_shared<AudioEncodeTransport>(RMT_DEV_ID_TEST);
52 }
53
TearDown(void)54 void EncodeTransportTest::TearDown(void)
55 {
56 transCallback_ = nullptr;
57 encodeTrans_ = nullptr;
58 }
59
60 /**
61 * @tc.name: encode_transport_test_001
62 * @tc.desc: Verify the configure transport function.
63 * @tc.type: FUNC
64 * @tc.require: AR000H0E5U
65 */
66 HWTEST_F(EncodeTransportTest, encode_transport_test_001, TestSize.Level1)
67 {
68 AudioParam testLocalParaEnc = {
69 {
70 SAMPLE_RATE_48000,
71 STEREO,
72 SAMPLE_S16LE,
73 AUDIO_CODEC_FLAC
74 },
75 {
76 SOURCE_TYPE_INVALID,
77 NORMAL_MODE
78 },
79 {
80 CONTENT_TYPE_UNKNOWN,
81 STREAM_USAGE_UNKNOWN,
82 NORMAL_MODE
83 }
84 };
85 AudioParam testRemoteParaEnc = {
86 {
87 SAMPLE_RATE_48000,
88 STEREO,
89 SAMPLE_S16LE,
90 AUDIO_CODEC_FLAC
91 },
92 {
93 SOURCE_TYPE_INVALID,
94 NORMAL_MODE
95 },
96 {
97 CONTENT_TYPE_UNKNOWN,
98 STREAM_USAGE_UNKNOWN,
99 NORMAL_MODE
100 }
101 };
102 EXPECT_NE(DH_SUCCESS, encodeTrans_->SetUp(testLocalParaEnc, testRemoteParaEnc, transCallback_, ROLE_TEST));
103 EXPECT_EQ(DH_SUCCESS, encodeTrans_->Release());
104 }
105
106 /**
107 * @tc.name: encode_transport_test_002
108 * @tc.desc: Verify the start transport without configure transport function.
109 * @tc.type: FUNC
110 * @tc.require: AR000H0E5U
111 */
112 HWTEST_F(EncodeTransportTest, encode_transport_test_002, TestSize.Level1)
113 {
114 encodeTrans_->audioChannel_ = std::make_shared<MockAudioDataChannel>(RMT_DEV_ID_TEST);
115 encodeTrans_->context_ = std::make_shared<AudioTransportContext>();
116 auto stateContext = std::shared_ptr<AudioTransportContext>(encodeTrans_->context_);
117 encodeTrans_->context_->currentState_ =
118 AudioTransportStatusFactory::GetInstance().CreateState(TRANSPORT_STATE_START, stateContext);
119 EXPECT_EQ(DH_SUCCESS, encodeTrans_->Start());
120 encodeTrans_->context_->currentState_ =
121 AudioTransportStatusFactory::GetInstance().CreateState(TRANSPORT_STATE_STOP, stateContext);
122 EXPECT_EQ(DH_SUCCESS, encodeTrans_->Stop());
123 EXPECT_EQ(DH_SUCCESS, encodeTrans_->Release());
124 }
125
126 /**
127 * @tc.name: encode_transport_test_003
128 * @tc.desc: Verify the pasue and restart transport without configure transport function.
129 * @tc.type: FUNC
130 * @tc.require: AR000H0E5U
131 */
132 HWTEST_F(EncodeTransportTest, encode_transport_test_003, TestSize.Level1)
133 {
134 AudioParam testLocalParaEnc = {
135 {
136 SAMPLE_RATE_48000,
137 STEREO,
138 SAMPLE_S16LE,
139 AUDIO_CODEC_FLAC
140 },
141 {
142 SOURCE_TYPE_INVALID,
143 NORMAL_MODE
144 },
145 {
146 CONTENT_TYPE_UNKNOWN,
147 STREAM_USAGE_UNKNOWN,
148 NORMAL_MODE
149 }
150 };
151 AudioParam testRemoteParaEnc = {
152 {
153 SAMPLE_RATE_48000,
154 STEREO,
155 SAMPLE_S16LE,
156 AUDIO_CODEC_FLAC
157 },
158 {
159 SOURCE_TYPE_INVALID,
160 NORMAL_MODE
161 },
162 {
163 CONTENT_TYPE_UNKNOWN,
164 STREAM_USAGE_UNKNOWN,
165 NORMAL_MODE
166 }
167 };
168
169 EXPECT_EQ(ERR_DH_AUDIO_TRANS_ERROR, encodeTrans_->RegisterProcessorListener(testLocalParaEnc, testRemoteParaEnc));
170 EXPECT_EQ(ERR_DH_AUDIO_TRANS_ERROR,
171 encodeTrans_->InitAudioEncodeTrans(testLocalParaEnc, testRemoteParaEnc, ROLE_TEST));
172 encodeTrans_->context_ = std::make_shared<AudioTransportContext>();
173 auto stateContext = std::shared_ptr<AudioTransportContext>(encodeTrans_->context_);
174 encodeTrans_->context_->currentState_ =
175 AudioTransportStatusFactory::GetInstance().CreateState(TRANSPORT_STATE_PAUSE, stateContext);
176 EXPECT_EQ(DH_SUCCESS, encodeTrans_->Pause());
177 EXPECT_EQ(ERR_DH_AUDIO_TRANS_ERROR, encodeTrans_->Restart(testLocalParaEnc, testRemoteParaEnc));
178 }
179
180 /**
181 * @tc.name: encode_transport_test_004
182 * @tc.desc: Verify encode_transport_test function.
183 * @tc.type: FUNC
184 * @tc.require: AR000H0E5U
185 */
186 HWTEST_F(EncodeTransportTest, encode_transport_test_004, TestSize.Level1)
187 {
188 std::shared_ptr<AudioData> audioData = nullptr;
189 AudioEvent event;
190 encodeTrans_->OnSessionOpened();
191 encodeTrans_->OnSessionClosed();
192 encodeTrans_->OnDataReceived(audioData);
193 encodeTrans_->OnEventReceived(event);
194 encodeTrans_->OnStateNotify(event);
195 encodeTrans_->OnAudioDataDone(audioData);
196
197 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, encodeTrans_->FeedAudioData(audioData));
198 }
199
200 /**
201 * @tc.name: encode_transport_test_005
202 * @tc.desc: Verify RegisterChannelListener function.
203 * @tc.type: FUNC
204 * @tc.require: AR000H0E5U
205 */
206 HWTEST_F(EncodeTransportTest, encode_transport_test_005, TestSize.Level1)
207 {
208 IAVEngineProvider *providerPtr = nullptr;
209 uint32_t type = 0;
210 std::string content = "content";
211 std::string dstDevId = "dstDevId";
212 EXPECT_EQ(ERR_DH_AUDIO_TRANS_ERROR, encodeTrans_->RegisterChannelListener(ROLE_TEST));
213 EXPECT_EQ(DH_SUCCESS, encodeTrans_->CreateCtrl());
214 EXPECT_EQ(DH_SUCCESS, encodeTrans_->InitEngine(providerPtr));
215 EXPECT_EQ(DH_SUCCESS, encodeTrans_->SendMessage(type, content, dstDevId));
216 }
217 } // namespace DistributedHardware
218 } // namespace OHOS
219