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 "foundation/multimedia/player_framework/interfaces/inner_api/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 }
87 
88 /**
89  * @tc.name: NormalTest.
90  * @tc.desc: test normal scene of PlayerCallbackImpl.
91  * @tc.type: FUNC.
92  * @tc.require:
93  */
94 HWTEST_F(PlayerAdapterImplTest, NormalTest, TestSize.Level1)
95 {
96     EXPECT_EQ(playerAdapter_->SetPlayerCallback(std::move(callbackTest_)), Media::MSERR_OK);
97     EXPECT_NE(playerAdapter_->SetSource(-1, 0, 0), -1);
98     EXPECT_NE(playerAdapter_->SetSource(sourceUrl_), -1);
99 
100     auto surfaceAdapter = OhosAdapterHelper::GetInstance().CreateConsumerSurfaceAdapter();
101     EXPECT_NE(surfaceAdapter, nullptr);
102     EXPECT_NE(playerAdapter_->SetVideoSurface(std::move(surfaceAdapter)), -1);
103     EXPECT_NE(playerAdapter_->PrepareAsync(), -1);
104     EXPECT_EQ(playerAdapter_->SetVolume(0, 0), Media::MSERR_OK);
105     EXPECT_NE(playerAdapter_->Seek(0, PlayerSeekMode::SEEK_CLOSEST_SYNC), -1);
106     EXPECT_NE(playerAdapter_->Play(), -1);
107     EXPECT_NE(playerAdapter_->Pause(), -1);
108     EXPECT_NE(playerAdapter_->GetCurrentTime(currentTime_), -1);
109     EXPECT_NE(playerAdapter_->GetDuration(duration_), -1);
110     EXPECT_NE(playerAdapter_->SetPlaybackSpeed(PlaybackRateMode::SPEED_FORWARD_1_00_X), -1);
111 }
112 
113 /**
114  * @tc.name: ModeConvertTest.
115  * @tc.desc: test seek() and SetPlaybackSpeed() in different mode.
116  * @tc.type: FUNC.
117  * @tc.require:
118  */
119 HWTEST_F(PlayerAdapterImplTest, ModeConvertTest, TestSize.Level1)
120 {
121     const std::array seekModeArray = { PlayerSeekMode::SEEK_NEXT_SYNC, PlayerSeekMode::SEEK_PREVIOUS_SYNC,
122         PlayerSeekMode::SEEK_CLOSEST_SYNC, PlayerSeekMode::SEEK_CLOSEST };
123     const std::array rateModeArray = { PlaybackRateMode::SPEED_FORWARD_0_75_X, PlaybackRateMode::SPEED_FORWARD_1_00_X,
124         PlaybackRateMode::SPEED_FORWARD_1_25_X, PlaybackRateMode::SPEED_FORWARD_1_75_X,
125         PlaybackRateMode::SPEED_FORWARD_2_00_X };
126 
127     for (PlayerSeekMode mode : seekModeArray) {
128         EXPECT_NE(playerAdapter_->Seek(0, mode), -1);
129     }
130     for (PlaybackRateMode mode : rateModeArray) {
131         EXPECT_NE(playerAdapter_->SetPlaybackSpeed(mode), -1);
132     }
133 }
134 
135 class PlayerCallbackImplTest : public testing::Test {
136 protected:
137     PlayerCallbackImplTest();
138     std::shared_ptr<PlayerCallbackImpl> playerCallback_ = nullptr;
139     Media::Format infoBody_;
140     const std::string errorMsg_ = "test";
141 };
142 
PlayerCallbackImplTest()143 PlayerCallbackImplTest::PlayerCallbackImplTest()
144 {
145     auto callbackTest = std::make_unique<PlayerCallbackTest>();
146     EXPECT_NE(callbackTest, nullptr);
147     playerCallback_ = std::make_shared<PlayerCallbackImpl>(std::move(callbackTest));
148     EXPECT_NE(playerCallback_, nullptr);
149     EXPECT_NE(playerCallback_->callbackAdapter_, nullptr);
150 }
151 
152 /**
153  * @tc.name: InvalidScene.
154  * @tc.desc: test invalid scene of PlayerCallbackImpl.
155  * @tc.type: FUNC.
156  * @tc.require:
157  */
158 HWTEST_F(PlayerCallbackImplTest, InvalidScene, TestSize.Level1)
159 {
160     ASSERT_NE(playerCallback_, nullptr);
161     auto callbackImpl = static_cast<PlayerCallbackTest*>(playerCallback_->callbackAdapter_.get());
162     playerCallback_->OnInfo(Media::INFO_TYPE_ERROR_MSG, 0, infoBody_);
163     EXPECT_EQ(callbackImpl->infoType_, PlayerOnInfoType::INFO_TYPE_UNSET);
164     playerCallback_->OnError(Media::MSERR_EXT_OK, errorMsg_);
165     EXPECT_EQ(callbackImpl->errorType_, PlayerAdapterErrorType::INVALID_CODE);
166 
167     playerCallback_->callbackAdapter_ = nullptr;
168     playerCallback_->OnInfo(Media::INFO_TYPE_EOS, 0, infoBody_);
169     playerCallback_->OnError(Media::MSERR_EXT_OK, errorMsg_);
170 }
171 
172 class PlayerCallbackOnErrorParamTest : public PlayerCallbackImplTest,
173                                        public testing::WithParamInterface<std::tuple<PlayerAdapterErrorType, int32_t>> {
174 };
175 
176 /**
177  * @tc.name: NormalTest.
178  * @tc.desc: Value-Parameterized test of PlayerCallbackImpl::OnError().
179  * @tc.type: FUNC.
180  * @tc.require:
181  */
182 HWTEST_P(PlayerCallbackOnErrorParamTest, NormalTest, TestSize.Level1)
183 {
184     ASSERT_NE(playerCallback_, nullptr);
185     PlayerAdapterErrorType errorType = PlayerAdapterErrorType::INVALID_CODE;
186     int32_t errorCode = 0;
187     playerCallback_->OnError(errorCode, errorMsg_);
188     EXPECT_EQ(static_cast<PlayerCallbackTest*>(playerCallback_->callbackAdapter_.get())->errorType_, errorType);
189 }
190 
191 INSTANTIATE_TEST_SUITE_P(UnsupportTypeTest, PlayerCallbackOnErrorParamTest,
192     testing::Combine(testing::Values(PlayerAdapterErrorType::UNSUPPORT_TYPE),
193         testing::Range(
194             static_cast<int32_t>(Media::MSERR_UNSUPPORT), static_cast<int32_t>(Media::MSERR_UNSUPPORT_SOURCE) + 1)));
195 
196 constexpr int32_t fatalError[] = { Media::MSERR_EXT_NO_MEMORY, Media::MSERR_EXT_SERVICE_DIED,
197     Media::MSERR_CREATE_PLAYER_ENGINE_FAILED, Media::MSERR_CREATE_AVMETADATAHELPER_ENGINE_FAILED,
198     Media::MSERR_AUD_DEC_FAILED, Media::MSERR_VID_DEC_FAILED, Media::MSERR_FILE_ACCESS_FAILED };
199 
200 INSTANTIATE_TEST_SUITE_P(FatalErrorTest, PlayerCallbackOnErrorParamTest,
201     testing::Combine(testing::Values(PlayerAdapterErrorType::FATAL_ERROR), testing::ValuesIn(fatalError)));
202 
203 INSTANTIATE_TEST_SUITE_P(InvalidTypeTest, PlayerCallbackOnErrorParamTest,
204     testing::Combine(testing::Values(PlayerAdapterErrorType::INVALID_CODE),
205         testing::Range(static_cast<int32_t>(Media::MSERR_START_FAILED),
206             static_cast<int32_t>(Media::MSERR_DATA_SOURCE_ERROR_UNKNOWN))));
207 
208 class PlayerCallbackOnInfoParamTest : public PlayerCallbackImplTest,
209                                       public testing::WithParamInterface<Media::PlayerOnInfoType> {};
210 
211 /**
212  * @tc.name: NormalTest.
213  * @tc.desc: Value-Parameterized test of PlayerCallbackImpl::OnInfo().
214  * @tc.type: FUNC.
215  * @tc.require:
216  */
217 HWTEST_P(PlayerCallbackOnInfoParamTest, NormalTest, TestSize.Level1)
218 {
219     ASSERT_NE(playerCallback_, nullptr);
220     Media::PlayerOnInfoType infoType = GetParam();
221     playerCallback_->OnInfo(infoType, 0, infoBody_);
222     EXPECT_NE(static_cast<PlayerCallbackTest*>(playerCallback_->callbackAdapter_.get())->infoType_,
223         PlayerOnInfoType::INFO_TYPE_UNSET);
224 }
225 
226 INSTANTIATE_TEST_SUITE_P(NormalTest, PlayerCallbackOnInfoParamTest,
227     testing::Values(Media::INFO_TYPE_SEEKDONE, Media::INFO_TYPE_EOS, Media::INFO_TYPE_STATE_CHANGE,
228         Media::INFO_TYPE_POSITION_UPDATE, Media::INFO_TYPE_MESSAGE));
229 } // namespace OHOS::NWeb
230