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 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK));
55 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
56 EXPECT_EQ(DH_SUCCESS, receiverTrans_->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(AVReceiverEngineTransportTest, InitEngine_001, TestSize.Level1)
66 {
67 IAVEngineProvider *providerPtr = nullptr;
68 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->InitEngine(providerPtr));
69 EXPECT_EQ(DH_SUCCESS, receiverTrans_->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(AVReceiverEngineTransportTest, CreateCtrl_001, TestSize.Level1)
79 {
80 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->CreateCtrl());
81 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
82 receiverTrans_->receiverAdapter_->chnCreateSuccess_ = true;
83 EXPECT_EQ(DH_SUCCESS, receiverTrans_->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(AVReceiverEngineTransportTest, Start_001, TestSize.Level1)
93 {
94 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->Start());
95 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->Stop());
96 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->Release());
97 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
98 receiverTrans_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
99 EXPECT_EQ(DH_SUCCESS, receiverTrans_->Start());
100 EXPECT_EQ(DH_SUCCESS, receiverTrans_->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(AVReceiverEngineTransportTest, 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, receiverTrans_->Restart(localParam, remoteParam));
116 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Pause());
117 EXPECT_EQ(DH_SUCCESS, receiverTrans_->FeedAudioData(audioData));
118 }
119
120 /**
121 * @tc.name: Pause_002
122 * @tc.desc: Verify the Pause function.
123 * @tc.type: FUNC
124 * @tc.require: AR000HTAPM
125 */
126 HWTEST_F(AVReceiverEngineTransportTest, Pause_002, TestSize.Level1)
127 {
128 AudioParam localParam;
129 AudioParam remoteParam;
130 size_t bufLen = 4096;
131 std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
132 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
133 receiverTrans_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
134 EXPECT_EQ(DH_SUCCESS, receiverTrans_->Restart(localParam, remoteParam));
135 EXPECT_EQ(DH_SUCCESS, receiverTrans_->Pause());
136 EXPECT_EQ(DH_SUCCESS, receiverTrans_->FeedAudioData(audioData));
137 }
138
139 /**
140 * @tc.name: SendMessage_001
141 * @tc.desc: Verify the SendMessage function.
142 * @tc.type: FUNC
143 * @tc.require: AR000HTAPM
144 */
145 HWTEST_F(AVReceiverEngineTransportTest, SendMessage_001, TestSize.Level1)
146 {
147 uint32_t type = 0;
148 std::string content = "content";
149 std::string dstDevId = "dstDevId";
150 EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->SendMessage(type, content, dstDevId));
151 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
152 receiverTrans_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
153 EXPECT_EQ(DH_SUCCESS, receiverTrans_->SendMessage(type, content, dstDevId));
154 }
155
156 /**
157 * @tc.name: SetParameter_001
158 * @tc.desc: Verify the SetParameter function.
159 * @tc.type: FUNC
160 * @tc.require: AR000HTAPM
161 */
162 HWTEST_F(AVReceiverEngineTransportTest, SetParameter_001, TestSize.Level1)
163 {
164 AVTransEvent event;
165 std::shared_ptr<AVTransMessage> message = nullptr;
166 std::shared_ptr<AVTransBuffer> buffer = nullptr;
167 receiverTrans_->OnEngineEvent(event);
168 receiverTrans_->OnEngineMessage(message);
169 receiverTrans_->OnEngineDataAvailable(buffer);
170 AudioParam audioParam;
171 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->SetParameter(audioParam));
172 receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
173 EXPECT_EQ(DH_SUCCESS, receiverTrans_->SetParameter(audioParam));
174 }
175 } // namespace DistributedHardware
176 } // namespace OHOS
177