src/third_party/webrtc/modules/audio_device/test/audio_device_test_api.cc

   1 /*
   2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <math.h>
  12 #include <stdio.h>
  13 #include <string.h>
  14
  15 #include "webrtc/modules/audio_device/test/audio_device_test_defines.h"
  16
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "webrtc/test/testsupport/fileutils.h"
  19
  20 #include "webrtc/modules/audio_device/audio_device_config.h"
  21 #include "webrtc/modules/audio_device/audio_device_impl.h"
  22 #include "webrtc/modules/audio_device/audio_device_utility.h"
  23 #include "webrtc/system_wrappers/interface/sleep.h"
  24
  25 // Helper functions
  26 #if defined(ANDROID)
  27 char filenameStr[2][256] =
  28 { {0},
  29   {0},
  30 }; // Allow two buffers for those API calls taking two filenames
  31 int currentStr = 0;
  32
  33 const char* GetFilename(const char* filename)
  34 {
  35   currentStr = !currentStr;
  36   sprintf(filenameStr[currentStr], "/sdcard/admtest/%s", filename);
  37   return filenameStr[currentStr];
  38 }
  39 #elif !defined(WEBRTC_IOS)
  40 const char* GetFilename(const char* filename) {
  41   std::string full_path_filename = webrtc::test::OutputPath() + filename;
  42   return full_path_filename.c_str();
  43 }
  44 #endif
  45
  46 using namespace webrtc;
  47
  48 class AudioEventObserverAPI: public AudioDeviceObserver {
  49  public:
  50   AudioEventObserverAPI(AudioDeviceModule* audioDevice)
  51       : error_(kRecordingError),
  52         warning_(kRecordingWarning),
  53         audio_device_(audioDevice) {
  54   }
  55
  56   ~AudioEventObserverAPI() {}
  57
  58   virtual void OnErrorIsReported(const ErrorCode error) {
  59     TEST_LOG("\n[*** ERROR ***] => OnErrorIsReported(%d)\n\n", error);
  60     error_ = error;
  61   }
  62
  63   virtual void OnWarningIsReported(const WarningCode warning) {
  64     TEST_LOG("\n[*** WARNING ***] => OnWarningIsReported(%d)\n\n", warning);
  65     warning_ = warning;
  66     EXPECT_EQ(0, audio_device_->StopRecording());
  67     EXPECT_EQ(0, audio_device_->StopPlayout());
  68   }
  69
  70  public:
  71   ErrorCode error_;
  72   WarningCode warning_;
  73  private:
  74   AudioDeviceModule* audio_device_;
  75 };
  76
  77 class AudioTransportAPI: public AudioTransport {
  78  public:
  79   AudioTransportAPI(AudioDeviceModule* audioDevice)
  80       : rec_count_(0),
  81         play_count_(0) {
  82   }
  83
  84   ~AudioTransportAPI() {}
  85
  86   virtual int32_t RecordedDataIsAvailable(
  87       const void* audioSamples,
  88       const uint32_t nSamples,
  89       const uint8_t nBytesPerSample,
  90       const uint8_t nChannels,
  91       const uint32_t sampleRate,
  92       const uint32_t totalDelay,
  93       const int32_t clockSkew,
  94       const uint32_t currentMicLevel,
  95       const bool keyPressed,
  96       uint32_t& newMicLevel) {
  97     rec_count_++;
  98     if (rec_count_ % 100 == 0) {
  99       if (nChannels == 1) {
 100         // mono
 101         TEST_LOG("-");
 102       } else if ((nChannels == 2) && (nBytesPerSample == 2)) {
 103         // stereo but only using one channel
 104         TEST_LOG("-|");
 105       } else {
 106         // stereo
 107         TEST_LOG("--");
 108       }
 109     }
 110     return 0;
 111   }
 112
 113   virtual int32_t NeedMorePlayData(
 114       const uint32_t nSamples,
 115       const uint8_t nBytesPerSample,
 116       const uint8_t nChannels,
 117       const uint32_t sampleRate,
 118       void* audioSamples,
 119       uint32_t& nSamplesOut,
 120       int64_t* elapsed_time_ms,
 121       int64_t* ntp_time_ms) {
 122     play_count_++;
 123     if (play_count_ % 100 == 0) {
 124       if (nChannels == 1) {
 125         TEST_LOG("+");
 126       } else {
 127         TEST_LOG("++");
 128       }
 129     }
 130     nSamplesOut = 480;
 131     return 0;
 132   }
 133
 134   virtual int OnDataAvailable(const int voe_channels[],
 135                               int number_of_voe_channels,
 136                               const int16_t* audio_data,
 137                               int sample_rate,
 138                               int number_of_channels,
 139                               int number_of_frames,
 140                               int audio_delay_milliseconds,
 141                               int current_volume,
 142                               bool key_pressed,
 143                               bool need_audio_processing) {
 144     return 0;
 145   }
 146
 147   virtual void PushCaptureData(int voe_channel, const void* audio_data,
 148                                int bits_per_sample, int sample_rate,
 149                                int number_of_channels,
 150                                int number_of_frames) {}
 151
 152   virtual void PullRenderData(int bits_per_sample, int sample_rate,
 153                               int number_of_channels, int number_of_frames,
 154                               void* audio_data,
 155                               int64_t* elapsed_time_ms,
 156                               int64_t* ntp_time_ms) {}
 157  private:
 158   uint32_t rec_count_;
 159   uint32_t play_count_;
 160 };
 161
 162 class AudioDeviceAPITest: public testing::Test {
 163  protected:
 164   AudioDeviceAPITest() {}
 165
 166   virtual ~AudioDeviceAPITest() {}
 167
 168   static void SetUpTestCase() {
 169     process_thread_ = ProcessThread::CreateProcessThread();
 170     process_thread_->Start();
 171
 172     // Windows:
 173     //      if (WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
 174     //          user can select between default (Core) or Wave
 175     //      else
 176     //          user can select between default (Wave) or Wave
 177     const int32_t kId = 444;
 178
 179 #if defined(_WIN32)
 180     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 181                 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
 182 #if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
 183     TEST_LOG("WEBRTC_WINDOWS_CORE_AUDIO_BUILD is defined!\n\n");
 184     // create default implementation (=Core Audio) instance
 185     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 186                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
 187     audio_device_->AddRef();
 188     EXPECT_EQ(0, audio_device_->Release());
 189     // create non-default (=Wave Audio) instance
 190     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 191                 kId, AudioDeviceModule::kWindowsWaveAudio)) != NULL);
 192     audio_device_->AddRef();
 193     EXPECT_EQ(0, audio_device_->Release());
 194     // explicitly specify usage of Core Audio (same as default)
 195     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 196                 kId, AudioDeviceModule::kWindowsCoreAudio)) != NULL);
 197 #else
 198     TEST_LOG("WEBRTC_WINDOWS_CORE_AUDIO_BUILD is *not* defined!\n");
 199     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 200                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
 201     // create default implementation (=Wave Audio) instance
 202     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 203                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
 204     audio_device_->AddRef();
 205     EXPECT_EQ(0, audio_device_->Release());
 206     // explicitly specify usage of Wave Audio (same as default)
 207     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 208                 kId, AudioDeviceModule::kWindowsWaveAudio)) != NULL);
 209 #endif
 210 #endif
 211
 212 #if defined(ANDROID)
 213     // Fails tests
 214     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 215                 kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
 216     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 217                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
 218     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 219                 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
 220     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 221                 kId, AudioDeviceModule::kLinuxPulseAudio)) == NULL);
 222     // Create default implementation instance
 223     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 224                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
 225 #elif defined(WEBRTC_LINUX)
 226     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 227                 kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
 228     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 229                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
 230     // create default implementation instance
 231     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 232                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
 233     audio_device_->AddRef();
 234     EXPECT_EQ(0, audio_device_->Terminate());
 235     EXPECT_EQ(0, audio_device_->Release());
 236     // explicitly specify usage of Pulse Audio (same as default)
 237     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 238                 kId, AudioDeviceModule::kLinuxPulseAudio)) != NULL);
 239 #endif
 240
 241 #if defined(WEBRTC_MAC)
 242     // Fails tests
 243     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 244                 kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
 245     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 246                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
 247     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 248                 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
 249     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 250                 kId, AudioDeviceModule::kLinuxPulseAudio)) == NULL);
 251     // Create default implementation instance
 252     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
 253                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
 254 #endif
 255
 256     if (audio_device_ == NULL) {
 257       FAIL() << "Failed creating audio device object!";
 258     }
 259
 260     // The ADM is reference counted.
 261     audio_device_->AddRef();
 262
 263     process_thread_->RegisterModule(audio_device_);
 264
 265     AudioDeviceModule::AudioLayer audio_layer =
 266         AudioDeviceModule::kPlatformDefaultAudio;
 267     EXPECT_EQ(0, audio_device_->ActiveAudioLayer(&audio_layer));
 268     if (audio_layer == AudioDeviceModule::kLinuxAlsaAudio) {
 269       linux_alsa_ = true;
 270     }
 271   }
 272
 273   static void TearDownTestCase() {
 274     if (process_thread_) {
 275       process_thread_->DeRegisterModule(audio_device_);
 276       process_thread_->Stop();
 277       ProcessThread::DestroyProcessThread(process_thread_);
 278     }
 279     if (event_observer_) {
 280       delete event_observer_;
 281       event_observer_ = NULL;
 282     }
 283     if (audio_transport_) {
 284       delete audio_transport_;
 285       audio_transport_ = NULL;
 286     }
 287     if (audio_device_) {
 288       EXPECT_EQ(0, audio_device_->Release());
 289     }
 290     PRINT_TEST_RESULTS;
 291   }
 292
 293   void SetUp() {
 294     if (linux_alsa_) {
 295       FAIL() << "API Test is not available on ALSA on Linux!";
 296     }
 297     EXPECT_EQ(0, audio_device_->Init());
 298     EXPECT_TRUE(audio_device_->Initialized());
 299   }
 300
 301   void TearDown() {
 302     EXPECT_EQ(0, audio_device_->Terminate());
 303   }
 304
 305   void CheckVolume(uint32_t expected, uint32_t actual) {
 306     // Mac and Windows have lower resolution on the volume settings.
 307 #if defined(WEBRTC_MAC) || defined(_WIN32)
 308     int diff = abs(static_cast<int>(expected - actual));
 309     EXPECT_LE(diff, 5);
 310 #else
 311     EXPECT_TRUE((actual == expected) || (actual == expected-1));
 312 #endif
 313   }
 314
 315   void CheckInitialPlayoutStates() {
 316     EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 317     EXPECT_FALSE(audio_device_->Playing());
 318     EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
 319   }
 320
 321   void CheckInitialRecordingStates() {
 322     EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 323     EXPECT_FALSE(audio_device_->Recording());
 324     EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
 325   }
 326
 327   static bool linux_alsa_;
 328   static ProcessThread* process_thread_;
 329   static AudioDeviceModule* audio_device_;
 330   static AudioTransportAPI* audio_transport_;
 331   static AudioEventObserverAPI* event_observer_;
 332 };
 333
 334 // Must be initialized like this to handle static SetUpTestCase() above.
 335 bool AudioDeviceAPITest::linux_alsa_ = false;
 336 ProcessThread* AudioDeviceAPITest::process_thread_ = NULL;
 337 AudioDeviceModule* AudioDeviceAPITest::audio_device_ = NULL;
 338 AudioTransportAPI* AudioDeviceAPITest::audio_transport_ = NULL;
 339 AudioEventObserverAPI* AudioDeviceAPITest::event_observer_ = NULL;
 340
 341 TEST_F(AudioDeviceAPITest, RegisterEventObserver) {
 342   event_observer_ = new AudioEventObserverAPI(audio_device_);
 343   EXPECT_EQ(0, audio_device_->RegisterEventObserver(NULL));
 344   EXPECT_EQ(0, audio_device_->RegisterEventObserver(event_observer_));
 345   EXPECT_EQ(0, audio_device_->RegisterEventObserver(NULL));
 346 }
 347
 348 TEST_F(AudioDeviceAPITest, RegisterAudioCallback) {
 349   audio_transport_ = new AudioTransportAPI(audio_device_);
 350   EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
 351   EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
 352   EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
 353 }
 354
 355 TEST_F(AudioDeviceAPITest, Init) {
 356   EXPECT_TRUE(audio_device_->Initialized());
 357   EXPECT_EQ(0, audio_device_->Init());
 358   EXPECT_TRUE(audio_device_->Initialized());
 359   EXPECT_EQ(0, audio_device_->Terminate());
 360   EXPECT_FALSE(audio_device_->Initialized());
 361   EXPECT_EQ(0, audio_device_->Init());
 362   EXPECT_TRUE(audio_device_->Initialized());
 363   EXPECT_EQ(0, audio_device_->Terminate());
 364   EXPECT_FALSE(audio_device_->Initialized());
 365 }
 366
 367 TEST_F(AudioDeviceAPITest, Terminate) {
 368   EXPECT_TRUE(audio_device_->Initialized());
 369   EXPECT_EQ(0, audio_device_->Terminate());
 370   EXPECT_FALSE(audio_device_->Initialized());
 371   EXPECT_EQ(0, audio_device_->Terminate());
 372   EXPECT_FALSE(audio_device_->Initialized());
 373   EXPECT_EQ(0, audio_device_->Init());
 374   EXPECT_TRUE(audio_device_->Initialized());
 375   EXPECT_EQ(0, audio_device_->Terminate());
 376   EXPECT_FALSE(audio_device_->Initialized());
 377 }
 378
 379 TEST_F(AudioDeviceAPITest, PlayoutDevices) {
 380   EXPECT_GT(audio_device_->PlayoutDevices(), 0);
 381   EXPECT_GT(audio_device_->PlayoutDevices(), 0);
 382 }
 383
 384 TEST_F(AudioDeviceAPITest, RecordingDevices) {
 385   EXPECT_GT(audio_device_->RecordingDevices(), 0);
 386   EXPECT_GT(audio_device_->RecordingDevices(), 0);
 387 }
 388
 389 // TODO(henrika): uncomment when you have decided what to do with issue 3675.
 390 #if 0
 391 TEST_F(AudioDeviceAPITest, PlayoutDeviceName) {
 392   char name[kAdmMaxDeviceNameSize];
 393   char guid[kAdmMaxGuidSize];
 394   int16_t no_devices = audio_device_->PlayoutDevices();
 395
 396   // fail tests
 397   EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(-2, name, guid));
 398   EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(no_devices, name, guid));
 399   EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(0, NULL, guid));
 400
 401   // bulk tests
 402   EXPECT_EQ(0, audio_device_->PlayoutDeviceName(0, name, NULL));
 403 #ifdef _WIN32
 404   // shall be mapped to 0.
 405   EXPECT_EQ(0, audio_device_->PlayoutDeviceName(-1, name, NULL));
 406 #else
 407   EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(-1, name, NULL));
 408 #endif
 409   for (int i = 0; i < no_devices; i++) {
 410     EXPECT_EQ(0, audio_device_->PlayoutDeviceName(i, name, guid));
 411     EXPECT_EQ(0, audio_device_->PlayoutDeviceName(i, name, NULL));
 412   }
 413 }
 414
 415 TEST_F(AudioDeviceAPITest, RecordingDeviceName) {
 416   char name[kAdmMaxDeviceNameSize];
 417   char guid[kAdmMaxGuidSize];
 418   int16_t no_devices = audio_device_->RecordingDevices();
 419
 420   // fail tests
 421   EXPECT_EQ(-1, audio_device_->RecordingDeviceName(-2, name, guid));
 422   EXPECT_EQ(-1, audio_device_->RecordingDeviceName(no_devices, name, guid));
 423   EXPECT_EQ(-1, audio_device_->RecordingDeviceName(0, NULL, guid));
 424
 425   // bulk tests
 426   EXPECT_EQ(0, audio_device_->RecordingDeviceName(0, name, NULL));
 427 #ifdef _WIN32
 428   // shall me mapped to 0
 429   EXPECT_EQ(0, audio_device_->RecordingDeviceName(-1, name, NULL));
 430 #else
 431   EXPECT_EQ(-1, audio_device_->RecordingDeviceName(-1, name, NULL));
 432 #endif
 433   for (int i = 0; i < no_devices; i++) {
 434     EXPECT_EQ(0, audio_device_->RecordingDeviceName(i, name, guid));
 435     EXPECT_EQ(0, audio_device_->RecordingDeviceName(i, name, NULL));
 436   }
 437 }
 438
 439 TEST_F(AudioDeviceAPITest, SetPlayoutDevice) {
 440   int16_t no_devices = audio_device_->PlayoutDevices();
 441
 442   // fail tests
 443   EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(-1));
 444   EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(no_devices));
 445
 446   // bulk tests
 447 #ifdef _WIN32
 448   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
 449       AudioDeviceModule::kDefaultCommunicationDevice));
 450   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
 451       AudioDeviceModule::kDefaultDevice));
 452 #else
 453   EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(
 454       AudioDeviceModule::kDefaultCommunicationDevice));
 455   EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(
 456       AudioDeviceModule::kDefaultDevice));
 457 #endif
 458   for (int i = 0; i < no_devices; i++) {
 459     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
 460   }
 461 }
 462
 463 TEST_F(AudioDeviceAPITest, SetRecordingDevice) {
 464   EXPECT_EQ(0, audio_device_->Init());
 465   int16_t no_devices = audio_device_->RecordingDevices();
 466
 467   // fail tests
 468   EXPECT_EQ(-1, audio_device_->SetRecordingDevice(-1));
 469   EXPECT_EQ(-1, audio_device_->SetRecordingDevice(no_devices));
 470
 471   // bulk tests
 472 #ifdef _WIN32
 473   EXPECT_TRUE(audio_device_->SetRecordingDevice(
 474           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
 475   EXPECT_EQ(0, audio_device_->SetRecordingDevice(
 476       AudioDeviceModule::kDefaultDevice));
 477 #else
 478   EXPECT_TRUE(audio_device_->SetRecordingDevice(
 479       AudioDeviceModule::kDefaultCommunicationDevice) == -1);
 480   EXPECT_TRUE(audio_device_->SetRecordingDevice(
 481       AudioDeviceModule::kDefaultDevice) == -1);
 482 #endif
 483   for (int i = 0; i < no_devices; i++) {
 484     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
 485   }
 486 }
 487 #endif  // 0
 488
 489 TEST_F(AudioDeviceAPITest, PlayoutIsAvailable) {
 490   bool available;
 491 #ifdef _WIN32
 492   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
 493           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
 494   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 495   // Availability check should not initialize.
 496   EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 497
 498   EXPECT_EQ(0,
 499             audio_device_->SetPlayoutDevice(AudioDeviceModule::kDefaultDevice));
 500   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 501   EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 502 #endif
 503
 504   int16_t no_devices = audio_device_->PlayoutDevices();
 505   for (int i = 0; i < no_devices; i++) {
 506     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
 507     EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 508     EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 509   }
 510 }
 511
 512 TEST_F(AudioDeviceAPITest, RecordingIsAvailable) {
 513   bool available;
 514 #ifdef _WIN32
 515   EXPECT_EQ(0, audio_device_->SetRecordingDevice(
 516       AudioDeviceModule::kDefaultCommunicationDevice));
 517   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 518   EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 519
 520   EXPECT_EQ(0, audio_device_->SetRecordingDevice(
 521       AudioDeviceModule::kDefaultDevice));
 522   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 523   EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 524 #endif
 525
 526   int16_t no_devices = audio_device_->RecordingDevices();
 527   for (int i = 0; i < no_devices; i++) {
 528     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
 529     EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 530     EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 531   }
 532 }
 533
 534 TEST_F(AudioDeviceAPITest, InitPlayout) {
 535   // check initial state
 536   EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 537
 538   // ensure that device must be set before we can initialize
 539   EXPECT_EQ(-1, audio_device_->InitPlayout());
 540   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
 541   EXPECT_EQ(0, audio_device_->InitPlayout());
 542   EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
 543
 544   // bulk tests
 545   bool available;
 546   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 547   if (available) {
 548     EXPECT_EQ(0, audio_device_->InitPlayout());
 549     EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
 550     EXPECT_EQ(0, audio_device_->InitPlayout());
 551     EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(
 552         MACRO_DEFAULT_COMMUNICATION_DEVICE));
 553     EXPECT_EQ(0, audio_device_->StopPlayout());
 554     EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 555   }
 556
 557   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
 558       MACRO_DEFAULT_COMMUNICATION_DEVICE));
 559   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 560   if (available) {
 561     EXPECT_EQ(0, audio_device_->InitPlayout());
 562     // Sleep is needed for e.g. iPhone since we after stopping then starting may
 563     // have a hangover time of a couple of ms before initialized.
 564     SleepMs(50);
 565     EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
 566   }
 567
 568   int16_t no_devices = audio_device_->PlayoutDevices();
 569   for (int i = 0; i < no_devices; i++) {
 570     EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 571     if (available) {
 572       EXPECT_EQ(0, audio_device_->StopPlayout());
 573       EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 574       EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
 575       EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 576       if (available) {
 577         EXPECT_EQ(0, audio_device_->InitPlayout());
 578         EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
 579       }
 580     }
 581   }
 582   EXPECT_EQ(0, audio_device_->StopPlayout());
 583 }
 584
 585 TEST_F(AudioDeviceAPITest, InitRecording) {
 586   // check initial state
 587   EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 588
 589   // ensure that device must be set before we can initialize
 590   EXPECT_EQ(-1, audio_device_->InitRecording());
 591   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
 592   EXPECT_EQ(0, audio_device_->InitRecording());
 593   EXPECT_TRUE(audio_device_->RecordingIsInitialized());
 594
 595   // bulk tests
 596   bool available;
 597   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 598   if (available) {
 599     EXPECT_EQ(0, audio_device_->InitRecording());
 600     EXPECT_TRUE(audio_device_->RecordingIsInitialized());
 601     EXPECT_EQ(0, audio_device_->InitRecording());
 602     EXPECT_EQ(-1,
 603         audio_device_->SetRecordingDevice(MACRO_DEFAULT_COMMUNICATION_DEVICE));
 604     EXPECT_EQ(0, audio_device_->StopRecording());
 605     EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 606   }
 607
 608   EXPECT_EQ(0,
 609       audio_device_->SetRecordingDevice(MACRO_DEFAULT_COMMUNICATION_DEVICE));
 610   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 611   if (available) {
 612     EXPECT_EQ(0, audio_device_->InitRecording());
 613     SleepMs(50);
 614     EXPECT_TRUE(audio_device_->RecordingIsInitialized());
 615   }
 616
 617   int16_t no_devices = audio_device_->RecordingDevices();
 618   for (int i = 0; i < no_devices; i++) {
 619     EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 620     if (available) {
 621       EXPECT_EQ(0, audio_device_->StopRecording());
 622       EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 623       EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
 624       EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 625       if (available) {
 626         EXPECT_EQ(0, audio_device_->InitRecording());
 627         EXPECT_TRUE(audio_device_->RecordingIsInitialized());
 628       }
 629     }
 630   }
 631   EXPECT_EQ(0, audio_device_->StopRecording());
 632 }
 633
 634 TEST_F(AudioDeviceAPITest, StartAndStopPlayout) {
 635   bool available;
 636   EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
 637
 638   CheckInitialPlayoutStates();
 639
 640   EXPECT_EQ(-1, audio_device_->StartPlayout());
 641   EXPECT_EQ(0, audio_device_->StopPlayout());
 642
 643 #ifdef _WIN32
 644   // kDefaultCommunicationDevice
 645   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
 646           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
 647   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 648   if (available)
 649   {
 650     EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 651     EXPECT_EQ(0, audio_device_->InitPlayout());
 652     EXPECT_EQ(0, audio_device_->StartPlayout());
 653     EXPECT_TRUE(audio_device_->Playing());
 654     EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
 655     EXPECT_EQ(0, audio_device_->StopPlayout());
 656     EXPECT_FALSE(audio_device_->Playing());
 657     EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
 658   }
 659 #endif
 660
 661   // repeat test but for kDefaultDevice
 662   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
 663   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 664   if (available) {
 665     EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 666     EXPECT_EQ(0, audio_device_->InitPlayout());
 667     EXPECT_EQ(0, audio_device_->StartPlayout());
 668     EXPECT_TRUE(audio_device_->Playing());
 669     EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
 670     EXPECT_EQ(0, audio_device_->StopPlayout());
 671     EXPECT_FALSE(audio_device_->Playing());
 672   }
 673
 674   // repeat test for all devices
 675   int16_t no_devices = audio_device_->PlayoutDevices();
 676   for (int i = 0; i < no_devices; i++) {
 677     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
 678     EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 679     if (available) {
 680       EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 681       EXPECT_EQ(0, audio_device_->InitPlayout());
 682       EXPECT_EQ(0, audio_device_->StartPlayout());
 683       EXPECT_TRUE(audio_device_->Playing());
 684       EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
 685       EXPECT_EQ(0, audio_device_->StopPlayout());
 686       EXPECT_FALSE(audio_device_->Playing());
 687     }
 688   }
 689 }
 690
 691 TEST_F(AudioDeviceAPITest, StartAndStopRecording) {
 692   bool available;
 693   EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
 694
 695   CheckInitialRecordingStates();
 696
 697   EXPECT_EQ(-1, audio_device_->StartRecording());
 698   EXPECT_EQ(0, audio_device_->StopRecording());
 699
 700 #ifdef _WIN32
 701   // kDefaultCommunicationDevice
 702   EXPECT_TRUE(audio_device_->SetRecordingDevice(
 703           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
 704   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 705   if (available)
 706   {
 707     EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 708     EXPECT_EQ(0, audio_device_->InitRecording());
 709     EXPECT_EQ(0, audio_device_->StartRecording());
 710     EXPECT_TRUE(audio_device_->Recording());
 711     EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
 712     EXPECT_EQ(0, audio_device_->StopRecording());
 713     EXPECT_FALSE(audio_device_->Recording());
 714     EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
 715   }
 716 #endif
 717
 718   // repeat test but for kDefaultDevice
 719   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
 720   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 721   if (available) {
 722     EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 723     EXPECT_EQ(0, audio_device_->InitRecording());
 724     EXPECT_EQ(0, audio_device_->StartRecording());
 725     EXPECT_TRUE(audio_device_->Recording());
 726     EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
 727     EXPECT_EQ(0, audio_device_->StopRecording());
 728     EXPECT_FALSE(audio_device_->Recording());
 729   }
 730
 731   // repeat test for all devices
 732   int16_t no_devices = audio_device_->RecordingDevices();
 733   for (int i = 0; i < no_devices; i++) {
 734     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
 735     EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 736     if (available) {
 737       EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 738       EXPECT_EQ(0, audio_device_->InitRecording());
 739       EXPECT_EQ(0, audio_device_->StartRecording());
 740       EXPECT_TRUE(audio_device_->Recording());
 741       EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
 742       EXPECT_EQ(0, audio_device_->StopRecording());
 743       EXPECT_FALSE(audio_device_->Recording());
 744     }
 745   }
 746 }
 747
 748 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
 749 TEST_F(AudioDeviceAPITest, SetAndGetWaveOutVolume) {
 750   uint32_t vol(0);
 751   // NOTE 1: Windows Wave only!
 752   // NOTE 2: It seems like the waveOutSetVolume API returns
 753   // MMSYSERR_NOTSUPPORTED on some Vista machines!
 754   const uint16_t maxVol(0xFFFF);
 755   uint16_t volL, volR;
 756
 757   CheckInitialPlayoutStates();
 758
 759   // make dummy test to see if this API is supported
 760   int32_t works = audio_device_->SetWaveOutVolume(vol, vol);
 761   WARNING(works == 0);
 762
 763   if (works == 0)
 764   {
 765     // set volume without open playout device
 766     for (vol = 0; vol <= maxVol; vol += (maxVol/5))
 767     {
 768       EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol));
 769       EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR));
 770       EXPECT_TRUE((volL == vol) && (volR == vol));
 771     }
 772
 773     // repeat test but this time with an open (default) output device
 774     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
 775         AudioDeviceModule::kDefaultDevice));
 776     EXPECT_EQ(0, audio_device_->InitPlayout());
 777     EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
 778     for (vol = 0; vol <= maxVol; vol += (maxVol/5))
 779     {
 780       EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol));
 781       EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR));
 782       EXPECT_TRUE((volL == vol) && (volR == vol));
 783     }
 784
 785     // as above but while playout is active
 786     EXPECT_EQ(0, audio_device_->StartPlayout());
 787     EXPECT_TRUE(audio_device_->Playing());
 788     for (vol = 0; vol <= maxVol; vol += (maxVol/5))
 789     {
 790       EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol));
 791       EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR));
 792       EXPECT_TRUE((volL == vol) && (volR == vol));
 793     }
 794   }
 795
 796   EXPECT_EQ(0, audio_device_->StopPlayout());
 797   EXPECT_FALSE(audio_device_->Playing());
 798 }
 799 #endif  // defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
 800
 801 TEST_F(AudioDeviceAPITest, InitSpeaker) {
 802   // NOTE: By calling Terminate (in TearDown) followed by Init (in SetUp) we
 803   // ensure that any existing output mixer handle is set to NULL.
 804   // The mixer handle is closed and reopened again for each call to
 805   // SetPlayoutDevice.
 806   CheckInitialPlayoutStates();
 807
 808   // kDefaultCommunicationDevice
 809   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
 810       MACRO_DEFAULT_COMMUNICATION_DEVICE));
 811   EXPECT_EQ(0, audio_device_->InitSpeaker());
 812
 813   // fail tests
 814   bool available;
 815   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
 816   if (available) {
 817     EXPECT_EQ(0, audio_device_->InitPlayout());
 818     EXPECT_EQ(0, audio_device_->StartPlayout());
 819     EXPECT_EQ(-1, audio_device_->InitSpeaker());
 820     EXPECT_EQ(0, audio_device_->StopPlayout());
 821   }
 822
 823   // kDefaultDevice
 824   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
 825   EXPECT_EQ(0, audio_device_->InitSpeaker());
 826
 827   // repeat test for all devices
 828   int16_t no_devices = audio_device_->PlayoutDevices();
 829   for (int i = 0; i < no_devices; i++) {
 830     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
 831     EXPECT_EQ(0, audio_device_->InitSpeaker());
 832   }
 833 }
 834
 835 TEST_F(AudioDeviceAPITest, InitMicrophone) {
 836   // NOTE: By calling Terminate (in TearDown) followed by Init (in SetUp) we
 837   // ensure that any existing output mixer handle is set to NULL.
 838   // The mixer handle is closed and reopened again for each call to
 839   // SetRecordingDevice.
 840   CheckInitialRecordingStates();
 841
 842   // kDefaultCommunicationDevice
 843   EXPECT_EQ(0,
 844       audio_device_->SetRecordingDevice(MACRO_DEFAULT_COMMUNICATION_DEVICE));
 845   EXPECT_EQ(0, audio_device_->InitMicrophone());
 846
 847   // fail tests
 848   bool available;
 849   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
 850   if (available) {
 851     EXPECT_EQ(0, audio_device_->InitRecording());
 852     EXPECT_EQ(0, audio_device_->StartRecording());
 853     EXPECT_EQ(-1, audio_device_->InitMicrophone());
 854     EXPECT_EQ(0, audio_device_->StopRecording());
 855   }
 856
 857   // kDefaultDevice
 858   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
 859   EXPECT_EQ(0, audio_device_->InitMicrophone());
 860
 861   // repeat test for all devices
 862   int16_t no_devices = audio_device_->RecordingDevices();
 863   for (int i = 0; i < no_devices; i++) {
 864     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
 865     EXPECT_EQ(0, audio_device_->InitMicrophone());
 866   }
 867 }
 868
 869 TEST_F(AudioDeviceAPITest, SpeakerVolumeIsAvailable) {
 870   CheckInitialPlayoutStates();
 871   bool available;
 872
 873 #ifdef _WIN32
 874   // check the kDefaultCommunicationDevice
 875   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
 876           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
 877   EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
 878   // check for availability should not lead to initialization
 879   EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
 880 #endif
 881
 882   // check the kDefaultDevice
 883   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
 884   EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
 885   EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
 886
 887   // check all availiable devices
 888   int16_t no_devices = audio_device_->PlayoutDevices();
 889   for (int i = 0; i < no_devices; i++) {
 890     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
 891     EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
 892     EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
 893   }
 894 }
 895
 896 // Tests the following methods:
 897 // SetSpeakerVolume
 898 // SpeakerVolume
 899 // MaxSpeakerVolume
 900 // MinSpeakerVolume
 901 // NOTE: Disabled on mac due to issue 257.
 902 #ifndef WEBRTC_MAC
 903 TEST_F(AudioDeviceAPITest, SpeakerVolumeTests) {
 904   uint32_t vol(0);
 905   uint32_t volume(0);
 906   uint32_t maxVolume(0);
 907   uint32_t minVolume(0);
 908   uint16_t stepSize(0);
 909   bool available;
 910   CheckInitialPlayoutStates();
 911
 912   // fail tests
 913   EXPECT_EQ(-1, audio_device_->SetSpeakerVolume(0));
 914   // speaker must be initialized first
 915   EXPECT_EQ(-1, audio_device_->SpeakerVolume(&volume));
 916   EXPECT_EQ(-1, audio_device_->MaxSpeakerVolume(&maxVolume));
 917   EXPECT_EQ(-1, audio_device_->MinSpeakerVolume(&minVolume));
 918   EXPECT_EQ(-1, audio_device_->SpeakerVolumeStepSize(&stepSize));
 919
 920 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
 921   // test for warning (can e.g. happen on Vista with Wave API)
 922   EXPECT_EQ(0,
 923             audio_device_->SetPlayoutDevice(AudioDeviceModule::kDefaultDevice));
 924   EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
 925   if (available) {
 926     EXPECT_EQ(0, audio_device_->InitSpeaker());
 927     EXPECT_EQ(0, audio_device_->SetSpeakerVolume(19001));
 928     EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume));
 929     WARNING(volume == 19001);
 930   }
 931 #endif
 932
 933 #ifdef _WIN32
 934   // use kDefaultCommunicationDevice and modify/retrieve the volume
 935   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
 936           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
 937   EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
 938   if (available) {
 939     EXPECT_EQ(0, audio_device_->InitSpeaker());
 940     EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume));
 941     EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume));
 942     EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize));
 943     for (vol = minVolume; vol < (int)maxVolume; vol += 20*stepSize) {
 944       EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol));
 945       EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume));
 946       CheckVolume(volume, vol);
 947     }
 948   }
 949 #endif
 950
 951   // use kDefaultDevice and modify/retrieve the volume
 952   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
 953   EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
 954   if (available) {
 955     EXPECT_EQ(0, audio_device_->InitSpeaker());
 956     EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume));
 957     EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume));
 958     EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize));
 959     uint32_t step = (maxVolume - minVolume) / 10;
 960     step = (step < stepSize ? stepSize : step);
 961     for (vol = minVolume; vol <= maxVolume; vol += step) {
 962       EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol));
 963       EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume));
 964       CheckVolume(volume, vol);
 965     }
 966   }
 967
 968   // use all (indexed) devices and modify/retrieve the volume
 969   int16_t no_devices = audio_device_->PlayoutDevices();
 970   for (int i = 0; i < no_devices; i++) {
 971     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
 972     EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
 973     if (available) {
 974       EXPECT_EQ(0, audio_device_->InitSpeaker());
 975       EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume));
 976       EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume));
 977       EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize));
 978       uint32_t step = (maxVolume - minVolume) / 10;
 979       step = (step < stepSize ? stepSize : step);
 980       for (vol = minVolume; vol <= maxVolume; vol += step) {
 981         EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol));
 982         EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume));
 983         CheckVolume(volume, vol);
 984       }
 985     }
 986   }
 987
 988   // restore reasonable level
 989   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
 990   EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
 991   if (available) {
 992     EXPECT_EQ(0, audio_device_->InitSpeaker());
 993     EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume));
 994     EXPECT_TRUE(audio_device_->SetSpeakerVolume(maxVolume < 10 ?
 995         maxVolume/3 : maxVolume/10) == 0);
 996   }
 997 }
 998 #endif  // !WEBRTC_MAC
 999
1000 TEST_F(AudioDeviceAPITest, AGC) {
1001   // NOTE: The AGC API only enables/disables the AGC. To ensure that it will
1002   // have an effect, use it in combination with MicrophoneVolumeIsAvailable.
1003   CheckInitialRecordingStates();
1004   EXPECT_FALSE(audio_device_->AGC());
1005
1006   // set/get tests
1007   EXPECT_EQ(0, audio_device_->SetAGC(true));
1008   EXPECT_TRUE(audio_device_->AGC());
1009   EXPECT_EQ(0, audio_device_->SetAGC(false));
1010   EXPECT_FALSE(audio_device_->AGC());
1011 }
1012
1013 TEST_F(AudioDeviceAPITest, MicrophoneVolumeIsAvailable) {
1014   CheckInitialRecordingStates();
1015   bool available;
1016
1017 #ifdef _WIN32
1018   // check the kDefaultCommunicationDevice
1019   EXPECT_TRUE(audio_device_->SetRecordingDevice(
1020           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1021   EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1022   // check for availability should not lead to initialization
1023   EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1024 #endif
1025
1026   // check the kDefaultDevice
1027   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1028   EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1029   EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1030
1031   // check all availiable devices
1032   int16_t no_devices = audio_device_->RecordingDevices();
1033   for (int i = 0; i < no_devices; i++) {
1034     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
1035     EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1036     EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1037   }
1038 }
1039
1040 // Tests the methods:
1041 // SetMicrophoneVolume
1042 // MicrophoneVolume
1043 // MaxMicrophoneVolume
1044 // MinMicrophoneVolume
1045 // NOTE: Disabled on mac due to issue 257.
1046 #ifndef WEBRTC_MAC
1047 TEST_F(AudioDeviceAPITest, MicrophoneVolumeTests) {
1048   uint32_t vol(0);
1049   uint32_t volume(0);
1050   uint32_t maxVolume(0);
1051   uint32_t minVolume(0);
1052   uint16_t stepSize(0);
1053   bool available;
1054   CheckInitialRecordingStates();
1055
1056   // fail tests
1057   EXPECT_EQ(-1, audio_device_->SetMicrophoneVolume(0));
1058   // must be initialized first
1059   EXPECT_EQ(-1, audio_device_->MicrophoneVolume(&volume));
1060   EXPECT_EQ(-1, audio_device_->MaxMicrophoneVolume(&maxVolume));
1061   EXPECT_EQ(-1, audio_device_->MinMicrophoneVolume(&minVolume));
1062   EXPECT_EQ(-1, audio_device_->MicrophoneVolumeStepSize(&stepSize));
1063
1064 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
1065   // test for warning (can e.g. happen on Vista with Wave API)
1066   EXPECT_EQ(0, audio_device_->SetRecordingDevice(
1067       AudioDeviceModule::kDefaultDevice));
1068   EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1069   if (available)
1070   {
1071     EXPECT_EQ(0, audio_device_->InitMicrophone());
1072     EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(19001));
1073     EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume));
1074     WARNING(volume == 19001);
1075   }
1076 #endif
1077
1078 #ifdef _WIN32
1079   // initialize kDefaultCommunicationDevice and modify/retrieve the volume
1080   EXPECT_TRUE(audio_device_->SetRecordingDevice(
1081           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1082   EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1083   if (available)
1084   {
1085     EXPECT_EQ(0, audio_device_->InitMicrophone());
1086     EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume));
1087     EXPECT_EQ(0, audio_device_->MinMicrophoneVolume(&minVolume));
1088     EXPECT_EQ(0, audio_device_->MicrophoneVolumeStepSize(&stepSize));
1089     for (vol = minVolume; vol < (int)maxVolume; vol += 10*stepSize)
1090     {
1091       EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(vol));
1092       EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume));
1093       CheckVolume(volume, vol);
1094     }
1095   }
1096 #endif
1097
1098   // reinitialize kDefaultDevice and modify/retrieve the volume
1099   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1100   EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1101   if (available) {
1102     EXPECT_EQ(0, audio_device_->InitMicrophone());
1103     EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume));
1104     EXPECT_EQ(0, audio_device_->MinMicrophoneVolume(&minVolume));
1105     EXPECT_EQ(0, audio_device_->MicrophoneVolumeStepSize(&stepSize));
1106     for (vol = minVolume; vol < maxVolume; vol += 10 * stepSize) {
1107       EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(vol));
1108       EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume));
1109       CheckVolume(volume, vol);
1110     }
1111   }
1112
1113   // use all (indexed) devices and modify/retrieve the volume
1114   int16_t no_devices = audio_device_->RecordingDevices();
1115   for (int i = 0; i < no_devices; i++) {
1116     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
1117     EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1118     if (available) {
1119       EXPECT_EQ(0, audio_device_->InitMicrophone());
1120       EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume));
1121       EXPECT_EQ(0, audio_device_->MinMicrophoneVolume(&minVolume));
1122       EXPECT_EQ(0, audio_device_->MicrophoneVolumeStepSize(&stepSize));
1123       for (vol = minVolume; vol < maxVolume; vol += 20 * stepSize) {
1124         EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(vol));
1125         EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume));
1126         CheckVolume(volume, vol);
1127       }
1128     }
1129   }
1130
1131   // restore reasonable level
1132   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1133   EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
1134   if (available) {
1135     EXPECT_EQ(0, audio_device_->InitMicrophone());
1136     EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume));
1137     EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(maxVolume/10));
1138   }
1139 }
1140 #endif  // !WEBRTC_MAC
1141
1142 TEST_F(AudioDeviceAPITest, SpeakerMuteIsAvailable) {
1143   bool available;
1144   CheckInitialPlayoutStates();
1145 #ifdef _WIN32
1146   // check the kDefaultCommunicationDevice
1147   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
1148           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1149   EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1150   // check for availability should not lead to initialization
1151   EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
1152 #endif
1153
1154   // check the kDefaultDevice
1155   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
1156   EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1157   EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
1158
1159   // check all availiable devices
1160   int16_t no_devices = audio_device_->PlayoutDevices();
1161   for (int i = 0; i < no_devices; i++) {
1162     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
1163     EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1164     EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
1165   }
1166 }
1167
1168 TEST_F(AudioDeviceAPITest, MicrophoneMuteIsAvailable) {
1169   bool available;
1170   CheckInitialRecordingStates();
1171 #ifdef _WIN32
1172   // check the kDefaultCommunicationDevice
1173   EXPECT_TRUE(audio_device_->SetRecordingDevice(
1174           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1175   EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1176   // check for availability should not lead to initialization
1177 #endif
1178   EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1179
1180   // check the kDefaultDevice
1181   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1182   EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1183   EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1184
1185   // check all availiable devices
1186   int16_t no_devices = audio_device_->RecordingDevices();
1187   for (int i = 0; i < no_devices; i++) {
1188     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
1189     EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1190     EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1191   }
1192 }
1193
1194 TEST_F(AudioDeviceAPITest, MicrophoneBoostIsAvailable) {
1195   bool available;
1196   CheckInitialRecordingStates();
1197 #ifdef _WIN32
1198   // check the kDefaultCommunicationDevice
1199   EXPECT_TRUE(audio_device_->SetRecordingDevice(
1200           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1201   EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1202   // check for availability should not lead to initialization
1203   EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1204 #endif
1205
1206   // check the kDefaultDevice
1207   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1208   EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1209   EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1210
1211   // check all availiable devices
1212   int16_t no_devices = audio_device_->RecordingDevices();
1213   for (int i = 0; i < no_devices; i++) {
1214     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
1215     EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1216     EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
1217   }
1218 }
1219
1220 TEST_F(AudioDeviceAPITest, SpeakerMuteTests) {
1221   bool available;
1222   bool enabled;
1223   CheckInitialPlayoutStates();
1224   // fail tests
1225   EXPECT_EQ(-1, audio_device_->SetSpeakerMute(true));
1226   // requires initialization
1227   EXPECT_EQ(-1, audio_device_->SpeakerMute(&enabled));
1228
1229 #ifdef _WIN32
1230   // initialize kDefaultCommunicationDevice and modify/retrieve the mute state
1231   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
1232       AudioDeviceModule::kDefaultCommunicationDevice));
1233   EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1234   if (available)
1235   {
1236     EXPECT_EQ(0, audio_device_->InitSpeaker());
1237     EXPECT_EQ(0, audio_device_->SetSpeakerMute(true));
1238     EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1239     EXPECT_TRUE(enabled);
1240     EXPECT_EQ(0, audio_device_->SetSpeakerMute(false));
1241     EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1242     EXPECT_FALSE(enabled);
1243   }
1244 #endif
1245
1246   // reinitialize kDefaultDevice and modify/retrieve the mute state
1247   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
1248   EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1249   if (available) {
1250     EXPECT_EQ(0, audio_device_->InitSpeaker());
1251     EXPECT_EQ(0, audio_device_->SetSpeakerMute(true));
1252     EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1253     EXPECT_TRUE(enabled);
1254     EXPECT_EQ(0, audio_device_->SetSpeakerMute(false));
1255     EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1256     EXPECT_FALSE(enabled);
1257   }
1258
1259   // reinitialize the default device (0) and modify/retrieve the mute state
1260   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(0));
1261   EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
1262   if (available) {
1263     EXPECT_EQ(0, audio_device_->InitSpeaker());
1264     EXPECT_EQ(0, audio_device_->SetSpeakerMute(true));
1265     EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1266     EXPECT_TRUE(enabled);
1267     EXPECT_EQ(0, audio_device_->SetSpeakerMute(false));
1268     EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
1269     EXPECT_FALSE(enabled);
1270   }
1271 }
1272
1273 TEST_F(AudioDeviceAPITest, MicrophoneMuteTests) {
1274   CheckInitialRecordingStates();
1275
1276   // fail tests
1277   EXPECT_EQ(-1, audio_device_->SetMicrophoneMute(true));
1278   // requires initialization
1279   bool available;
1280   bool enabled;
1281   EXPECT_EQ(-1, audio_device_->MicrophoneMute(&enabled));
1282
1283 #ifdef _WIN32
1284   // initialize kDefaultCommunicationDevice and modify/retrieve the mute
1285   EXPECT_TRUE(audio_device_->SetRecordingDevice(
1286           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1287   EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1288   if (available)
1289   {
1290     EXPECT_EQ(0, audio_device_->InitMicrophone());
1291     EXPECT_EQ(0, audio_device_->SetMicrophoneMute(true));
1292     EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1293     EXPECT_TRUE(enabled);
1294     EXPECT_EQ(0, audio_device_->SetMicrophoneMute(false));
1295     EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1296     EXPECT_FALSE(enabled);
1297   }
1298 #endif
1299
1300   // reinitialize kDefaultDevice and modify/retrieve the mute
1301   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1302   EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1303   if (available) {
1304     EXPECT_EQ(0, audio_device_->InitMicrophone());
1305     EXPECT_EQ(0, audio_device_->SetMicrophoneMute(true));
1306     EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1307     EXPECT_TRUE(enabled);
1308     EXPECT_EQ(0, audio_device_->SetMicrophoneMute(false));
1309     EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1310     EXPECT_FALSE(enabled);
1311   }
1312
1313   // reinitialize the default device (0) and modify/retrieve the Mute
1314   EXPECT_EQ(0, audio_device_->SetRecordingDevice(0));
1315   EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
1316   if (available) {
1317     EXPECT_EQ(0, audio_device_->InitMicrophone());
1318     EXPECT_EQ(0, audio_device_->SetMicrophoneMute(true));
1319     EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1320     EXPECT_TRUE(enabled);
1321     EXPECT_EQ(0, audio_device_->SetMicrophoneMute(false));
1322     EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
1323     EXPECT_FALSE(enabled);
1324   }
1325 }
1326
1327 TEST_F(AudioDeviceAPITest, MicrophoneBoostTests) {
1328   bool available;
1329   bool enabled;
1330   CheckInitialRecordingStates();
1331
1332   // fail tests
1333   EXPECT_EQ(-1, audio_device_->SetMicrophoneBoost(true));
1334   // requires initialization
1335   EXPECT_EQ(-1, audio_device_->MicrophoneBoost(&enabled));
1336
1337 #ifdef _WIN32
1338   // initialize kDefaultCommunicationDevice and modify/retrieve the boost
1339   EXPECT_TRUE(audio_device_->SetRecordingDevice(
1340           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
1341   EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1342   if (available)
1343   {
1344     EXPECT_EQ(0, audio_device_->InitMicrophone());
1345     EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(true));
1346     EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1347     EXPECT_TRUE(enabled);
1348     EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(false));
1349     EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1350     EXPECT_FALSE(enabled);
1351   }
1352 #endif
1353
1354   // reinitialize kDefaultDevice and modify/retrieve the boost
1355   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1356   EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1357   if (available) {
1358     EXPECT_EQ(0, audio_device_->InitMicrophone());
1359     EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(true));
1360     EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1361     EXPECT_TRUE(enabled);
1362     EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(false));
1363     EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1364     EXPECT_FALSE(enabled);
1365   }
1366
1367   // reinitialize the default device (0) and modify/retrieve the boost
1368   EXPECT_EQ(0, audio_device_->SetRecordingDevice(0));
1369   EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
1370   if (available) {
1371     EXPECT_EQ(0, audio_device_->InitMicrophone());
1372     EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(true));
1373     EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1374     EXPECT_TRUE(enabled);
1375     EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(false));
1376     EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
1377     EXPECT_FALSE(enabled);
1378   }
1379 }
1380
1381 TEST_F(AudioDeviceAPITest, StereoPlayoutTests) {
1382   CheckInitialPlayoutStates();
1383
1384   // fail tests
1385   EXPECT_EQ(-1, audio_device_->InitPlayout());
1386   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
1387       MACRO_DEFAULT_COMMUNICATION_DEVICE));
1388
1389   // TODO(kjellander): Fix so these tests pass on Mac.
1390 #if !defined(WEBRTC_MAC)
1391   EXPECT_EQ(0, audio_device_->InitPlayout());
1392   EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
1393   // must be performed before initialization
1394   EXPECT_EQ(-1, audio_device_->SetStereoPlayout(true));
1395 #endif
1396
1397   // ensure that we can set the stereo mode for playout
1398   EXPECT_EQ(0, audio_device_->StopPlayout());
1399   EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
1400
1401   // initialize kDefaultCommunicationDevice and modify/retrieve stereo support
1402   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
1403       MACRO_DEFAULT_COMMUNICATION_DEVICE));
1404   bool available;
1405   bool enabled;
1406   EXPECT_EQ(0, audio_device_->StereoPlayoutIsAvailable(&available));
1407   if (available) {
1408     EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1409     EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1410     EXPECT_TRUE(enabled);
1411     EXPECT_EQ(0, audio_device_->SetStereoPlayout(false));
1412     EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1413     EXPECT_FALSE(enabled);
1414     EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1415     EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1416     EXPECT_TRUE(enabled);
1417   }
1418
1419   // initialize kDefaultDevice and modify/retrieve stereo support
1420   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
1421   EXPECT_EQ(0, audio_device_->StereoPlayoutIsAvailable(&available));
1422   if (available) {
1423     EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1424     EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1425     EXPECT_TRUE(enabled);
1426     EXPECT_EQ(0, audio_device_->SetStereoPlayout(false));
1427     EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1428     EXPECT_FALSE(enabled);
1429     EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1430     EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1431     EXPECT_TRUE(enabled);
1432   }
1433
1434   // initialize default device (0) and modify/retrieve stereo support
1435   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(0));
1436   EXPECT_EQ(0, audio_device_->StereoPlayoutIsAvailable(&available));
1437   if (available) {
1438     EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1439     EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1440     EXPECT_TRUE(enabled);
1441     EXPECT_EQ(0, audio_device_->SetStereoPlayout(false));
1442     EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1443     EXPECT_FALSE(enabled);
1444     EXPECT_EQ(0, audio_device_->SetStereoPlayout(true));
1445     EXPECT_EQ(0, audio_device_->StereoPlayout(&enabled));
1446     EXPECT_TRUE(enabled);
1447   }
1448 }
1449
1450 TEST_F(AudioDeviceAPITest, StereoRecordingTests) {
1451   CheckInitialRecordingStates();
1452   EXPECT_FALSE(audio_device_->Playing());
1453
1454   // fail tests
1455   EXPECT_EQ(-1, audio_device_->InitRecording());
1456   EXPECT_EQ(0, audio_device_->SetRecordingDevice(
1457       MACRO_DEFAULT_COMMUNICATION_DEVICE));
1458
1459   // TODO(kjellander): Fix so these tests pass on Mac.
1460 #if !defined(WEBRTC_MAC)
1461   EXPECT_EQ(0, audio_device_->InitRecording());
1462   EXPECT_TRUE(audio_device_->RecordingIsInitialized());
1463   // must be performed before initialization
1464   EXPECT_EQ(-1, audio_device_->SetStereoRecording(true));
1465 #endif
1466   // ensures that we can set the stereo mode for recording
1467   EXPECT_EQ(0, audio_device_->StopRecording());
1468   EXPECT_FALSE(audio_device_->RecordingIsInitialized());
1469
1470   // initialize kDefaultCommunicationDevice and modify/retrieve stereo support
1471   EXPECT_EQ(0, audio_device_->SetRecordingDevice(
1472       MACRO_DEFAULT_COMMUNICATION_DEVICE));
1473   bool available;
1474   bool enabled;
1475   EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available));
1476   if (available) {
1477     EXPECT_EQ(0, audio_device_->SetStereoRecording(true));
1478     EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1479     EXPECT_TRUE(enabled);
1480     EXPECT_EQ(0, audio_device_->SetStereoRecording(false));
1481     EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1482     EXPECT_FALSE(enabled);
1483   }
1484
1485   // initialize kDefaultDevice and modify/retrieve stereo support
1486   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1487   EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available));
1488   if (available) {
1489     EXPECT_EQ(0, audio_device_->SetStereoRecording(true));
1490     EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1491     EXPECT_TRUE(enabled);
1492     EXPECT_EQ(0, audio_device_->SetStereoRecording(false));
1493     EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1494     EXPECT_FALSE(enabled);
1495   }
1496
1497   // initialize default device (0) and modify/retrieve stereo support
1498   EXPECT_EQ(0, audio_device_->SetRecordingDevice(0));
1499   EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available));
1500   if (available) {
1501     EXPECT_EQ(0, audio_device_->SetStereoRecording(true));
1502     EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1503     EXPECT_TRUE(enabled);
1504     EXPECT_EQ(0, audio_device_->SetStereoRecording(false));
1505     EXPECT_EQ(0, audio_device_->StereoRecording(&enabled));
1506     EXPECT_FALSE(enabled);
1507   }
1508 }
1509
1510 TEST_F(AudioDeviceAPITest, RecordingChannelTests) {
1511   // the user in Win Core Audio
1512   AudioDeviceModule::ChannelType channelType(AudioDeviceModule::kChannelBoth);
1513   CheckInitialRecordingStates();
1514   EXPECT_FALSE(audio_device_->Playing());
1515
1516   // fail tests
1517   EXPECT_EQ(0, audio_device_->SetStereoRecording(false));
1518   EXPECT_EQ(-1, audio_device_->SetRecordingChannel(
1519       AudioDeviceModule::kChannelBoth));
1520
1521   // initialize kDefaultCommunicationDevice and modify/retrieve stereo support
1522   EXPECT_EQ(0, audio_device_->SetRecordingDevice(
1523       MACRO_DEFAULT_COMMUNICATION_DEVICE));
1524   bool available;
1525   EXPECT_EQ(0, audio_device_->StereoRecordingIsAvailable(&available));
1526   if (available) {
1527     EXPECT_EQ(0, audio_device_->SetStereoRecording(true));
1528     EXPECT_EQ(0, audio_device_->SetRecordingChannel(
1529         AudioDeviceModule::kChannelBoth));
1530     EXPECT_EQ(0, audio_device_->RecordingChannel(&channelType));
1531     EXPECT_EQ(AudioDeviceModule::kChannelBoth, channelType);
1532     EXPECT_EQ(0, audio_device_->SetRecordingChannel(
1533         AudioDeviceModule::kChannelLeft));
1534     EXPECT_EQ(0, audio_device_->RecordingChannel(&channelType));
1535     EXPECT_EQ(AudioDeviceModule::kChannelLeft, channelType);
1536     EXPECT_EQ(0, audio_device_->SetRecordingChannel(
1537         AudioDeviceModule::kChannelRight));
1538     EXPECT_EQ(0, audio_device_->RecordingChannel(&channelType));
1539     EXPECT_EQ(AudioDeviceModule::kChannelRight, channelType);
1540   }
1541 }
1542
1543 TEST_F(AudioDeviceAPITest, PlayoutBufferTests) {
1544   AudioDeviceModule::BufferType bufferType;
1545   uint16_t sizeMS(0);
1546
1547   CheckInitialPlayoutStates();
1548   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1549 #if defined(_WIN32) || defined(ANDROID) || defined(WEBRTC_IOS)
1550   EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType);
1551 #else
1552   EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
1553 #endif
1554
1555   // fail tests
1556   EXPECT_EQ(-1, audio_device_->InitPlayout());
1557   // must set device first
1558   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
1559       MACRO_DEFAULT_COMMUNICATION_DEVICE));
1560
1561   // TODO(kjellander): Fix so these tests pass on Mac.
1562 #if !defined(WEBRTC_MAC)
1563   EXPECT_EQ(0, audio_device_->InitPlayout());
1564   EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
1565 #endif
1566   EXPECT_TRUE(audio_device_->SetPlayoutBuffer(
1567       AudioDeviceModule::kAdaptiveBufferSize, 100) == -1);
1568   EXPECT_EQ(0, audio_device_->StopPlayout());
1569   EXPECT_TRUE(audio_device_->SetPlayoutBuffer(
1570       AudioDeviceModule::kFixedBufferSize, kAdmMinPlayoutBufferSizeMs-1) == -1);
1571   EXPECT_TRUE(audio_device_->SetPlayoutBuffer(
1572       AudioDeviceModule::kFixedBufferSize, kAdmMaxPlayoutBufferSizeMs+1) == -1);
1573
1574   // bulk tests (all should be successful)
1575   EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
1576 #ifdef _WIN32
1577   EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1578       AudioDeviceModule::kAdaptiveBufferSize, 0));
1579   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1580   EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType);
1581   EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1582       AudioDeviceModule::kAdaptiveBufferSize, 10000));
1583   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1584   EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType);
1585 #endif
1586 #if defined(ANDROID) || defined(WEBRTC_IOS)
1587   EXPECT_EQ(-1,
1588             audio_device_->SetPlayoutBuffer(AudioDeviceModule::kFixedBufferSize,
1589                                           kAdmMinPlayoutBufferSizeMs));
1590 #else
1591   EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1592       AudioDeviceModule::kFixedBufferSize, kAdmMinPlayoutBufferSizeMs));
1593   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1594   EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
1595   EXPECT_EQ(kAdmMinPlayoutBufferSizeMs, sizeMS);
1596   EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1597       AudioDeviceModule::kFixedBufferSize, kAdmMaxPlayoutBufferSizeMs));
1598   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1599   EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
1600   EXPECT_EQ(kAdmMaxPlayoutBufferSizeMs, sizeMS);
1601   EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1602       AudioDeviceModule::kFixedBufferSize, 100));
1603   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1604   EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
1605   EXPECT_EQ(100, sizeMS);
1606 #endif
1607
1608 #ifdef _WIN32
1609   // restore default
1610   EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
1611       AudioDeviceModule::kAdaptiveBufferSize, 0));
1612   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
1613 #endif
1614 }
1615
1616 TEST_F(AudioDeviceAPITest, PlayoutDelay) {
1617   // NOTE: this API is better tested in a functional test
1618   uint16_t sizeMS(0);
1619   CheckInitialPlayoutStates();
1620   // bulk tests
1621   EXPECT_EQ(0, audio_device_->PlayoutDelay(&sizeMS));
1622   EXPECT_EQ(0, audio_device_->PlayoutDelay(&sizeMS));
1623 }
1624
1625 TEST_F(AudioDeviceAPITest, RecordingDelay) {
1626   // NOTE: this API is better tested in a functional test
1627   uint16_t sizeMS(0);
1628   CheckInitialRecordingStates();
1629
1630   // bulk tests
1631   EXPECT_EQ(0, audio_device_->RecordingDelay(&sizeMS));
1632   EXPECT_EQ(0, audio_device_->RecordingDelay(&sizeMS));
1633 }
1634
1635 TEST_F(AudioDeviceAPITest, CPULoad) {
1636   // NOTE: this API is better tested in a functional test
1637   uint16_t load(0);
1638
1639   // bulk tests
1640 #ifdef _WIN32
1641   EXPECT_EQ(0, audio_device_->CPULoad(&load));
1642   EXPECT_EQ(0, load);
1643 #else
1644   EXPECT_EQ(-1, audio_device_->CPULoad(&load));
1645 #endif
1646 }
1647
1648 // TODO(kjellander): Fix flakiness causing failures on Windows.
1649 // TODO(phoglund):  Fix flakiness causing failures on Linux.
1650 #if !defined(_WIN32) && !defined(WEBRTC_LINUX)
1651 TEST_F(AudioDeviceAPITest, StartAndStopRawOutputFileRecording) {
1652   // NOTE: this API is better tested in a functional test
1653   CheckInitialPlayoutStates();
1654
1655   // fail tests
1656   EXPECT_EQ(-1, audio_device_->StartRawOutputFileRecording(NULL));
1657
1658   // bulk tests
1659   EXPECT_EQ(0, audio_device_->StartRawOutputFileRecording(
1660       GetFilename("raw_output_not_playing.pcm")));
1661   EXPECT_EQ(0, audio_device_->StopRawOutputFileRecording());
1662   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
1663       MACRO_DEFAULT_COMMUNICATION_DEVICE));
1664
1665   // TODO(kjellander): Fix so these tests pass on Mac.
1666 #if !defined(WEBRTC_MAC)
1667   EXPECT_EQ(0, audio_device_->InitPlayout());
1668   EXPECT_EQ(0, audio_device_->StartPlayout());
1669 #endif
1670
1671   EXPECT_EQ(0, audio_device_->StartRawOutputFileRecording(
1672       GetFilename("raw_output_playing.pcm")));
1673   SleepMs(100);
1674   EXPECT_EQ(0, audio_device_->StopRawOutputFileRecording());
1675   EXPECT_EQ(0, audio_device_->StopPlayout());
1676   EXPECT_EQ(0, audio_device_->StartRawOutputFileRecording(
1677       GetFilename("raw_output_not_playing.pcm")));
1678   EXPECT_EQ(0, audio_device_->StopRawOutputFileRecording());
1679
1680   // results after this test:
1681   //
1682   // - size of raw_output_not_playing.pcm shall be 0
1683   // - size of raw_output_playing.pcm shall be > 0
1684 }
1685
1686 TEST_F(AudioDeviceAPITest, StartAndStopRawInputFileRecording) {
1687   // NOTE: this API is better tested in a functional test
1688   CheckInitialRecordingStates();
1689   EXPECT_FALSE(audio_device_->Playing());
1690
1691   // fail tests
1692   EXPECT_EQ(-1, audio_device_->StartRawInputFileRecording(NULL));
1693
1694   // bulk tests
1695   EXPECT_EQ(0, audio_device_->StartRawInputFileRecording(
1696       GetFilename("raw_input_not_recording.pcm")));
1697   EXPECT_EQ(0, audio_device_->StopRawInputFileRecording());
1698   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1699
1700   // TODO(kjellander): Fix so these tests pass on Mac.
1701 #if !defined(WEBRTC_MAC)
1702   EXPECT_EQ(0, audio_device_->InitRecording());
1703   EXPECT_EQ(0, audio_device_->StartRecording());
1704 #endif
1705   EXPECT_EQ(0, audio_device_->StartRawInputFileRecording(
1706       GetFilename("raw_input_recording.pcm")));
1707   SleepMs(100);
1708   EXPECT_EQ(0, audio_device_->StopRawInputFileRecording());
1709   EXPECT_EQ(0, audio_device_->StopRecording());
1710   EXPECT_EQ(0, audio_device_->StartRawInputFileRecording(
1711       GetFilename("raw_input_not_recording.pcm")));
1712   EXPECT_EQ(0, audio_device_->StopRawInputFileRecording());
1713
1714   // results after this test:
1715   //
1716   // - size of raw_input_not_recording.pcm shall be 0
1717   // - size of raw_input_not_recording.pcm shall be > 0
1718 }
1719 #endif  // !WIN32 && !WEBRTC_LINUX
1720
1721 TEST_F(AudioDeviceAPITest, RecordingSampleRate) {
1722   uint32_t sampleRate(0);
1723
1724   // bulk tests
1725   EXPECT_EQ(0, audio_device_->RecordingSampleRate(&sampleRate));
1726 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
1727   EXPECT_EQ(48000, sampleRate);
1728 #elif defined(ANDROID)
1729   TEST_LOG("Recording sample rate is %u\n\n", sampleRate);
1730   EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000));
1731 #elif defined(WEBRTC_IOS)
1732   TEST_LOG("Recording sample rate is %u\n\n", sampleRate);
1733   EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000) ||
1734               (sampleRate == 8000));
1735 #endif
1736
1737   // @TODO(xians) - add tests for all platforms here...
1738 }
1739
1740 TEST_F(AudioDeviceAPITest, PlayoutSampleRate) {
1741   uint32_t sampleRate(0);
1742
1743   // bulk tests
1744   EXPECT_EQ(0, audio_device_->PlayoutSampleRate(&sampleRate));
1745 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
1746   EXPECT_EQ(48000, sampleRate);
1747 #elif defined(ANDROID)
1748   TEST_LOG("Playout sample rate is %u\n\n", sampleRate);
1749   EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000));
1750 #elif defined(WEBRTC_IOS)
1751   TEST_LOG("Playout sample rate is %u\n\n", sampleRate);
1752   EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000) ||
1753               (sampleRate == 8000));
1754 #endif
1755 }
1756
1757 TEST_F(AudioDeviceAPITest, ResetAudioDevice) {
1758   CheckInitialPlayoutStates();
1759   CheckInitialRecordingStates();
1760   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
1761   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
1762
1763 #if defined(WEBRTC_IOS)
1764   // Not playing or recording, should just return 0
1765   EXPECT_EQ(0, audio_device_->ResetAudioDevice());
1766
1767   EXPECT_EQ(0, audio_device_->InitRecording());
1768   EXPECT_EQ(0, audio_device_->StartRecording());
1769   EXPECT_EQ(0, audio_device_->InitPlayout());
1770   EXPECT_EQ(0, audio_device_->StartPlayout());
1771   for (int l=0; l<20; ++l)
1772   {
1773     TEST_LOG("Resetting sound device several time with pause %d ms\n", l);
1774     EXPECT_EQ(0, audio_device_->ResetAudioDevice());
1775     SleepMs(l);
1776   }
1777 #else
1778   // Fail tests
1779   EXPECT_EQ(-1, audio_device_->ResetAudioDevice());
1780
1781   // TODO(kjellander): Fix so these tests pass on Mac.
1782 #if !defined(WEBRTC_MAC)
1783   EXPECT_EQ(0, audio_device_->InitRecording());
1784   EXPECT_EQ(0, audio_device_->StartRecording());
1785   EXPECT_EQ(0, audio_device_->InitPlayout());
1786   EXPECT_EQ(0, audio_device_->StartPlayout());
1787 #endif
1788   EXPECT_EQ(-1, audio_device_->ResetAudioDevice());
1789 #endif
1790   EXPECT_EQ(0, audio_device_->StopRecording());
1791   EXPECT_EQ(0, audio_device_->StopPlayout());
1792 }
1793
1794 TEST_F(AudioDeviceAPITest, SetPlayoutSpeaker) {
1795   CheckInitialPlayoutStates();
1796   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
1797
1798   bool loudspeakerOn(false);
1799 #if defined(WEBRTC_IOS)
1800   // Not playing or recording, should just return a success
1801   EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(true));
1802   EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
1803   EXPECT_TRUE(loudspeakerOn);
1804   EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(false));
1805   EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
1806   EXPECT_FALSE(loudspeakerOn);
1807
1808   EXPECT_EQ(0, audio_device_->InitPlayout());
1809   EXPECT_EQ(0, audio_device_->StartPlayout());
1810   EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(true));
1811   EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
1812   EXPECT_TRUE(loudspeakerOn);
1813   EXPECT_EQ(0, audio_device_->SetLoudspeakerStatus(false));
1814   EXPECT_EQ(0, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
1815   EXPECT_FALSE(loudspeakerOn);
1816
1817 #else
1818   // Fail tests
1819   EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(true));
1820   EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(false));
1821   EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(true));
1822   EXPECT_EQ(-1, audio_device_->SetLoudspeakerStatus(false));
1823
1824   // TODO(kjellander): Fix so these tests pass on Mac.
1825 #if !defined(WEBRTC_MAC)
1826   EXPECT_EQ(0, audio_device_->InitPlayout());
1827   EXPECT_EQ(0, audio_device_->StartPlayout());
1828 #endif
1829
1830   EXPECT_EQ(-1, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
1831 #endif
1832   EXPECT_EQ(0, audio_device_->StopPlayout());
1833 }