1 /*
2 * Copyright (C) 2024 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 #include "gtest/gtest.h"
16 #include "media_unils_unit_test.h"
17
18 using namespace OHOS;
19 using namespace OHOS::Media;
20 using namespace std;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Media {
SetUpTestCase(void)25 void MediaUtilsUnitTest::SetUpTestCase(void) {}
26
TearDownTestCase(void)27 void MediaUtilsUnitTest::TearDownTestCase(void) {}
28
SetUp(void)29 void MediaUtilsUnitTest::SetUp(void) {}
30
TearDown(void)31 void MediaUtilsUnitTest::TearDown(void) {}
32
33 HWTEST_F(MediaUtilsUnitTest, TransStatus_001, TestSize.Level0) {
34 EXPECT_EQ(TransStatus(Status::ERROR_INVALID_BUFFER_ID), MSERR_UNKNOWN);
35 }
36
37 // Scenario1: Test for PlayerStateId::IDLE
38 HWTEST_F(MediaUtilsUnitTest, TransStateId2PlayerState_ShouldReturnPlayerIdle_WhenStateIsIdle, TestSize.Level0)
39 {
40 PlayerStateId state = PlayerStateId::IDLE;
41 PlayerStates expectedState = PLAYER_IDLE;
42 EXPECT_EQ(expectedState, TransStateId2PlayerState(state));
43 }
44
45 // Scenario2: Test for PlayerStateId::INIT
46 HWTEST_F(MediaUtilsUnitTest, TransStateId2PlayerState_ShouldReturnPlayerInitialized_WhenStateIsInit, TestSize.Level0)
47 {
48 PlayerStateId state = PlayerStateId::INIT;
49 PlayerStates expectedState = PLAYER_INITIALIZED;
50 EXPECT_EQ(expectedState, TransStateId2PlayerState(state));
51 }
52
53 // Scenario3: Test for PlayerStateId::PREPARING
54 HWTEST_F(MediaUtilsUnitTest, TransStateId2PlayerState_ShouldReturnPlayerPreparing_WhenStateIsPreparing, TestSize.Level0)
55 {
56 PlayerStateId state = PlayerStateId::PREPARING;
57 PlayerStates expectedState = PLAYER_PREPARING;
58 EXPECT_EQ(expectedState, TransStateId2PlayerState(state));
59 }
60
61 // Scenario4: Test for PlayerStateId::READY
62 HWTEST_F(MediaUtilsUnitTest, TransStateId2PlayerState_ShouldReturnPlayerPrepared_WhenStateIsReady, TestSize.Level0)
63 {
64 PlayerStateId state = PlayerStateId::READY;
65 PlayerStates expectedState = PLAYER_PREPARED;
66 EXPECT_EQ(expectedState, TransStateId2PlayerState(state));
67 }
68
69 // Scenario5: Test for PlayerStateId::PAUSE
70 HWTEST_F(MediaUtilsUnitTest, TransStateId2PlayerState_ShouldReturnPlayerPaused_WhenStateIsPause, TestSize.Level0)
71 {
72 PlayerStateId state = PlayerStateId::PAUSE;
73 PlayerStates expectedState = PLAYER_PAUSED;
74 EXPECT_EQ(expectedState, TransStateId2PlayerState(state));
75 }
76
77 // Scenario6: Test for PlayerStateId::PLAYING
78 HWTEST_F(MediaUtilsUnitTest, TransStateId2PlayerState_ShouldReturnPlayerStarted_WhenStateIsPlaying, TestSize.Level0)
79 {
80 PlayerStateId state = PlayerStateId::PLAYING;
81 PlayerStates expectedState = PLAYER_STARTED;
82 EXPECT_EQ(expectedState, TransStateId2PlayerState(state));
83 }
84
85 // Scenario7: Test for PlayerStateId::STOPPED
86 HWTEST_F(MediaUtilsUnitTest, TransStateId2PlayerState_ShouldReturnPlayerStopped_WhenStateIsStopped, TestSize.Level0)
87 {
88 PlayerStateId state = PlayerStateId::STOPPED;
89 PlayerStates expectedState = PLAYER_STOPPED;
90 EXPECT_EQ(expectedState, TransStateId2PlayerState(state));
91 }
92
93 // Scenario8: Test for PlayerStateId::EOS
94 HWTEST_F(MediaUtilsUnitTest,
95 TransStateId2PlayerState_ShouldReturnPlayerPlaybackComplete_WhenStateIsEOS, TestSize.Level0)
96 {
97 PlayerStateId state = PlayerStateId::EOS;
98 PlayerStates expectedState = PLAYER_PLAYBACK_COMPLETE;
99 EXPECT_EQ(expectedState, TransStateId2PlayerState(state));
100 }
101
102 // Scenario9: Test for default case
103 HWTEST_F(MediaUtilsUnitTest, TransStateId2PlayerState_ShouldReturnPlayerError_WhenStateIsInvalid, TestSize.Level0)
104 {
105 PlayerStateId state = static_cast<PlayerStateId>(100); // Assuming 100 is an invalid state
106 PlayerStates expectedState = PLAYER_STATE_ERROR;
107 EXPECT_EQ(expectedState, TransStateId2PlayerState(state));
108 }
109
110 // Scenario1: Test case for PlayerSeekMode::SEEK_NEXT_SYNC
111 HWTEST_F(MediaUtilsUnitTest, ShouldReturnSeekNextSync_WhenSeekModeIsNextSync, TestSize.Level0) {
112 EXPECT_EQ(Plugins::SeekMode::SEEK_NEXT_SYNC, Transform2SeekMode(PlayerSeekMode::SEEK_NEXT_SYNC));
113 }
114
115 // Scenario2: Test case for PlayerSeekMode::SEEK_PREVIOUS_SYNC
116 HWTEST_F(MediaUtilsUnitTest, ShouldReturnSeekPreviousSync_WhenSeekModeIsPreviousSync, TestSize.Level0) {
117 EXPECT_EQ(Plugins::SeekMode::SEEK_PREVIOUS_SYNC, Transform2SeekMode(PlayerSeekMode::SEEK_PREVIOUS_SYNC));
118 }
119
120 // Scenario3: Test case for PlayerSeekMode::SEEK_CLOSEST_SYNC
121 HWTEST_F(MediaUtilsUnitTest, ShouldReturnSeekClosestSync_WhenSeekModeIsClosestSync, TestSize.Level0) {
122 EXPECT_EQ(Plugins::SeekMode::SEEK_CLOSEST_SYNC, Transform2SeekMode(PlayerSeekMode::SEEK_CLOSEST_SYNC));
123 }
124
125 // Scenario4: Test case for PlayerSeekMode::SEEK_CLOSEST
126 HWTEST_F(MediaUtilsUnitTest, ShouldReturnSeekClosest_WhenSeekModeIsClosest, TestSize.Level0) {
127 EXPECT_EQ(Plugins::SeekMode::SEEK_CLOSEST, Transform2SeekMode(PlayerSeekMode::SEEK_CLOSEST));
128 }
129
130 // Scenario5: Test case for default case
131 HWTEST_F(MediaUtilsUnitTest, ShouldReturnSeekClosest_WhenSeekModeIsDefault, TestSize.Level0) {
132 EXPECT_EQ(Plugins::SeekMode::SEEK_CLOSEST, Transform2SeekMode(static_cast<PlayerSeekMode>(-1)));
133 }
134 } // namespace Media
135 } // namespace OHOS