1 /*
2 * Copyright (c) 2021-2022 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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioVolumeChangeUnitTest"
17 #endif
18
19 #include <sys/stat.h>
20
21 #include "audio_errors.h"
22 #include "audio_info.h"
23 #include "audio_log.h"
24 #include "audio_system_manager.h"
25
26 #include "audio_volume_change_unit_test.h"
27
28 using namespace std;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace AudioStandard {
33 namespace {
34 AudioSystemManager *g_audioManagerInstance = nullptr;
35
36 int32_t g_streamType(0);
37 int32_t g_volumeLevel(0);
38 bool g_isUpdateUi(false);
39 int32_t g_volumeGroupId(0);
40 std::string g_networkId(LOCAL_NETWORK_ID);
41 bool g_isCallbackReceived(false);
42
43 std::string g_callbackName("");
44 std::mutex g_mutex;
45 std::condition_variable g_condVar;
46 } // namespace
47
ApplicationCallback(const std::string & testCaseName)48 ApplicationCallback::ApplicationCallback(const std::string &testCaseName) : testCaseName_(testCaseName) {}
49
OnVolumeKeyEvent(VolumeEvent volumeEvent)50 void ApplicationCallback::OnVolumeKeyEvent(VolumeEvent volumeEvent)
51 {
52 g_isCallbackReceived = true;
53 g_streamType = volumeEvent.volumeType;
54 g_volumeLevel = volumeEvent.volume;
55 g_callbackName = testCaseName_;
56 g_isUpdateUi = volumeEvent.updateUi;
57 g_volumeGroupId = volumeEvent.volumeGroupId;
58 g_networkId = volumeEvent.networkId;
59 g_condVar.notify_all();
60 }
61
WaitForCallback()62 void AudioVolumeChangeUnitTest::WaitForCallback()
63 {
64 std::unique_lock<std::mutex> lock(g_mutex);
65 g_condVar.wait_until(lock, std::chrono::system_clock::now() + std::chrono::minutes(1),
66 []() { return g_isCallbackReceived == true; });
67 }
68
SetUpTestCase(void)69 void AudioVolumeChangeUnitTest::SetUpTestCase(void)
70 {
71 g_audioManagerInstance = AudioSystemManager::GetInstance();
72 if (g_audioManagerInstance == nullptr) {
73 AUDIO_ERR_LOG("AudioSystemManager instance not available");
74 return;
75 }
76 }
77
TearDownTestCase(void)78 void AudioVolumeChangeUnitTest::TearDownTestCase(void)
79 {
80 g_audioManagerInstance = nullptr;
81 }
82
83 // SetUp:Execute before each test case
SetUp()84 void AudioVolumeChangeUnitTest::SetUp() {}
85
TearDown(void)86 void AudioVolumeChangeUnitTest::TearDown(void) {}
87
88 /*
89 * Feature: AudioVolumeChangeUnitTest
90 * Function: Set volume for AudioStreamType::STREAM_MUSIC
91 * SubFunction: NA
92 * FunctionPoints: NA
93 * EnvConditions: NA
94 * CaseDescription:
95 */
96 HWTEST_F(AudioVolumeChangeUnitTest, volumeChange_test_001, TestSize.Level1)
97 {
98 int result;
99 int callBackSetResult;
100 std::string testCaseName("volumeChange_test_001");
101 g_isCallbackReceived = false;
102 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
103 AudioVolumeType volumeType
104 = static_cast<AudioVolumeType>(streamType);
105 int volume = 10;
106 g_callbackName = testCaseName;
107 bool isUpdateUi = false;
108 auto appCallback = make_shared<ApplicationCallback>(testCaseName);
109 callBackSetResult = g_audioManagerInstance->RegisterVolumeKeyEventCallback(getpid(), appCallback);
110 result = g_audioManagerInstance->SetVolume(volumeType, volume);
111 EXPECT_EQ(result, SUCCESS);
112 EXPECT_EQ(callBackSetResult, SUCCESS);
113 if (result == SUCCESS) {
114 // Wait here for callback. If not callback for 2 mintues, will skip this step
115 AudioVolumeChangeUnitTest::WaitForCallback();
116 EXPECT_EQ(streamType, g_streamType);
117 EXPECT_EQ(volume, g_volumeLevel);
118 EXPECT_EQ(isUpdateUi, g_isUpdateUi);
119 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
120 }
121 g_audioManagerInstance->UnregisterVolumeKeyEventCallback(getpid());
122 }
123
124 /*
125 * Feature: AudioVolumeChangeUnitTest
126 * Function: Set volume for AudioStreamType::STREAM_RING
127 * SubFunction: NA
128 * FunctionPoints: NA
129 * EnvConditions: NA
130 * CaseDescription:
131 */
132 HWTEST_F(AudioVolumeChangeUnitTest, volumeChange_test_002, TestSize.Level1)
133 {
134 int result;
135 int callBackSetResult;
136 std::string testCaseName("volumeChange_test_002");
137 g_isCallbackReceived = false;
138 AudioStreamType streamType = AudioStreamType::STREAM_RING;
139 AudioVolumeType volumeType
140 = static_cast<AudioVolumeType>(streamType);
141 int volume = 10;
142 g_callbackName = testCaseName;
143 bool isUpdateUi = false;
144 auto appCallback = make_shared<ApplicationCallback>(testCaseName);
145 callBackSetResult = g_audioManagerInstance->RegisterVolumeKeyEventCallback(getpid(), appCallback);
146 result = g_audioManagerInstance->SetVolume(volumeType, volume);
147 EXPECT_EQ(result, SUCCESS);
148 EXPECT_EQ(callBackSetResult, SUCCESS);
149 if (result == SUCCESS) {
150 // Wait here for callback. If not callback for 2 mintues, will skip this step
151 AudioVolumeChangeUnitTest::WaitForCallback();
152 EXPECT_EQ(streamType, g_streamType);
153 EXPECT_EQ(volume, g_volumeLevel);
154 EXPECT_EQ(isUpdateUi, g_isUpdateUi);
155 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
156 }
157 g_audioManagerInstance->UnregisterVolumeKeyEventCallback(getpid());
158 }
159
160 /*
161 * Feature: AudioVolumeChangeUnitTest
162 * Function: Set volume for AudioStreamType::STREAM_VOICE_CALL
163 * SubFunction: NA
164 * FunctionPoints: NA
165 * EnvConditions: NA
166 * CaseDescription:
167 */
168 HWTEST_F(AudioVolumeChangeUnitTest, volumeChange_test_003, TestSize.Level1)
169 {
170 int result;
171 int callBackSetResult;
172 std::string testCaseName("volumeChange_test_003");
173 g_isCallbackReceived = false;
174 AudioStreamType streamType = AudioStreamType::STREAM_VOICE_CALL;
175 AudioVolumeType volumeType = static_cast<AudioVolumeType>(streamType);
176 int volume = 10;
177 g_callbackName = testCaseName;
178 bool isUpdateUi = false;
179 auto appCallback = make_shared<ApplicationCallback>(testCaseName);
180 callBackSetResult = g_audioManagerInstance->RegisterVolumeKeyEventCallback(getpid(), appCallback);
181 result = g_audioManagerInstance->SetVolume(volumeType, volume);
182 EXPECT_EQ(result, SUCCESS);
183 EXPECT_EQ(callBackSetResult, SUCCESS);
184 if (result == SUCCESS) {
185 // Wait here for callback. If not callback for 2 mintues, will skip this step
186 AudioVolumeChangeUnitTest::WaitForCallback();
187 EXPECT_EQ(streamType, g_streamType);
188 EXPECT_EQ(volume, g_volumeLevel);
189 EXPECT_EQ(isUpdateUi, g_isUpdateUi);
190 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
191 }
192 g_audioManagerInstance->UnregisterVolumeKeyEventCallback(getpid());
193 }
194 } // namespace AudioStandard
195 } // namespace OHOS
196