1 // Copyright 2016 The Android Open Source Project
2 //
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 // Tests for the brillo audio client.
17
18 #include <binderwrapper/binder_test_base.h>
19 #include <binderwrapper/stub_binder_wrapper.h>
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
22
23 #include "audio_service_callback.h"
24 #include "brillo_audio_client.h"
25 #include "include/brillo_audio_manager.h"
26 #include "test/brillo_audio_client_mock.h"
27 #include "test/brillo_audio_service_mock.h"
28
29 using android::sp;
30 using android::String8;
31 using testing::Return;
32 using testing::_;
33
34 namespace brillo {
35
36 static const char kBrilloAudioServiceName[] =
37 "android.brillo.brilloaudioservice.BrilloAudioService";
38
39 class BrilloAudioClientTest : public android::BinderTestBase {
40 public:
ConnectClientToBAS()41 bool ConnectClientToBAS() {
42 bas_ = new BrilloAudioServiceMock();
43 binder_wrapper()->SetBinderForService(kBrilloAudioServiceName, bas_);
44 return client_.Initialize();
45 }
46
47 BrilloAudioClientMock client_;
48 sp<BrilloAudioServiceMock> bas_;
49 };
50
TEST_F(BrilloAudioClientTest,SetDeviceNoService)51 TEST_F(BrilloAudioClientTest, SetDeviceNoService) {
52 EXPECT_CALL(client_, OnBASDisconnect());
53 EXPECT_EQ(
54 client_.SetDevice(AUDIO_POLICY_FORCE_USE_MAX, AUDIO_POLICY_FORCE_NONE),
55 ECONNABORTED);
56 }
57
TEST_F(BrilloAudioClientTest,GetDevicesNoService)58 TEST_F(BrilloAudioClientTest, GetDevicesNoService) {
59 std::vector<int> foo;
60 EXPECT_CALL(client_, OnBASDisconnect());
61 EXPECT_EQ(client_.GetDevices(0, foo), ECONNABORTED);
62 }
63
TEST_F(BrilloAudioClientTest,RegisterCallbackNoService)64 TEST_F(BrilloAudioClientTest, RegisterCallbackNoService) {
65 EXPECT_CALL(client_, OnBASDisconnect());
66 EXPECT_EQ(client_.RegisterAudioCallback(nullptr, nullptr), ECONNABORTED);
67 }
68
TEST_F(BrilloAudioClientTest,UnregisterAudioCallbackNoService)69 TEST_F(BrilloAudioClientTest, UnregisterAudioCallbackNoService) {
70 EXPECT_CALL(client_, OnBASDisconnect());
71 EXPECT_EQ(client_.UnregisterAudioCallback(0), ECONNABORTED);
72 }
73
TEST_F(BrilloAudioClientTest,InitializeNoService)74 TEST_F(BrilloAudioClientTest, InitializeNoService) {
75 EXPECT_FALSE(client_.Initialize());
76 }
77
TEST_F(BrilloAudioClientTest,CheckInitializeRegistersForDeathNotifications)78 TEST_F(BrilloAudioClientTest, CheckInitializeRegistersForDeathNotifications) {
79 EXPECT_TRUE(ConnectClientToBAS());
80 EXPECT_CALL(client_, OnBASDisconnect());
81 binder_wrapper()->NotifyAboutBinderDeath(bas_);
82 }
83
TEST_F(BrilloAudioClientTest,GetDevicesWithBAS)84 TEST_F(BrilloAudioClientTest, GetDevicesWithBAS) {
85 EXPECT_TRUE(ConnectClientToBAS());
86 std::vector<int> foo;
87 EXPECT_CALL(*bas_.get(), GetDevices(0, &foo)).WillOnce(Return(Status::ok()));
88 EXPECT_EQ(client_.GetDevices(0, foo), 0);
89 }
90
TEST_F(BrilloAudioClientTest,SetDeviceWithBAS)91 TEST_F(BrilloAudioClientTest, SetDeviceWithBAS) {
92 EXPECT_TRUE(ConnectClientToBAS());
93 std::vector<int> foo;
94 EXPECT_CALL(*bas_.get(),
95 SetDevice(AUDIO_POLICY_FORCE_USE_MAX, AUDIO_POLICY_FORCE_NONE))
96 .WillOnce(Return(Status::ok()));
97 EXPECT_EQ(
98 client_.SetDevice(AUDIO_POLICY_FORCE_USE_MAX, AUDIO_POLICY_FORCE_NONE),
99 0);
100 }
101
TEST_F(BrilloAudioClientTest,RegisterCallbackWithBAS)102 TEST_F(BrilloAudioClientTest, RegisterCallbackWithBAS) {
103 EXPECT_TRUE(ConnectClientToBAS());
104 BAudioCallback bcallback;
105 AudioServiceCallback* callback =
106 new AudioServiceCallback(&bcallback, nullptr);
107 int id = 0;
108 EXPECT_CALL(*bas_.get(),
109 RegisterServiceCallback(sp<IAudioServiceCallback>(callback)))
110 .WillOnce(Return(Status::ok()));
111 EXPECT_EQ(client_.RegisterAudioCallback(callback, &id), 0);
112 EXPECT_NE(id, 0);
113 }
114
TEST_F(BrilloAudioClientTest,RegisterSameCallbackTwiceWithBAS)115 TEST_F(BrilloAudioClientTest, RegisterSameCallbackTwiceWithBAS) {
116 EXPECT_TRUE(ConnectClientToBAS());
117 BAudioCallback bcallback;
118 AudioServiceCallback* callback =
119 new AudioServiceCallback(&bcallback, nullptr);
120 int id = -1;
121 EXPECT_CALL(*bas_.get(),
122 RegisterServiceCallback(sp<IAudioServiceCallback>(callback)))
123 .Times(2)
124 .WillRepeatedly(Return(Status::ok()));
125 EXPECT_EQ(client_.RegisterAudioCallback(callback, &id), 0);
126 EXPECT_NE(id, 0);
127 id = -1;
128 EXPECT_EQ(client_.RegisterAudioCallback(callback, &id), EINVAL);
129 EXPECT_EQ(id, 0);
130 }
131
TEST_F(BrilloAudioClientTest,UnregisterAudioCallbackValidWithBAS)132 TEST_F(BrilloAudioClientTest, UnregisterAudioCallbackValidWithBAS) {
133 EXPECT_TRUE(ConnectClientToBAS());
134 BAudioCallback bcallback;
135 AudioServiceCallback* callback =
136 new AudioServiceCallback(&bcallback, nullptr);
137 int id = 0;
138 EXPECT_CALL(*bas_.get(),
139 RegisterServiceCallback(sp<IAudioServiceCallback>(callback)))
140 .WillOnce(Return(Status::ok()));
141 EXPECT_EQ(client_.RegisterAudioCallback(callback, &id), 0);
142 EXPECT_NE(id, 0);
143 EXPECT_CALL(*bas_.get(),
144 UnregisterServiceCallback(sp<IAudioServiceCallback>(callback)))
145 .WillOnce(Return(Status::ok()));
146 EXPECT_EQ(client_.UnregisterAudioCallback(id), 0);
147 }
148
TEST_F(BrilloAudioClientTest,UnregisterInvalidCallbackWithBAS)149 TEST_F(BrilloAudioClientTest, UnregisterInvalidCallbackWithBAS) {
150 EXPECT_TRUE(ConnectClientToBAS());
151 EXPECT_EQ(client_.UnregisterAudioCallback(1), EINVAL);
152 }
153
TEST_F(BrilloAudioClientTest,RegisterAndUnregisterAudioTwoCallbacks)154 TEST_F(BrilloAudioClientTest, RegisterAndUnregisterAudioTwoCallbacks) {
155 EXPECT_TRUE(ConnectClientToBAS());
156 BAudioCallback bcallback1, bcallback2;
157 AudioServiceCallback* callback1 =
158 new AudioServiceCallback(&bcallback1, nullptr);
159 AudioServiceCallback* callback2 =
160 new AudioServiceCallback(&bcallback2, nullptr);
161 int id1 = 0, id2 = 0;
162 EXPECT_CALL(*bas_.get(), RegisterServiceCallback(_))
163 .WillRepeatedly(Return(Status::ok()));
164 EXPECT_EQ(client_.RegisterAudioCallback(callback1, &id1), 0);
165 EXPECT_NE(id1, 0);
166 EXPECT_EQ(client_.RegisterAudioCallback(callback2, &id2), 0);
167 EXPECT_NE(id2, 0);
168 EXPECT_CALL(*bas_.get(), UnregisterServiceCallback(_))
169 .WillRepeatedly(Return(Status::ok()));
170 EXPECT_EQ(client_.UnregisterAudioCallback(id1), 0);
171 EXPECT_EQ(client_.UnregisterAudioCallback(id2), 0);
172 }
173
TEST_F(BrilloAudioClientTest,GetMaxVolStepsNoService)174 TEST_F(BrilloAudioClientTest, GetMaxVolStepsNoService) {
175 EXPECT_CALL(client_, OnBASDisconnect());
176 int foo;
177 EXPECT_EQ(client_.GetMaxVolumeSteps(BAudioUsage::kUsageInvalid, &foo),
178 ECONNABORTED);
179 }
180
TEST_F(BrilloAudioClientTest,GetMaxVolStepsWithBAS)181 TEST_F(BrilloAudioClientTest, GetMaxVolStepsWithBAS) {
182 EXPECT_TRUE(ConnectClientToBAS());
183 int foo;
184 EXPECT_CALL(*bas_.get(), GetMaxVolumeSteps(AUDIO_STREAM_MUSIC, &foo))
185 .WillOnce(Return(Status::ok()));
186 EXPECT_EQ(client_.GetMaxVolumeSteps(BAudioUsage::kUsageMedia, &foo), 0);
187 }
188
TEST_F(BrilloAudioClientTest,SetMaxVolStepsNoService)189 TEST_F(BrilloAudioClientTest, SetMaxVolStepsNoService) {
190 EXPECT_CALL(client_, OnBASDisconnect());
191 EXPECT_EQ(client_.SetMaxVolumeSteps(BAudioUsage::kUsageInvalid, 100),
192 ECONNABORTED);
193 }
194
TEST_F(BrilloAudioClientTest,SetMaxVolStepsWithBAS)195 TEST_F(BrilloAudioClientTest, SetMaxVolStepsWithBAS) {
196 EXPECT_TRUE(ConnectClientToBAS());
197 EXPECT_CALL(*bas_.get(), SetMaxVolumeSteps(AUDIO_STREAM_MUSIC, 100))
198 .WillOnce(Return(Status::ok()));
199 EXPECT_EQ(client_.SetMaxVolumeSteps(BAudioUsage::kUsageMedia, 100), 0);
200 }
201
TEST_F(BrilloAudioClientTest,SetVolIndexNoService)202 TEST_F(BrilloAudioClientTest, SetVolIndexNoService) {
203 EXPECT_CALL(client_, OnBASDisconnect());
204 EXPECT_EQ(client_.SetVolumeIndex(
205 BAudioUsage::kUsageInvalid, AUDIO_DEVICE_NONE, 100),
206 ECONNABORTED);
207 }
208
TEST_F(BrilloAudioClientTest,SetVolIndexWithBAS)209 TEST_F(BrilloAudioClientTest, SetVolIndexWithBAS) {
210 EXPECT_TRUE(ConnectClientToBAS());
211 EXPECT_CALL(*bas_.get(),
212 SetVolumeIndex(AUDIO_STREAM_MUSIC, AUDIO_DEVICE_OUT_SPEAKER, 100))
213 .WillOnce(Return(Status::ok()));
214 EXPECT_EQ(client_.SetVolumeIndex(
215 BAudioUsage::kUsageMedia, AUDIO_DEVICE_OUT_SPEAKER, 100),
216 0);
217 }
218
TEST_F(BrilloAudioClientTest,GetVolIndexNoService)219 TEST_F(BrilloAudioClientTest, GetVolIndexNoService) {
220 EXPECT_CALL(client_, OnBASDisconnect());
221 int foo;
222 EXPECT_EQ(client_.GetVolumeIndex(
223 BAudioUsage::kUsageInvalid, AUDIO_DEVICE_NONE, &foo),
224 ECONNABORTED);
225 }
226
TEST_F(BrilloAudioClientTest,GetVolIndexWithBAS)227 TEST_F(BrilloAudioClientTest, GetVolIndexWithBAS) {
228 EXPECT_TRUE(ConnectClientToBAS());
229 int foo;
230 EXPECT_CALL(
231 *bas_.get(),
232 GetVolumeIndex(AUDIO_STREAM_MUSIC, AUDIO_DEVICE_OUT_SPEAKER, &foo))
233 .WillOnce(Return(Status::ok()));
234 EXPECT_EQ(client_.GetVolumeIndex(
235 BAudioUsage::kUsageMedia, AUDIO_DEVICE_OUT_SPEAKER, &foo),
236 0);
237 }
238
TEST_F(BrilloAudioClientTest,GetVolumeControlStreamNoService)239 TEST_F(BrilloAudioClientTest, GetVolumeControlStreamNoService) {
240 EXPECT_CALL(client_, OnBASDisconnect());
241 BAudioUsage foo;
242 EXPECT_EQ(client_.GetVolumeControlStream(&foo), ECONNABORTED);
243 }
244
TEST_F(BrilloAudioClientTest,GetVolumeControlStreamWithBAS)245 TEST_F(BrilloAudioClientTest, GetVolumeControlStreamWithBAS) {
246 EXPECT_TRUE(ConnectClientToBAS());
247 EXPECT_CALL(*bas_.get(), GetVolumeControlStream(_))
248 .WillOnce(Return(Status::ok()));
249 BAudioUsage foo;
250 EXPECT_EQ(client_.GetVolumeControlStream(&foo), 0);
251 }
252
TEST_F(BrilloAudioClientTest,SetVolumeControlStreamNoService)253 TEST_F(BrilloAudioClientTest, SetVolumeControlStreamNoService) {
254 EXPECT_CALL(client_, OnBASDisconnect());
255 EXPECT_EQ(client_.SetVolumeControlStream(kUsageMedia), ECONNABORTED);
256 }
257
TEST_F(BrilloAudioClientTest,SetVolumeControlStreamWithBAS)258 TEST_F(BrilloAudioClientTest, SetVolumeControlStreamWithBAS) {
259 EXPECT_TRUE(ConnectClientToBAS());
260 EXPECT_CALL(*bas_.get(), SetVolumeControlStream(AUDIO_STREAM_MUSIC))
261 .WillOnce(Return(Status::ok()));
262 EXPECT_EQ(client_.SetVolumeControlStream(kUsageMedia), 0);
263 }
264
TEST_F(BrilloAudioClientTest,IncrementVolNoService)265 TEST_F(BrilloAudioClientTest, IncrementVolNoService) {
266 EXPECT_CALL(client_, OnBASDisconnect());
267 EXPECT_EQ(client_.IncrementVolume(), ECONNABORTED);
268 }
269
TEST_F(BrilloAudioClientTest,IncrementVolWithBAS)270 TEST_F(BrilloAudioClientTest, IncrementVolWithBAS) {
271 EXPECT_TRUE(ConnectClientToBAS());
272 EXPECT_CALL(*bas_.get(), IncrementVolume()).WillOnce(Return(Status::ok()));
273 EXPECT_EQ(client_.IncrementVolume(), 0);
274 }
275
TEST_F(BrilloAudioClientTest,DecrementVolNoService)276 TEST_F(BrilloAudioClientTest, DecrementVolNoService) {
277 EXPECT_CALL(client_, OnBASDisconnect());
278 EXPECT_EQ(client_.DecrementVolume(), ECONNABORTED);
279 }
280
TEST_F(BrilloAudioClientTest,DecrementVolWithBAS)281 TEST_F(BrilloAudioClientTest, DecrementVolWithBAS) {
282 EXPECT_TRUE(ConnectClientToBAS());
283 EXPECT_CALL(*bas_.get(), DecrementVolume()).WillOnce(Return(Status::ok()));
284 EXPECT_EQ(client_.DecrementVolume(), 0);
285 }
286
287 } // namespace brillo
288