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_zone_client_unit_test.h"
17 #include "audio_zone_manager.h"
18 #include "audio_errors.h"
19 #include "audio_policy_log.h"
20
21 #include <thread>
22 #include <memory>
23 #include <vector>
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace AudioStandard {
28
SetUpTestCase(void)29 void AudiZoneClientUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)30 void AudiZoneClientUnitTest::TearDownTestCase(void) {}
SetUp(void)31 void AudiZoneClientUnitTest::SetUp(void) {}
TearDown(void)32 void AudiZoneClientUnitTest::TearDown(void) {}
33
34 class AudioZoneCallbackStub : public AudioZoneCallback {
35 public:
~AudioZoneCallbackStub()36 ~AudioZoneCallbackStub() {}
37
OnAudioZoneAdd(const AudioZoneDescriptor & zoneDescriptor)38 void OnAudioZoneAdd(const AudioZoneDescriptor &zoneDescriptor) override {}
39
OnAudioZoneRemove(int32_t zoneId)40 void OnAudioZoneRemove(int32_t zoneId) override {}
41 };
42
43 class AudioZoneChangeCallbackStub : public AudioZoneChangeCallback {
44 public:
~AudioZoneChangeCallbackStub()45 ~AudioZoneChangeCallbackStub() override {}
46
OnAudioZoneChange(const AudioZoneDescriptor & zoneDescriptor,AudioZoneChangeReason reason)47 void OnAudioZoneChange(const AudioZoneDescriptor &zoneDescriptor,
48 AudioZoneChangeReason reason) override {}
49 };
50
51 class AudioZoneVolumeProxyStub : public AudioZoneVolumeProxy {
52 public:
~AudioZoneVolumeProxyStub()53 ~AudioZoneVolumeProxyStub() override {}
54
SetSystemVolume(const AudioVolumeType volumeType,const int32_t volumeLevel)55 void SetSystemVolume(const AudioVolumeType volumeType, const int32_t volumeLevel) override {}
56
GetSystemVolume(AudioVolumeType volumeType)57 int32_t GetSystemVolume(AudioVolumeType volumeType) override {return 0;}
58 };
59
60 class AudioZoneInterruptCallbackStub : public AudioZoneInterruptCallback {
61 public:
~AudioZoneInterruptCallbackStub()62 ~AudioZoneInterruptCallbackStub() {}
63
OnInterruptEvent(const std::list<std::pair<AudioInterrupt,AudioFocuState>> & interrupts,AudioZoneInterruptReason reason)64 void OnInterruptEvent(const std::list<std::pair<AudioInterrupt, AudioFocuState>> &interrupts,
65 AudioZoneInterruptReason reason) override {}
66 };
67
68 /**
69 * @tc.name : Test AudiZoneClientUnitTest.
70 * @tc.number: AudiZoneClientUnitTest_001
71 * @tc.desc : Test AddAudioZoneCallback interface.
72 */
73 HWTEST_F(AudiZoneClientUnitTest, AudiZoneClientUnitTest_001, TestSize.Level4)
74 {
75 auto audioZoneClient = std::make_shared<AudioZoneClient>();
76 auto callback = std::make_shared<AudioZoneCallbackStub>();
77 audioZoneClient->audioZoneCallback_ = callback;
78 auto ret = audioZoneClient->AddAudioZoneCallback(callback);
79 EXPECT_EQ(SUCCESS, ret);
80
81 audioZoneClient->audioZoneCallback_ = nullptr;
82 ret = audioZoneClient->AddAudioZoneCallback(callback);
83 EXPECT_EQ(SUCCESS, ret);
84 }
85
86 /**
87 * @tc.name : Test AudiZoneClientUnitTest.
88 * @tc.number: AudiZoneClientUnitTest_002
89 * @tc.desc : Test AddAudioZoneChangeCallback interface.
90 */
91 HWTEST_F(AudiZoneClientUnitTest, AudiZoneClientUnitTest_002, TestSize.Level4)
92 {
93 auto audioZoneClient = std::make_shared<AudioZoneClient>();
94 int32_t zoneId = 0;
95 auto callback = std::make_shared<AudioZoneChangeCallbackStub>();
96 audioZoneClient->audioZoneChangeCallbackMap_[zoneId] = callback;
97 auto ret = audioZoneClient->AddAudioZoneChangeCallback(zoneId, callback);
98 EXPECT_EQ(SUCCESS, ret);
99
100 audioZoneClient->audioZoneChangeCallbackMap_.erase(zoneId);
101 ret = audioZoneClient->AddAudioZoneChangeCallback(zoneId, callback);
102 EXPECT_NE(SUCCESS, ret);
103 }
104
105 /**
106 * @tc.name : Test AudiZoneClientUnitTest.
107 * @tc.number: AudiZoneClientUnitTest_003
108 * @tc.desc : Test AddAudioZoneVolumeProxy interface.
109 */
110 HWTEST_F(AudiZoneClientUnitTest, AudiZoneClientUnitTest_003, TestSize.Level4)
111 {
112 auto audioZoneClient = std::make_shared<AudioZoneClient>();
113 int32_t zoneId = 0;
114 auto callback = std::make_shared<AudioZoneVolumeProxyStub>();
115 audioZoneClient->audioZoneVolumeProxyMap_[zoneId] = callback;
116 auto ret = audioZoneClient->AddAudioZoneVolumeProxy(zoneId, callback);
117 EXPECT_EQ(SUCCESS, ret);
118
119 audioZoneClient->audioZoneVolumeProxyMap_.erase(zoneId);
120 ret = audioZoneClient->AddAudioZoneVolumeProxy(zoneId, callback);
121 EXPECT_NE(SUCCESS, ret);
122 }
123
124
125 /**
126 * @tc.name : Test AudiZoneClientUnitTest.
127 * @tc.number: AudiZoneClientUnitTest_004
128 * @tc.desc : Test AddAudioInterruptCallback interface.
129 */
130 HWTEST_F(AudiZoneClientUnitTest, AudiZoneClientUnitTest_004, TestSize.Level4)
131 {
132 auto audioZoneClient = std::make_shared<AudioZoneClient>();
133 int32_t zoneId = 0;
134 std::string deviceTag = "test";
135 auto callback = std::make_shared<AudioZoneInterruptCallbackStub>();
136 std::string key = std::to_string(zoneId) + "&" + deviceTag;
137 audioZoneClient->audioZoneInterruptCallbackMap_[key] = callback;
138 auto ret = audioZoneClient->AddAudioInterruptCallback(zoneId, deviceTag, callback);
139 EXPECT_EQ(SUCCESS, ret);
140
141 audioZoneClient->audioZoneInterruptCallbackMap_.erase(key);
142 ret = audioZoneClient->AddAudioInterruptCallback(zoneId, deviceTag, callback);
143 EXPECT_NE(SUCCESS, ret);
144 }
145
146 /**
147 * @tc.name : Test AudiZoneClientUnitTest.
148 * @tc.number: AudiZoneClientUnitTest_005
149 * @tc.desc : Test Restore interface.
150 */
151 HWTEST_F(AudiZoneClientUnitTest, AudiZoneClientUnitTest_005, TestSize.Level4)
152 {
153 auto audioZoneClient = std::make_shared<AudioZoneClient>();
154 auto callback = std::make_shared<AudioZoneCallbackStub>();
155 audioZoneClient->Restore();
156 EXPECT_EQ(nullptr, audioZoneClient->audioZoneCallback_);
157 audioZoneClient->audioZoneCallback_ = callback;
158 audioZoneClient->Restore();
159 EXPECT_NE(nullptr, audioZoneClient->audioZoneCallback_);
160 }
161 } // namespace AudioStandard
162 } // namespace OHOS