1 /* 2 * Copyright (c) 2025 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 "audio_policy_state_monitor.h" 17 #include "gtest/gtest.h" 18 #include <vector> 19 20 using namespace testing::ext; 21 22 namespace OHOS { 23 namespace AudioStandard { 24 25 static const std::time_t AUDIO_SESSION_TIME_OUT_DURATION_TEST_S = 3; // 3s 26 27 static const std::shared_ptr<AudioPolicyStateMonitor> g_audioPolicyStateMonitor = 28 DelayedSingleton<AudioPolicyStateMonitor>::GetInstance(); 29 30 class AudioPolicyStateMonitorTest : public testing::Test { 31 public: 32 // SetUp: Called before each test cases SetUp(void)33 void SetUp(void) override 34 { 35 ASSERT_NE(g_audioPolicyStateMonitor, nullptr); 36 ASSERT_EQ(g_audioPolicyStateMonitor->monitoredObj_.size(), 0); 37 for (int32_t i = 0; i < MAX_CB_ID_NUM; i++) { 38 ASSERT_FALSE(g_audioPolicyStateMonitor->idAllocator_[i]); 39 } 40 } 41 }; 42 43 class AudioPolicyStateMonitorCallbackMocker : public AudioPolicyStateMonitorCallback { 44 public: OnTimeOut()45 void OnTimeOut() override 46 {} 47 }; 48 49 /** 50 * @tc.name : OneTimeStateMonitorTest. 51 * @tc.desc : Test for one time state monitor regsitor. 52 */ 53 HWTEST_F(AudioPolicyStateMonitorTest, OneTimeStateMonitorTest, TestSize.Level1) 54 { 55 auto cb = std::make_shared<AudioPolicyStateMonitorCallbackMocker>(); 56 int32_t cbId = g_audioPolicyStateMonitor->RegisterCallback( 57 cb, 58 AUDIO_SESSION_TIME_OUT_DURATION_TEST_S, 59 CallbackType::ONE_TIME); 60 EXPECT_NE(cbId, INVALID_CB_ID); 61 g_audioPolicyStateMonitor->UnRegisterCallback(cbId); 62 EXPECT_EQ(g_audioPolicyStateMonitor->monitoredObj_.size(), 0); 63 } 64 65 /** 66 * @tc.name : OneTimeStateMonitorTest. 67 * @tc.desc : Test for repeat state monitor regsitor. 68 */ 69 HWTEST_F(AudioPolicyStateMonitorTest, RepeatStateMonitorTest, TestSize.Level1) 70 { 71 auto cb = std::make_shared<AudioPolicyStateMonitorCallbackMocker>(); 72 int32_t cbId = g_audioPolicyStateMonitor->RegisterCallback( 73 cb, 74 AUDIO_SESSION_TIME_OUT_DURATION_TEST_S, 75 CallbackType::REPEAT); 76 EXPECT_NE(cbId, INVALID_CB_ID); 77 g_audioPolicyStateMonitor->UnRegisterCallback(cbId); 78 EXPECT_EQ(g_audioPolicyStateMonitor->monitoredObj_.size(), 0); 79 } 80 81 /** 82 * @tc.name : OneTimeStateMonitorTest. 83 * @tc.desc : Test for repeat state monitor regsitor. 84 */ 85 HWTEST_F(AudioPolicyStateMonitorTest, StopStateMonitorSuccessTest, TestSize.Level1) 86 { 87 auto cb = std::make_shared<AudioPolicyStateMonitorCallbackMocker>(); 88 for (int32_t i = 0; i < MAX_CB_ID_NUM; i++) { 89 int32_t cbId = g_audioPolicyStateMonitor->RegisterCallback( 90 cb, 91 AUDIO_SESSION_TIME_OUT_DURATION_TEST_S, 92 CallbackType::REPEAT); 93 EXPECT_NE(cbId, INVALID_CB_ID); 94 } 95 96 int32_t targetCbId = 50; 97 EXPECT_EQ(g_audioPolicyStateMonitor->monitoredObj_.count(targetCbId), 1); 98 g_audioPolicyStateMonitor->UnRegisterCallback(targetCbId); 99 EXPECT_EQ(g_audioPolicyStateMonitor->monitoredObj_.size(), MAX_CB_ID_NUM - 1); 100 EXPECT_EQ(g_audioPolicyStateMonitor->monitoredObj_.count(targetCbId), 0); 101 102 103 for (int32_t i = 0; i < MAX_CB_ID_NUM; i++) { 104 g_audioPolicyStateMonitor->UnRegisterCallback(i); 105 } 106 } 107 108 /** 109 * @tc.name : RegisterMaxNumOfStateMonitorTest. 110 * @tc.desc : Test for max num of state monitor regsitor. 111 */ 112 HWTEST_F(AudioPolicyStateMonitorTest, RegisterMaxNumOfStateMonitorTest, TestSize.Level1) 113 { 114 auto cb = std::make_shared<AudioPolicyStateMonitorCallbackMocker>(); 115 for (int32_t i = 0; i < MAX_CB_ID_NUM; i++) { 116 int32_t cbId = g_audioPolicyStateMonitor->RegisterCallback( 117 cb, 118 AUDIO_SESSION_TIME_OUT_DURATION_TEST_S, 119 CallbackType::REPEAT); 120 EXPECT_NE(cbId, INVALID_CB_ID); 121 EXPECT_EQ(g_audioPolicyStateMonitor->monitoredObj_.size(), i + 1); 122 } 123 124 for (int32_t i = 0; i < MAX_CB_ID_NUM; i++) { 125 g_audioPolicyStateMonitor->UnRegisterCallback(i); 126 EXPECT_EQ(g_audioPolicyStateMonitor->monitoredObj_.size(), MAX_CB_ID_NUM - i - 1); 127 } 128 EXPECT_EQ(g_audioPolicyStateMonitor->monitoredObj_.size(), 0); 129 } 130 131 /** 132 * @tc.name : RegisterStateMonitorFailWithNullThreadTest. 133 * @tc.desc : Test for Register state monitor failed when no thread. 134 */ 135 HWTEST_F(AudioPolicyStateMonitorTest, RegisterStateMonitorFailWithNullThreadTest, TestSize.Level1) 136 { 137 auto cb = std::make_shared<AudioPolicyStateMonitorCallbackMocker>(); 138 std::shared_ptr<std::thread> stateMonitorThreadTemp = g_audioPolicyStateMonitor->stateMonitorThread_; 139 g_audioPolicyStateMonitor->stateMonitorThread_ = nullptr; 140 int32_t cbId = g_audioPolicyStateMonitor->RegisterCallback( 141 cb, 142 AUDIO_SESSION_TIME_OUT_DURATION_TEST_S, 143 CallbackType::ONE_TIME); 144 EXPECT_EQ(cbId, INVALID_CB_ID); 145 g_audioPolicyStateMonitor->UnRegisterCallback(cbId); 146 EXPECT_EQ(g_audioPolicyStateMonitor->monitoredObj_.size(), 0); 147 g_audioPolicyStateMonitor->stateMonitorThread_ = stateMonitorThreadTemp; 148 } 149 150 /** 151 * @tc.name : RegisterStateMonitorFailWithNullCbTest. 152 * @tc.desc : Test for Register state monitor failed with null callback. 153 */ 154 HWTEST_F(AudioPolicyStateMonitorTest, RegisterStateMonitorFailWithNullCbTest, TestSize.Level1) 155 { 156 int32_t cbId = g_audioPolicyStateMonitor->RegisterCallback( 157 nullptr, 158 AUDIO_SESSION_TIME_OUT_DURATION_TEST_S, 159 CallbackType::ONE_TIME); 160 EXPECT_EQ(cbId, INVALID_CB_ID); 161 } 162 163 /** 164 * @tc.name : AudioPolicyStateMonitor_001 165 * @tc.desc : AudioPolicyStateMonitor::FreeCbId 166 */ 167 HWTEST_F(AudioPolicyStateMonitorTest, AudioPolicyStateMonitor_001, TestSize.Level1) 168 { 169 auto audioPolicyStateMonitor = std::make_shared<AudioPolicyStateMonitor>(); 170 EXPECT_NE(audioPolicyStateMonitor, nullptr); 171 172 int32_t cbId = -10; 173 audioPolicyStateMonitor->FreeCbId(cbId); 174 } 175 176 /** 177 * @tc.name : AudioPolicyStateMonitor_002 178 * @tc.desc : AudioPolicyStateMonitor::FreeCbId 179 */ 180 HWTEST_F(AudioPolicyStateMonitorTest, AudioPolicyStateMonitor_002, TestSize.Level1) 181 { 182 auto audioPolicyStateMonitor = std::make_shared<AudioPolicyStateMonitor>(); 183 EXPECT_NE(audioPolicyStateMonitor, nullptr); 184 185 int32_t cbId = 200; 186 audioPolicyStateMonitor->FreeCbId(cbId); 187 } 188 } // AudioStandardnamespace 189 } // OHOSnamespace 190