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_receiver_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 AVReceiverEngineTransportTest::SetUpTestCase(void) {}
28
TearDownTestCase(void)29 void AVReceiverEngineTransportTest::TearDownTestCase(void) {}
30
SetUp(void)31 void AVReceiverEngineTransportTest::SetUp(void)
32 {
33 std::string devId = "devId";
34 auto callback = std::make_shared<MockAVReceiverTransportCallback>();
35 receiverTrans_ = std::make_shared<AVTransReceiverTransport>(devId, callback);
36 }
37
TearDown(void)38 void AVReceiverEngineTransportTest::TearDown(void)
39 {
40 receiverTrans_ = 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(AVReceiverEngineTransportTest, SetUp_001, TestSize.Level1)
50 {
51 AudioParam localParam;
52 AudioParam remoteParam;
53 std::shared_ptr<IAudioDataTransCallback> callback = nullptr;
54 ASSERT_NE(receiverTrans_, nullptr);
55 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK));
56 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
57 EXPECT_EQ(DH_SUCCESS, receiverTrans_->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(AVReceiverEngineTransportTest, InitEngine_001, TestSize.Level1)
67 {
68 IAVEngineProvider *providerPtr = nullptr;
69 ASSERT_NE(receiverTrans_, nullptr);
70 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->InitEngine(providerPtr));
71 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
72 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->InitEngine(providerPtr));
73 EXPECT_EQ(DH_SUCCESS, receiverTrans_->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(AVReceiverEngineTransportTest, CreateCtrl_001, TestSize.Level1)
83 {
84 ASSERT_NE(receiverTrans_, nullptr);
85 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->CreateCtrl());
86 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
87 receiverTrans_->receiverAdapter_->chnCreateSuccess_ = true;
88 EXPECT_EQ(DH_SUCCESS, receiverTrans_->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(AVReceiverEngineTransportTest, Start_001, TestSize.Level1)
98 {
99 ASSERT_NE(receiverTrans_, nullptr);
100 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Start());
101 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Stop());
102 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Release());
103 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
104 receiverTrans_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
105 EXPECT_EQ(DH_SUCCESS, receiverTrans_->Start());
106 EXPECT_EQ(DH_SUCCESS, receiverTrans_->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(AVReceiverEngineTransportTest, 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(receiverTrans_, nullptr);
122 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Restart(localParam, remoteParam));
123 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Pause());
124 EXPECT_EQ(DH_SUCCESS, receiverTrans_->FeedAudioData(audioData));
125 }
126
127 /**
128 * @tc.name: Pause_002
129 * @tc.desc: Verify the Pause function.
130 * @tc.type: FUNC
131 * @tc.require: AR000HTAPM
132 */
133 HWTEST_F(AVReceiverEngineTransportTest, Pause_002, TestSize.Level1)
134 {
135 AudioParam localParam;
136 AudioParam remoteParam;
137 size_t bufLen = 4096;
138 std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
139 ASSERT_NE(receiverTrans_, nullptr);
140 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
141 receiverTrans_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
142 EXPECT_EQ(DH_SUCCESS, receiverTrans_->Restart(localParam, remoteParam));
143 EXPECT_EQ(DH_SUCCESS, receiverTrans_->Pause());
144 EXPECT_EQ(DH_SUCCESS, receiverTrans_->FeedAudioData(audioData));
145 }
146
147 /**
148 * @tc.name: SendMessage_001
149 * @tc.desc: Verify the SendMessage function.
150 * @tc.type: FUNC
151 * @tc.require: AR000HTAPM
152 */
153 HWTEST_F(AVReceiverEngineTransportTest, SendMessage_001, TestSize.Level1)
154 {
155 uint32_t type = 0;
156 std::string content = "content";
157 std::string dstDevId = "dstDevId";
158 ASSERT_NE(receiverTrans_, nullptr);
159 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->SendMessage(type, content, dstDevId));
160 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
161 receiverTrans_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
162 EXPECT_EQ(DH_SUCCESS, receiverTrans_->SendMessage(type, content, dstDevId));
163 }
164
165 /**
166 * @tc.name: SetParameter_001
167 * @tc.desc: Verify the SetParameter function.
168 * @tc.type: FUNC
169 * @tc.require: AR000HTAPM
170 */
171 HWTEST_F(AVReceiverEngineTransportTest, SetParameter_001, TestSize.Level1)
172 {
173 AVTransEvent event;
174 std::shared_ptr<AVTransMessage> message = nullptr;
175 std::shared_ptr<AVTransBuffer> buffer = nullptr;
176 ASSERT_NE(receiverTrans_, nullptr);
177 receiverTrans_->OnEngineEvent(event);
178 receiverTrans_->OnEngineMessage(message);
179 receiverTrans_->OnEngineDataAvailable(buffer);
180 AudioParam audioParam;
181 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->SetParameter(audioParam));
182 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
183 EXPECT_EQ(DH_SUCCESS, receiverTrans_->SetParameter(audioParam));
184 }
185 } // namespace DistributedHardware
186 } // namespace OHOS