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
29using android::sp;
30using android::String8;
31using testing::Return;
32using testing::_;
33
34namespace brillo {
35
36static const char kBrilloAudioServiceName[] =
37    "android.brillo.brilloaudioservice.BrilloAudioService";
38
39class BrilloAudioClientTest : public android::BinderTestBase {
40 public:
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
51TEST_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
58TEST_F(BrilloAudioClientTest, GetDevicesNoService) {
59  std::vector<int> foo;
60  EXPECT_CALL(client_, OnBASDisconnect());
61  EXPECT_EQ(client_.GetDevices(0, foo), ECONNABORTED);
62}
63
64TEST_F(BrilloAudioClientTest, RegisterCallbackNoService) {
65  EXPECT_CALL(client_, OnBASDisconnect());
66  EXPECT_EQ(client_.RegisterAudioCallback(nullptr, nullptr), ECONNABORTED);
67}
68
69TEST_F(BrilloAudioClientTest, UnregisterAudioCallbackNoService) {
70  EXPECT_CALL(client_, OnBASDisconnect());
71  EXPECT_EQ(client_.UnregisterAudioCallback(0), ECONNABORTED);
72}
73
74TEST_F(BrilloAudioClientTest, InitializeNoService) {
75  EXPECT_FALSE(client_.Initialize());
76}
77
78TEST_F(BrilloAudioClientTest, CheckInitializeRegistersForDeathNotifications) {
79  EXPECT_TRUE(ConnectClientToBAS());
80  EXPECT_CALL(client_, OnBASDisconnect());
81  binder_wrapper()->NotifyAboutBinderDeath(bas_);
82}
83
84TEST_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
91TEST_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
102TEST_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
115TEST_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
132TEST_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
149TEST_F(BrilloAudioClientTest, UnregisterInvalidCallbackWithBAS) {
150  EXPECT_TRUE(ConnectClientToBAS());
151  EXPECT_EQ(client_.UnregisterAudioCallback(1), EINVAL);
152}
153
154TEST_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
174TEST_F(BrilloAudioClientTest, GetMaxVolStepsNoService) {
175  EXPECT_CALL(client_, OnBASDisconnect());
176  int foo;
177  EXPECT_EQ(client_.GetMaxVolumeSteps(BAudioUsage::kUsageInvalid, &foo),
178            ECONNABORTED);
179}
180
181TEST_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
189TEST_F(BrilloAudioClientTest, SetMaxVolStepsNoService) {
190  EXPECT_CALL(client_, OnBASDisconnect());
191  EXPECT_EQ(client_.SetMaxVolumeSteps(BAudioUsage::kUsageInvalid, 100),
192            ECONNABORTED);
193}
194
195TEST_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
202TEST_F(BrilloAudioClientTest, SetVolIndexNoService) {
203  EXPECT_CALL(client_, OnBASDisconnect());
204  EXPECT_EQ(client_.SetVolumeIndex(
205                BAudioUsage::kUsageInvalid, AUDIO_DEVICE_NONE, 100),
206            ECONNABORTED);
207}
208
209TEST_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
219TEST_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
227TEST_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
239TEST_F(BrilloAudioClientTest, GetVolumeControlStreamNoService) {
240  EXPECT_CALL(client_, OnBASDisconnect());
241  BAudioUsage foo;
242  EXPECT_EQ(client_.GetVolumeControlStream(&foo), ECONNABORTED);
243}
244
245TEST_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
253TEST_F(BrilloAudioClientTest, SetVolumeControlStreamNoService) {
254  EXPECT_CALL(client_, OnBASDisconnect());
255  EXPECT_EQ(client_.SetVolumeControlStream(kUsageMedia), ECONNABORTED);
256}
257
258TEST_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
265TEST_F(BrilloAudioClientTest, IncrementVolNoService) {
266  EXPECT_CALL(client_, OnBASDisconnect());
267  EXPECT_EQ(client_.IncrementVolume(), ECONNABORTED);
268}
269
270TEST_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
276TEST_F(BrilloAudioClientTest, DecrementVolNoService) {
277  EXPECT_CALL(client_, OnBASDisconnect());
278  EXPECT_EQ(client_.DecrementVolume(), ECONNABORTED);
279}
280
281TEST_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