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