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 "none_mix_engine.h" 17 18 using namespace testing::ext; 19 namespace OHOS { 20 namespace AudioStandard { 21 class AudioThreadTaskUnitTest : public testing::Test { 22 public: 23 static void SetUpTestCase(void); 24 static void TearDownTestCase(void); 25 void SetUp(); 26 void TearDown(); 27 }; 28 29 /** 30 * @tc.name : Test Start API 31 * @tc.type : FUNC 32 * @tc.number: Start_001 33 * @tc.desc : Test Start interface. 34 */ 35 HWTEST(AudioThreadTaskUnitTest, Start_001, TestSize.Level1) 36 { 37 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 38 audioThreadTask->state_ = AudioThreadTask::RunningState::STARTED; 39 audioThreadTask->Start(); 40 EXPECT_EQ(audioThreadTask->state_, AudioThreadTask::RunningState::STARTED); 41 } 42 43 /** 44 * @tc.name : Test StopAsync API 45 * @tc.type : FUNC 46 * @tc.number: StopAsync_001 47 * @tc.desc : Test StopAsync interface. 48 */ 49 HWTEST(AudioThreadTaskUnitTest, StopAsync_001, TestSize.Level1) 50 { 51 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 52 audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPED; 53 audioThreadTask->StopAsync(); 54 EXPECT_EQ(audioThreadTask->state_, AudioThreadTask::RunningState::STOPPED); 55 } 56 57 /** 58 * @tc.name : Test StopAsync API 59 * @tc.type : FUNC 60 * @tc.number: StopAsync_002 61 * @tc.desc : Test StopAsync interface. 62 */ 63 HWTEST(AudioThreadTaskUnitTest, StopAsync_002, TestSize.Level1) 64 { 65 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 66 audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPING; 67 audioThreadTask->StopAsync(); 68 EXPECT_EQ(audioThreadTask->state_, AudioThreadTask::RunningState::STOPPING); 69 } 70 71 /** 72 * @tc.name : Test StopAsync API 73 * @tc.type : FUNC 74 * @tc.number: StopAsync_003 75 * @tc.desc : Test StopAsync interface. 76 */ 77 HWTEST(AudioThreadTaskUnitTest, StopAsync_003, TestSize.Level1) 78 { 79 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 80 audioThreadTask->state_ = AudioThreadTask::RunningState::STARTED; 81 audioThreadTask->StopAsync(); 82 EXPECT_EQ(audioThreadTask->state_, AudioThreadTask::RunningState::STOPPING); 83 } 84 85 /** 86 * @tc.name : Test Pause API 87 * @tc.type : FUNC 88 * @tc.number: Pause_001 89 * @tc.desc : Test Pause interface. 90 */ 91 HWTEST(AudioThreadTaskUnitTest, Pause_001, TestSize.Level1) 92 { 93 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 94 audioThreadTask->state_ = AudioThreadTask::RunningState::PAUSED; 95 audioThreadTask->Pause(); 96 EXPECT_EQ(audioThreadTask->state_, AudioThreadTask::RunningState::PAUSED); 97 } 98 99 /** 100 * @tc.name : Test PauseAsync API 101 * @tc.type : FUNC 102 * @tc.number: PauseAsync_001 103 * @tc.desc : Test PauseAsync interface. 104 */ 105 HWTEST(AudioThreadTaskUnitTest, PauseAsync_001, TestSize.Level1) 106 { 107 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 108 audioThreadTask->state_ = AudioThreadTask::RunningState::PAUSED; 109 audioThreadTask->PauseAsync(); 110 EXPECT_EQ(audioThreadTask->state_, AudioThreadTask::RunningState::PAUSED); 111 } 112 113 /** 114 * @tc.name : Test PauseAsync API 115 * @tc.type : FUNC 116 * @tc.number: PauseAsync_002 117 * @tc.desc : Test PauseAsync interface. 118 */ 119 HWTEST(AudioThreadTaskUnitTest, PauseAsync_002, TestSize.Level1) 120 { 121 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 122 audioThreadTask->state_ = AudioThreadTask::RunningState::STARTED; 123 audioThreadTask->PauseAsync(); 124 EXPECT_EQ(audioThreadTask->state_, AudioThreadTask::RunningState::PAUSING); 125 } 126 127 /** 128 * @tc.name : Test Start API 129 * @tc.type : FUNC 130 * @tc.number: Start_002 131 * @tc.desc : Test Start interface. 132 */ 133 HWTEST(AudioThreadTaskUnitTest, Start_002, TestSize.Level1) 134 { 135 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 136 audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPED; 137 audioThreadTask->Start(); 138 EXPECT_EQ(audioThreadTask->state_, AudioThreadTask::RunningState::STARTED); 139 } 140 141 /** 142 * @tc.name : Test Start API 143 * @tc.type : FUNC 144 * @tc.number: Start_003 145 * @tc.desc : Test Start interface. 146 */ 147 HWTEST(AudioThreadTaskUnitTest, Start_003, TestSize.Level1) 148 { 149 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 150 audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPED; __anon46cde1650102null151 audioThreadTask->loop_ = std::make_unique<std::thread>([&] {}); 152 audioThreadTask->Start(); 153 EXPECT_NE(audioThreadTask->loop_, nullptr); 154 } 155 156 /** 157 * @tc.name : Test Start API 158 * @tc.type : FUNC 159 * @tc.number: Start_004 160 * @tc.desc : Test Start interface. 161 */ 162 HWTEST(AudioThreadTaskUnitTest, Start_004, TestSize.Level1) 163 { 164 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 165 audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPED; 166 std::thread joinableThread; 167 audioThreadTask->loop_ = std::make_unique<std::thread>(std::move(joinableThread)); 168 audioThreadTask->Start(); 169 EXPECT_NE(audioThreadTask->loop_, nullptr); 170 } 171 172 /** 173 * @tc.name : Test Start API 174 * @tc.type : FUNC 175 * @tc.number: Start_005 176 * @tc.desc : Test Start interface. 177 */ 178 HWTEST(AudioThreadTaskUnitTest, Start_005, TestSize.Level1) 179 { 180 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 181 audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPED; __anon46cde1650202null182 audioThreadTask->loop_ = std::make_unique<std::thread>([&] {}); 183 audioThreadTask->Start(); 184 EXPECT_NE(audioThreadTask->loop_, nullptr); 185 } 186 187 /** 188 * @tc.name : Test Start API 189 * @tc.type : FUNC 190 * @tc.number: Start_006 191 * @tc.desc : Test Start interface. 192 */ 193 HWTEST(AudioThreadTaskUnitTest, Start_006, TestSize.Level1) 194 { 195 std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test"); 196 audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPED; 197 audioThreadTask->Start(); 198 EXPECT_NE(audioThreadTask->loop_, nullptr); 199 } 200 } // namespace AudioStandard 201 } // namespace OHOS