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 "../native/media_errors.h"
17 #include "gtest/gtest.h"
18 #define private public
19 #include "player_framework_adapter_impl.h"
20 #undef private
21 #include "ohos_adapter_helper.h"
22
23 using testing::ext::TestSize;
24
25 namespace OHOS::NWeb {
26 class PlayerCallbackTest : public PlayerCallbackAdapter {
27 public:
28 PlayerCallbackTest() = default;
29 ~PlayerCallbackTest() override = default;
OnInfo(PlayerOnInfoType type,int32_t extra,int32_t value)30 void OnInfo(PlayerOnInfoType type, int32_t extra, int32_t value) override
31 {
32 infoType_ = type;
33 }
OnError(PlayerAdapterErrorType errorType)34 void OnError(PlayerAdapterErrorType errorType) override
35 {
36 errorType_ = errorType;
37 }
38 PlayerOnInfoType infoType_ = PlayerOnInfoType::INFO_TYPE_UNSET;
39 PlayerAdapterErrorType errorType_ = PlayerAdapterErrorType::INVALID_CODE;
40 };
41
42 class PlayerAdapterImplTest : public testing::Test {
43 protected:
44 void SetUp() override;
45 std::unique_ptr<PlayerAdapterImpl> playerAdapter_ = nullptr;
46 std::unique_ptr<PlayerCallbackTest> callbackTest_ = nullptr;
47 const std::string sourceUrl_ = "sourcetest.mp3";
48 int32_t currentTime_ = 0;
49 int32_t duration_ = 0;
50 };
51
SetUp()52 void PlayerAdapterImplTest::SetUp()
53 {
54 EXPECT_EQ(playerAdapter_, nullptr);
55 playerAdapter_ = std::make_unique<PlayerAdapterImpl>();
56 ASSERT_NE(playerAdapter_, nullptr);
57 ASSERT_NE(playerAdapter_->player_, nullptr);
58 callbackTest_ = std::make_unique<PlayerCallbackTest>();
59 EXPECT_NE(callbackTest_, nullptr);
60 }
61
62 /**
63 * @tc.name: HandlesInvalidArguments.
64 * @tc.desc: test invalid scene of PlayerCallbackImpl.
65 * @tc.type: FUNC.
66 * @tc.require:
67 */
68 HWTEST_F(PlayerAdapterImplTest, HandlesInvalidArguments, TestSize.Level1)
69 {
70 EXPECT_EQ(playerAdapter_->SetPlayerCallback(nullptr), -1);
71 EXPECT_EQ(playerAdapter_->SetVideoSurface(nullptr), -1);
72
73 playerAdapter_->player_ = nullptr;
74 EXPECT_EQ(playerAdapter_->SetPlayerCallback(nullptr), -1);
75 EXPECT_EQ(playerAdapter_->SetSource(sourceUrl_), -1);
76 EXPECT_EQ(playerAdapter_->SetSource(0, 0, 0), -1);
77 EXPECT_EQ(playerAdapter_->SetVideoSurface(nullptr), -1);
78 EXPECT_EQ(playerAdapter_->SetVolume(0, 0), -1);
79 EXPECT_EQ(playerAdapter_->Seek(0, PlayerSeekMode::SEEK_CLOSEST_SYNC), -1);
80 EXPECT_EQ(playerAdapter_->Play(), -1);
81 EXPECT_EQ(playerAdapter_->Pause(), -1);
82 EXPECT_EQ(playerAdapter_->PrepareAsync(), -1);
83 EXPECT_EQ(playerAdapter_->GetCurrentTime(currentTime_), -1);
84 EXPECT_EQ(playerAdapter_->GetDuration(duration_), -1);
85 EXPECT_EQ(playerAdapter_->SetPlaybackSpeed(PlaybackRateMode::SPEED_FORWARD_1_00_X), -1);
86 std::map<std::string, std::string> header;
87 EXPECT_EQ(playerAdapter_->SetMediaSourceHeader(sourceUrl_, header), -1);
88 }
89
90 /**
91 * @tc.name: NormalTest.
92 * @tc.desc: test normal scene of PlayerCallbackImpl.
93 * @tc.type: FUNC.
94 * @tc.require:
95 */
96 HWTEST_F(PlayerAdapterImplTest, NormalTest, TestSize.Level1)
97 {
98 EXPECT_EQ(playerAdapter_->SetPlayerCallback(std::move(callbackTest_)), Media::MSERR_OK);
99 EXPECT_NE(playerAdapter_->SetSource(-1, 0, 0), -1);
100 EXPECT_NE(playerAdapter_->SetSource(sourceUrl_), -1);
101
102 auto surfaceAdapter = OhosAdapterHelper::GetInstance().CreateConsumerSurfaceAdapter();
103 EXPECT_NE(surfaceAdapter, nullptr);
104 EXPECT_NE(playerAdapter_->SetVideoSurface(std::move(surfaceAdapter)), -1);
105 EXPECT_NE(playerAdapter_->PrepareAsync(), -1);
106 EXPECT_EQ(playerAdapter_->SetVolume(0, 0), Media::MSERR_OK);
107 EXPECT_NE(playerAdapter_->Seek(0, PlayerSeekMode::SEEK_CLOSEST_SYNC), -1);
108 EXPECT_NE(playerAdapter_->Play(), -1);
109 EXPECT_NE(playerAdapter_->Pause(), -1);
110 EXPECT_NE(playerAdapter_->GetCurrentTime(currentTime_), -1);
111 EXPECT_NE(playerAdapter_->GetDuration(duration_), -1);
112 EXPECT_NE(playerAdapter_->SetPlaybackSpeed(PlaybackRateMode::SPEED_FORWARD_1_00_X), -1);
113 std::map<std::string, std::string> header;
114 EXPECT_NE(playerAdapter_->SetMediaSourceHeader(sourceUrl_, header), -1);
115 }
116
117 /**
118 * @tc.name: ModeConvertTest.
119 * @tc.desc: test seek() and SetPlaybackSpeed() in different mode.
120 * @tc.type: FUNC.
121 * @tc.require:
122 */
123 HWTEST_F(PlayerAdapterImplTest, ModeConvertTest, TestSize.Level1)
124 {
125 const std::array seekModeArray = { PlayerSeekMode::SEEK_NEXT_SYNC, PlayerSeekMode::SEEK_PREVIOUS_SYNC,
126 PlayerSeekMode::SEEK_CLOSEST_SYNC, PlayerSeekMode::SEEK_CLOSEST };
127 const std::array rateModeArray = { PlaybackRateMode::SPEED_FORWARD_0_75_X, PlaybackRateMode::SPEED_FORWARD_1_00_X,
128 PlaybackRateMode::SPEED_FORWARD_1_25_X, PlaybackRateMode::SPEED_FORWARD_1_75_X,
129 PlaybackRateMode::SPEED_FORWARD_2_00_X };
130
131 for (PlayerSeekMode mode : seekModeArray) {
132 EXPECT_NE(playerAdapter_->Seek(0, mode), -1);
133 }
134 for (PlaybackRateMode mode : rateModeArray) {
135 EXPECT_NE(playerAdapter_->SetPlaybackSpeed(mode), -1);
136 }
137 }
138
139 class PlayerCallbackImplTest : public testing::Test {
140 protected:
141 PlayerCallbackImplTest();
142 std::shared_ptr<PlayerCallbackImpl> playerCallback_ = nullptr;
143 Media::Format infoBody_;
144 const std::string errorMsg_ = "test";
145 };
146
PlayerCallbackImplTest()147 PlayerCallbackImplTest::PlayerCallbackImplTest()
148 {
149 auto callbackTest = std::make_unique<PlayerCallbackTest>();
150 EXPECT_NE(callbackTest, nullptr);
151 playerCallback_ = std::make_shared<PlayerCallbackImpl>(std::move(callbackTest));
152 EXPECT_NE(playerCallback_, nullptr);
153 EXPECT_NE(playerCallback_->callbackAdapter_, nullptr);
154 }
155
156 /**
157 * @tc.name: InvalidScene.
158 * @tc.desc: test invalid scene of PlayerCallbackImpl.
159 * @tc.type: FUNC.
160 * @tc.require:
161 */
162 HWTEST_F(PlayerCallbackImplTest, InvalidScene, TestSize.Level1)
163 {
164 ASSERT_NE(playerCallback_, nullptr);
165 auto callbackImpl = static_cast<PlayerCallbackTest*>(playerCallback_->callbackAdapter_.get());
166 playerCallback_->OnInfo(Media::INFO_TYPE_ERROR_MSG, 0, infoBody_);
167 EXPECT_EQ(callbackImpl->infoType_, PlayerOnInfoType::INFO_TYPE_UNSET);
168 playerCallback_->OnError(Media::MSERR_EXT_OK, errorMsg_);
169 EXPECT_EQ(callbackImpl->errorType_, PlayerAdapterErrorType::INVALID_CODE);
170
171 playerCallback_->callbackAdapter_ = nullptr;
172 playerCallback_->OnInfo(Media::INFO_TYPE_EOS, 0, infoBody_);
173 playerCallback_->OnError(Media::MSERR_EXT_OK, errorMsg_);
174 }
175
176 class PlayerCallbackOnErrorParamTest : public PlayerCallbackImplTest,
177 public testing::WithParamInterface<std::tuple<PlayerAdapterErrorType, int32_t>> {
178 };
179
180 /**
181 * @tc.name: NormalTest.
182 * @tc.desc: Value-Parameterized test of PlayerCallbackImpl::OnError().
183 * @tc.type: FUNC.
184 * @tc.require:
185 */
186 HWTEST_P(PlayerCallbackOnErrorParamTest, NormalTest, TestSize.Level1)
187 {
188 ASSERT_NE(playerCallback_, nullptr);
189 PlayerAdapterErrorType errorType = PlayerAdapterErrorType::INVALID_CODE;
190 int32_t errorCode = 0;
191 playerCallback_->OnError(errorCode, errorMsg_);
192 EXPECT_EQ(static_cast<PlayerCallbackTest*>(playerCallback_->callbackAdapter_.get())->errorType_, errorType);
193 }
194
195 INSTANTIATE_TEST_SUITE_P(UnsupportTypeTest, PlayerCallbackOnErrorParamTest,
196 testing::Combine(testing::Values(PlayerAdapterErrorType::UNSUPPORT_TYPE),
197 testing::Range(
198 static_cast<int32_t>(Media::MSERR_UNSUPPORT), static_cast<int32_t>(Media::MSERR_UNSUPPORT_SOURCE) + 1)));
199
200 constexpr int32_t fatalError[] = { Media::MSERR_EXT_NO_MEMORY, Media::MSERR_EXT_SERVICE_DIED,
201 Media::MSERR_CREATE_PLAYER_ENGINE_FAILED, Media::MSERR_CREATE_AVMETADATAHELPER_ENGINE_FAILED,
202 Media::MSERR_AUD_DEC_FAILED, Media::MSERR_VID_DEC_FAILED, Media::MSERR_FILE_ACCESS_FAILED };
203
204 INSTANTIATE_TEST_SUITE_P(FatalErrorTest, PlayerCallbackOnErrorParamTest,
205 testing::Combine(testing::Values(PlayerAdapterErrorType::FATAL_ERROR), testing::ValuesIn(fatalError)));
206
207 INSTANTIATE_TEST_SUITE_P(InvalidTypeTest, PlayerCallbackOnErrorParamTest,
208 testing::Combine(testing::Values(PlayerAdapterErrorType::INVALID_CODE),
209 testing::Range(static_cast<int32_t>(Media::MSERR_START_FAILED),
210 static_cast<int32_t>(Media::MSERR_DATA_SOURCE_ERROR_UNKNOWN))));
211
212 class PlayerCallbackOnInfoParamTest : public PlayerCallbackImplTest,
213 public testing::WithParamInterface<Media::PlayerOnInfoType> {};
214
215 /**
216 * @tc.name: NormalTest.
217 * @tc.desc: Value-Parameterized test of PlayerCallbackImpl::OnInfo().
218 * @tc.type: FUNC.
219 * @tc.require:
220 */
221 HWTEST_P(PlayerCallbackOnInfoParamTest, NormalTest, TestSize.Level1)
222 {
223 ASSERT_NE(playerCallback_, nullptr);
224 Media::PlayerOnInfoType infoType = GetParam();
225 playerCallback_->OnInfo(infoType, 0, infoBody_);
226 EXPECT_NE(static_cast<PlayerCallbackTest*>(playerCallback_->callbackAdapter_.get())->infoType_,
227 PlayerOnInfoType::INFO_TYPE_UNSET);
228 }
229
230 INSTANTIATE_TEST_SUITE_P(NormalTest, PlayerCallbackOnInfoParamTest,
231 testing::Values(Media::INFO_TYPE_SEEKDONE, Media::INFO_TYPE_EOS, Media::INFO_TYPE_STATE_CHANGE,
232 Media::INFO_TYPE_POSITION_UPDATE, Media::INFO_TYPE_MESSAGE));
233 } // namespace OHOS::NWeb
234