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_interrupt_unit_test.h"
17 using namespace testing::ext;
18
19 namespace OHOS {
20 namespace AudioStandard {
21
SetUpTestCase(void)22 void AudioInterruptZoneUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)23 void AudioInterruptZoneUnitTest::TearDownTestCase(void) {}
SetUp(void)24 void AudioInterruptZoneUnitTest::SetUp(void) {}
TearDown(void)25 void AudioInterruptZoneUnitTest::TearDown(void) {}
26
27 /**
28 * @tc.name : Test AudioInterruptZoneManager
29 * @tc.number: AudioInterruptZoneManager_001
30 * @tc.desc : Test AudioInterruptZoneManager
31 */
32 HWTEST(AudioInterruptZoneUnitTest, AudioInterruptZoneManager_001, TestSize.Level1)
33 {
34 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
35 ASSERT_NE(audioInterruptZoneManager, nullptr);
36
37 audioInterruptZoneManager->service_ = new AudioInterruptService();
38 ASSERT_NE(audioInterruptZoneManager->service_, nullptr);
39 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
40 audioInterruptZoneManager->service_->zonesMap_.insert({0, audioInterruptZone});
41
42 int32_t zoneId = 5;
43 AudioFocusList focusInfoList;
44
45 auto ret = audioInterruptZoneManager->GetAudioFocusInfoList(zoneId, focusInfoList);
46 EXPECT_EQ(ret, SUCCESS);
47 EXPECT_EQ(focusInfoList.size(), 0);
48 }
49
50 /**
51 * @tc.name : Test AudioInterruptZoneManager
52 * @tc.number: AudioInterruptZoneManager_002
53 * @tc.desc : Test AudioInterruptZoneManager
54 */
55 HWTEST(AudioInterruptZoneUnitTest, AudioInterruptZoneManager_002, TestSize.Level1)
56 {
57 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
58 ASSERT_NE(audioInterruptZoneManager, nullptr);
59
60 audioInterruptZoneManager->service_ = new AudioInterruptService();
61 ASSERT_NE(audioInterruptZoneManager->service_, nullptr);
62 std::shared_ptr<AudioInterruptZone> audioInterruptZone = nullptr;
63 audioInterruptZoneManager->service_->zonesMap_.insert({0, audioInterruptZone});
64
65 int32_t zoneId = 0;
66 AudioFocusList focusInfoList;
67
68 auto ret = audioInterruptZoneManager->GetAudioFocusInfoList(zoneId, focusInfoList);
69 EXPECT_EQ(ret, SUCCESS);
70 EXPECT_EQ(focusInfoList.size(), 0);
71 }
72
73 /**
74 * @tc.name : Test AudioInterruptZoneManager
75 * @tc.number: AudioInterruptZoneManager_003
76 * @tc.desc : Test AudioInterruptZoneManager
77 */
78 HWTEST(AudioInterruptZoneUnitTest, AudioInterruptZoneManager_003, TestSize.Level1)
79 {
80 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
81 ASSERT_NE(audioInterruptZoneManager, nullptr);
82
83 audioInterruptZoneManager->service_ = new AudioInterruptService();
84 ASSERT_NE(audioInterruptZoneManager->service_, nullptr);
85 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
86 AudioInterrupt audioInterrupt;
87 audioInterrupt.deviceTag = "1";
88 AudioFocuState audioFocuState = AudioFocuState::ACTIVE;
89 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
90 audioInterruptZoneManager->service_->zonesMap_.insert({0, audioInterruptZone});
91
92 int32_t zoneId = 0;
93 std::string deviceTag = "1";
94 AudioFocusList focusInfoList;
95
96 auto ret = audioInterruptZoneManager->GetAudioFocusInfoList(zoneId, deviceTag, focusInfoList);
97 EXPECT_EQ(ret, SUCCESS);
98 EXPECT_EQ(focusInfoList.size(), 1);
99 }
100
101 /**
102 * @tc.name : Test AudioInterruptZoneManager
103 * @tc.number: AudioInterruptZoneManager_004
104 * @tc.desc : Test AudioInterruptZoneManager
105 */
106 HWTEST(AudioInterruptZoneUnitTest, AudioInterruptZoneManager_004, TestSize.Level1)
107 {
108 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
109 ASSERT_NE(audioInterruptZoneManager, nullptr);
110
111 audioInterruptZoneManager->service_ = new AudioInterruptService();
112 ASSERT_NE(audioInterruptZoneManager->service_, nullptr);
113 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
114 AudioInterrupt audioInterrupt;
115 audioInterrupt.deviceTag = "1";
116 AudioFocuState audioFocuState = AudioFocuState::ACTIVE;
117 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
118 audioInterruptZoneManager->service_->zonesMap_.insert({0, audioInterruptZone});
119
120 int32_t zoneId = 0;
121 std::string deviceTag = "0";
122 AudioFocusList focusInfoList;
123
124 auto ret = audioInterruptZoneManager->GetAudioFocusInfoList(zoneId, deviceTag, focusInfoList);
125 EXPECT_EQ(ret, SUCCESS);
126 EXPECT_EQ(focusInfoList.size(), 0);
127 }
128
129 /**
130 * @tc.name : Test AudioInterruptZoneManager
131 * @tc.number: AudioInterruptZoneManager_005
132 * @tc.desc : Test AudioInterruptZoneManager
133 */
134 HWTEST(AudioInterruptZoneUnitTest, AudioInterruptZoneManager_005, TestSize.Level1)
135 {
136 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
137 ASSERT_NE(audioInterruptZoneManager, nullptr);
138
139 audioInterruptZoneManager->service_ = new AudioInterruptService();
140 ASSERT_NE(audioInterruptZoneManager->service_, nullptr);
141 std::shared_ptr<AudioInterruptZone> audioInterruptZone = nullptr;
142 audioInterruptZoneManager->service_->zonesMap_.insert({0, audioInterruptZone});
143
144 int32_t zoneId = 0;
145 std::string deviceTag = "0";
146 AudioFocusList focusInfoList;
147
148 auto ret = audioInterruptZoneManager->GetAudioFocusInfoList(zoneId, deviceTag, focusInfoList);
149 EXPECT_EQ(ret, SUCCESS);
150 EXPECT_EQ(focusInfoList.size(), 0);
151 }
152
153 /**
154 * @tc.name : Test AudioInterruptZoneManager
155 * @tc.number: AudioInterruptZoneManager_006
156 * @tc.desc : Test AudioInterruptZoneManager
157 */
158 HWTEST(AudioInterruptZoneUnitTest, AudioInterruptZoneManager_006, TestSize.Level1)
159 {
160 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
161 ASSERT_NE(audioInterruptZoneManager, nullptr);
162
163 audioInterruptZoneManager->service_ = new AudioInterruptService();
164 ASSERT_NE(audioInterruptZoneManager->service_, nullptr);
165 std::shared_ptr<AudioInterruptZone> audioInterruptZone = nullptr;
166 audioInterruptZoneManager->service_->zonesMap_.insert({0, audioInterruptZone});
167
168 int32_t zoneId = 1;
169 std::string deviceTag = "0";
170 AudioFocusList focusInfoList;
171
172 auto ret = audioInterruptZoneManager->GetAudioFocusInfoList(zoneId, deviceTag, focusInfoList);
173 EXPECT_EQ(ret, SUCCESS);
174 EXPECT_EQ(focusInfoList.size(), 0);
175 }
176 } // namespace AudioStandard
177 } // namespace OHOS