testautomation_audio.c (38582B)
1 /** 2 * Original code: automated SDL audio test written by Edgar Simo "bobbens" 3 * New/updated tests: aschiffler at ferzkopp dot net 4 */ 5 6 /* quiet windows compiler warnings */ 7 #define _CRT_SECURE_NO_WARNINGS 8 9 #include <stdio.h> 10 #include <string.h> 11 12 #include "SDL.h" 13 #include "SDL_test.h" 14 15 /* ================= Test Case Implementation ================== */ 16 17 /* Fixture */ 18 19 void 20 _audioSetUp(void *arg) 21 { 22 /* Start SDL audio subsystem */ 23 int ret = SDL_InitSubSystem( SDL_INIT_AUDIO ); 24 SDLTest_AssertPass("Call to SDL_InitSubSystem(SDL_INIT_AUDIO)"); 25 SDLTest_AssertCheck(ret==0, "Check result from SDL_InitSubSystem(SDL_INIT_AUDIO)"); 26 if (ret != 0) { 27 SDLTest_LogError("%s", SDL_GetError()); 28 } 29 } 30 31 void 32 _audioTearDown(void *arg) 33 { 34 /* Remove a possibly created file from SDL disk writer audio driver; ignore errors */ 35 remove("sdlaudio.raw"); 36 37 SDLTest_AssertPass("Cleanup of test files completed"); 38 } 39 40 41 /* Global counter for callback invocation */ 42 int _audio_testCallbackCounter; 43 44 /* Global accumulator for total callback length */ 45 int _audio_testCallbackLength; 46 47 48 /* Test callback function */ 49 void SDLCALL _audio_testCallback(void *userdata, Uint8 *stream, int len) 50 { 51 /* track that callback was called */ 52 _audio_testCallbackCounter++; 53 _audio_testCallbackLength += len; 54 } 55 56 57 /* Test case functions */ 58 59 /** 60 * \brief Stop and restart audio subsystem 61 * 62 * \sa https://wiki.libsdl.org/SDL_QuitSubSystem 63 * \sa https://wiki.libsdl.org/SDL_InitSubSystem 64 */ 65 int audio_quitInitAudioSubSystem() 66 { 67 /* Stop SDL audio subsystem */ 68 SDL_QuitSubSystem( SDL_INIT_AUDIO ); 69 SDLTest_AssertPass("Call to SDL_QuitSubSystem(SDL_INIT_AUDIO)"); 70 71 /* Restart audio again */ 72 _audioSetUp(NULL); 73 74 return TEST_COMPLETED; 75 } 76 77 /** 78 * \brief Start and stop audio directly 79 * 80 * \sa https://wiki.libsdl.org/SDL_InitAudio 81 * \sa https://wiki.libsdl.org/SDL_QuitAudio 82 */ 83 int audio_initQuitAudio() 84 { 85 int result; 86 int i, iMax; 87 const char* audioDriver; 88 89 /* Stop SDL audio subsystem */ 90 SDL_QuitSubSystem( SDL_INIT_AUDIO ); 91 SDLTest_AssertPass("Call to SDL_QuitSubSystem(SDL_INIT_AUDIO)"); 92 93 /* Loop over all available audio drivers */ 94 iMax = SDL_GetNumAudioDrivers(); 95 SDLTest_AssertPass("Call to SDL_GetNumAudioDrivers()"); 96 SDLTest_AssertCheck(iMax > 0, "Validate number of audio drivers; expected: >0 got: %d", iMax); 97 for (i = 0; i < iMax; i++) { 98 audioDriver = SDL_GetAudioDriver(i); 99 SDLTest_AssertPass("Call to SDL_GetAudioDriver(%d)", i); 100 SDLTest_AssertCheck(audioDriver != NULL, "Audio driver name is not NULL"); 101 SDLTest_AssertCheck(audioDriver[0] != '\0', "Audio driver name is not empty; got: %s", audioDriver); 102 103 /* Call Init */ 104 result = SDL_AudioInit(audioDriver); 105 SDLTest_AssertPass("Call to SDL_AudioInit('%s')", audioDriver); 106 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0 got: %d", result); 107 108 /* Call Quit */ 109 SDL_AudioQuit(); 110 SDLTest_AssertPass("Call to SDL_AudioQuit()"); 111 } 112 113 /* NULL driver specification */ 114 audioDriver = NULL; 115 116 /* Call Init */ 117 result = SDL_AudioInit(audioDriver); 118 SDLTest_AssertPass("Call to SDL_AudioInit(NULL)"); 119 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0 got: %d", result); 120 121 /* Call Quit */ 122 SDL_AudioQuit(); 123 SDLTest_AssertPass("Call to SDL_AudioQuit()"); 124 125 /* Restart audio again */ 126 _audioSetUp(NULL); 127 128 return TEST_COMPLETED; 129 } 130 131 /** 132 * \brief Start, open, close and stop audio 133 * 134 * \sa https://wiki.libsdl.org/SDL_InitAudio 135 * \sa https://wiki.libsdl.org/SDL_OpenAudio 136 * \sa https://wiki.libsdl.org/SDL_CloseAudio 137 * \sa https://wiki.libsdl.org/SDL_QuitAudio 138 */ 139 int audio_initOpenCloseQuitAudio() 140 { 141 int result, expectedResult; 142 int i, iMax, j, k; 143 const char* audioDriver; 144 SDL_AudioSpec desired; 145 146 /* Stop SDL audio subsystem */ 147 SDL_QuitSubSystem( SDL_INIT_AUDIO ); 148 SDLTest_AssertPass("Call to SDL_QuitSubSystem(SDL_INIT_AUDIO)"); 149 150 /* Loop over all available audio drivers */ 151 iMax = SDL_GetNumAudioDrivers(); 152 SDLTest_AssertPass("Call to SDL_GetNumAudioDrivers()"); 153 SDLTest_AssertCheck(iMax > 0, "Validate number of audio drivers; expected: >0 got: %d", iMax); 154 for (i = 0; i < iMax; i++) { 155 audioDriver = SDL_GetAudioDriver(i); 156 SDLTest_AssertPass("Call to SDL_GetAudioDriver(%d)", i); 157 SDLTest_AssertCheck(audioDriver != NULL, "Audio driver name is not NULL"); 158 SDLTest_AssertCheck(audioDriver[0] != '\0', "Audio driver name is not empty; got: %s", audioDriver); 159 160 /* Change specs */ 161 for (j = 0; j < 2; j++) { 162 163 /* Call Init */ 164 result = SDL_AudioInit(audioDriver); 165 SDLTest_AssertPass("Call to SDL_AudioInit('%s')", audioDriver); 166 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0 got: %d", result); 167 168 /* Set spec */ 169 SDL_memset(&desired, 0, sizeof(desired)); 170 switch (j) { 171 case 0: 172 /* Set standard desired spec */ 173 desired.freq = 22050; 174 desired.format = AUDIO_S16SYS; 175 desired.channels = 2; 176 desired.samples = 4096; 177 desired.callback = _audio_testCallback; 178 desired.userdata = NULL; 179 180 case 1: 181 /* Set custom desired spec */ 182 desired.freq = 48000; 183 desired.format = AUDIO_F32SYS; 184 desired.channels = 2; 185 desired.samples = 2048; 186 desired.callback = _audio_testCallback; 187 desired.userdata = NULL; 188 break; 189 } 190 191 /* Call Open (maybe multiple times) */ 192 for (k=0; k <= j; k++) { 193 result = SDL_OpenAudio(&desired, NULL); 194 SDLTest_AssertPass("Call to SDL_OpenAudio(desired_spec_%d, NULL), call %d", j, k+1); 195 expectedResult = (k==0) ? 0 : -1; 196 SDLTest_AssertCheck(result == expectedResult, "Verify return value; expected: %d, got: %d", expectedResult, result); 197 } 198 199 /* Call Close (maybe multiple times) */ 200 for (k=0; k <= j; k++) { 201 SDL_CloseAudio(); 202 SDLTest_AssertPass("Call to SDL_CloseAudio(), call %d", k+1); 203 } 204 205 /* Call Quit (maybe multiple times) */ 206 for (k=0; k <= j; k++) { 207 SDL_AudioQuit(); 208 SDLTest_AssertPass("Call to SDL_AudioQuit(), call %d", k+1); 209 } 210 211 } /* spec loop */ 212 } /* driver loop */ 213 214 /* Restart audio again */ 215 _audioSetUp(NULL); 216 217 return TEST_COMPLETED; 218 } 219 220 /** 221 * \brief Pause and unpause audio 222 * 223 * \sa https://wiki.libsdl.org/SDL_PauseAudio 224 */ 225 int audio_pauseUnpauseAudio() 226 { 227 int result; 228 int i, iMax, j, k, l; 229 int totalDelay; 230 int pause_on; 231 int originalCounter; 232 const char* audioDriver; 233 SDL_AudioSpec desired; 234 235 /* Stop SDL audio subsystem */ 236 SDL_QuitSubSystem( SDL_INIT_AUDIO ); 237 SDLTest_AssertPass("Call to SDL_QuitSubSystem(SDL_INIT_AUDIO)"); 238 239 /* Loop over all available audio drivers */ 240 iMax = SDL_GetNumAudioDrivers(); 241 SDLTest_AssertPass("Call to SDL_GetNumAudioDrivers()"); 242 SDLTest_AssertCheck(iMax > 0, "Validate number of audio drivers; expected: >0 got: %d", iMax); 243 for (i = 0; i < iMax; i++) { 244 audioDriver = SDL_GetAudioDriver(i); 245 SDLTest_AssertPass("Call to SDL_GetAudioDriver(%d)", i); 246 SDLTest_AssertCheck(audioDriver != NULL, "Audio driver name is not NULL"); 247 SDLTest_AssertCheck(audioDriver[0] != '\0', "Audio driver name is not empty; got: %s", audioDriver); 248 249 /* Change specs */ 250 for (j = 0; j < 2; j++) { 251 252 /* Call Init */ 253 result = SDL_AudioInit(audioDriver); 254 SDLTest_AssertPass("Call to SDL_AudioInit('%s')", audioDriver); 255 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0 got: %d", result); 256 257 /* Set spec */ 258 SDL_memset(&desired, 0, sizeof(desired)); 259 switch (j) { 260 case 0: 261 /* Set standard desired spec */ 262 desired.freq = 22050; 263 desired.format = AUDIO_S16SYS; 264 desired.channels = 2; 265 desired.samples = 4096; 266 desired.callback = _audio_testCallback; 267 desired.userdata = NULL; 268 269 case 1: 270 /* Set custom desired spec */ 271 desired.freq = 48000; 272 desired.format = AUDIO_F32SYS; 273 desired.channels = 2; 274 desired.samples = 2048; 275 desired.callback = _audio_testCallback; 276 desired.userdata = NULL; 277 break; 278 } 279 280 /* Call Open */ 281 result = SDL_OpenAudio(&desired, NULL); 282 SDLTest_AssertPass("Call to SDL_OpenAudio(desired_spec_%d, NULL)", j); 283 SDLTest_AssertCheck(result == 0, "Verify return value; expected: 0 got: %d", result); 284 285 /* Start and stop audio multiple times */ 286 for (l=0; l<3; l++) { 287 SDLTest_Log("Pause/Unpause iteration: %d", l+1); 288 289 /* Reset callback counters */ 290 _audio_testCallbackCounter = 0; 291 _audio_testCallbackLength = 0; 292 293 /* Un-pause audio to start playing (maybe multiple times) */ 294 pause_on = 0; 295 for (k=0; k <= j; k++) { 296 SDL_PauseAudio(pause_on); 297 SDLTest_AssertPass("Call to SDL_PauseAudio(%d), call %d", pause_on, k+1); 298 } 299 300 /* Wait for callback */ 301 totalDelay = 0; 302 do { 303 SDL_Delay(10); 304 totalDelay += 10; 305 } 306 while (_audio_testCallbackCounter == 0 && totalDelay < 1000); 307 SDLTest_AssertCheck(_audio_testCallbackCounter > 0, "Verify callback counter; expected: >0 got: %d", _audio_testCallbackCounter); 308 SDLTest_AssertCheck(_audio_testCallbackLength > 0, "Verify callback length; expected: >0 got: %d", _audio_testCallbackLength); 309 310 /* Pause audio to stop playing (maybe multiple times) */ 311 for (k=0; k <= j; k++) { 312 pause_on = (k==0) ? 1 : SDLTest_RandomIntegerInRange(99, 9999); 313 SDL_PauseAudio(pause_on); 314 SDLTest_AssertPass("Call to SDL_PauseAudio(%d), call %d", pause_on, k+1); 315 } 316 317 /* Ensure callback is not called again */ 318 originalCounter = _audio_testCallbackCounter; 319 SDL_Delay(totalDelay + 10); 320 SDLTest_AssertCheck(originalCounter == _audio_testCallbackCounter, "Verify callback counter; expected: %d, got: %d", originalCounter, _audio_testCallbackCounter); 321 } 322 323 /* Call Close */ 324 SDL_CloseAudio(); 325 SDLTest_AssertPass("Call to SDL_CloseAudio()"); 326 327 /* Call Quit */ 328 SDL_AudioQuit(); 329 SDLTest_AssertPass("Call to SDL_AudioQuit()"); 330 331 } /* spec loop */ 332 } /* driver loop */ 333 334 /* Restart audio again */ 335 _audioSetUp(NULL); 336 337 return TEST_COMPLETED; 338 } 339 340 /** 341 * \brief Enumerate and name available audio devices (output and capture). 342 * 343 * \sa https://wiki.libsdl.org/SDL_GetNumAudioDevices 344 * \sa https://wiki.libsdl.org/SDL_GetAudioDeviceName 345 */ 346 int audio_enumerateAndNameAudioDevices() 347 { 348 int t, tt; 349 int i, n, nn; 350 const char *name, *nameAgain; 351 352 /* Iterate over types: t=0 output device, t=1 input/capture device */ 353 for (t=0; t<2; t++) { 354 355 /* Get number of devices. */ 356 n = SDL_GetNumAudioDevices(t); 357 SDLTest_AssertPass("Call to SDL_GetNumAudioDevices(%i)", t); 358 SDLTest_Log("Number of %s devices < 0, reported as %i", (t) ? "capture" : "output", n); 359 SDLTest_AssertCheck(n >= 0, "Validate result is >= 0, got: %i", n); 360 361 /* Variation of non-zero type */ 362 if (t==1) { 363 tt = t + SDLTest_RandomIntegerInRange(1,10); 364 nn = SDL_GetNumAudioDevices(tt); 365 SDLTest_AssertCheck(n==nn, "Verify result from SDL_GetNumAudioDevices(%i), expected same number of audio devices %i, got %i", tt, n, nn); 366 nn = SDL_GetNumAudioDevices(-tt); 367 SDLTest_AssertCheck(n==nn, "Verify result from SDL_GetNumAudioDevices(%i), expected same number of audio devices %i, got %i", -tt, n, nn); 368 } 369 370 /* List devices. */ 371 if (n>0) { 372 for (i=0; i<n; i++) { 373 name = SDL_GetAudioDeviceName(i, t); 374 SDLTest_AssertPass("Call to SDL_GetAudioDeviceName(%i, %i)", i, t); 375 SDLTest_AssertCheck(name != NULL, "Verify result from SDL_GetAudioDeviceName(%i, %i) is not NULL", i, t); 376 if (name != NULL) { 377 SDLTest_AssertCheck(name[0] != '\0', "verify result from SDL_GetAudioDeviceName(%i, %i) is not empty, got: '%s'", i, t, name); 378 if (t==1) { 379 /* Also try non-zero type */ 380 tt = t + SDLTest_RandomIntegerInRange(1,10); 381 nameAgain = SDL_GetAudioDeviceName(i, tt); 382 SDLTest_AssertCheck(nameAgain != NULL, "Verify result from SDL_GetAudioDeviceName(%i, %i) is not NULL", i, tt); 383 if (nameAgain != NULL) { 384 SDLTest_AssertCheck(nameAgain[0] != '\0', "Verify result from SDL_GetAudioDeviceName(%i, %i) is not empty, got: '%s'", i, tt, nameAgain); 385 SDLTest_AssertCheck(SDL_strcmp(name, nameAgain)==0, 386 "Verify SDL_GetAudioDeviceName(%i, %i) and SDL_GetAudioDeviceName(%i %i) return the same string", 387 i, t, i, tt); 388 } 389 } 390 } 391 } 392 } 393 } 394 395 return TEST_COMPLETED; 396 } 397 398 /** 399 * \brief Negative tests around enumeration and naming of audio devices. 400 * 401 * \sa https://wiki.libsdl.org/SDL_GetNumAudioDevices 402 * \sa https://wiki.libsdl.org/SDL_GetAudioDeviceName 403 */ 404 int audio_enumerateAndNameAudioDevicesNegativeTests() 405 { 406 int t; 407 int i, j, no, nc; 408 const char *name; 409 410 /* Get number of devices. */ 411 no = SDL_GetNumAudioDevices(0); 412 SDLTest_AssertPass("Call to SDL_GetNumAudioDevices(0)"); 413 nc = SDL_GetNumAudioDevices(1); 414 SDLTest_AssertPass("Call to SDL_GetNumAudioDevices(1)"); 415 416 /* Invalid device index when getting name */ 417 for (t=0; t<2; t++) { 418 /* Negative device index */ 419 i = SDLTest_RandomIntegerInRange(-10,-1); 420 name = SDL_GetAudioDeviceName(i, t); 421 SDLTest_AssertPass("Call to SDL_GetAudioDeviceName(%i, %i)", i, t); 422 SDLTest_AssertCheck(name == NULL, "Check SDL_GetAudioDeviceName(%i, %i) result NULL, expected NULL, got: %s", i, t, (name == NULL) ? "NULL" : name); 423 424 /* Device index past range */ 425 for (j=0; j<3; j++) { 426 i = (t) ? nc+j : no+j; 427 name = SDL_GetAudioDeviceName(i, t); 428 SDLTest_AssertPass("Call to SDL_GetAudioDeviceName(%i, %i)", i, t); 429 SDLTest_AssertCheck(name == NULL, "Check SDL_GetAudioDeviceName(%i, %i) result, expected: NULL, got: %s", i, t, (name == NULL) ? "NULL" : name); 430 } 431 432 /* Capture index past capture range but within output range */ 433 if ((no>0) && (no>nc) && (t==1)) { 434 i = no-1; 435 name = SDL_GetAudioDeviceName(i, t); 436 SDLTest_AssertPass("Call to SDL_GetAudioDeviceName(%i, %i)", i, t); 437 SDLTest_AssertCheck(name == NULL, "Check SDL_GetAudioDeviceName(%i, %i) result, expected: NULL, got: %s", i, t, (name == NULL) ? "NULL" : name); 438 } 439 } 440 441 return TEST_COMPLETED; 442 } 443 444 445 /** 446 * \brief Checks available audio driver names. 447 * 448 * \sa https://wiki.libsdl.org/SDL_GetNumAudioDrivers 449 * \sa https://wiki.libsdl.org/SDL_GetAudioDriver 450 */ 451 int audio_printAudioDrivers() 452 { 453 int i, n; 454 const char *name; 455 456 /* Get number of drivers */ 457 n = SDL_GetNumAudioDrivers(); 458 SDLTest_AssertPass("Call to SDL_GetNumAudioDrivers()"); 459 SDLTest_AssertCheck(n>=0, "Verify number of audio drivers >= 0, got: %i", n); 460 461 /* List drivers. */ 462 if (n>0) 463 { 464 for (i=0; i<n; i++) { 465 name = SDL_GetAudioDriver(i); 466 SDLTest_AssertPass("Call to SDL_GetAudioDriver(%i)", i); 467 SDLTest_AssertCheck(name != NULL, "Verify returned name is not NULL"); 468 if (name != NULL) { 469 SDLTest_AssertCheck(name[0] != '\0', "Verify returned name is not empty, got: '%s'", name); 470 } 471 } 472 } 473 474 return TEST_COMPLETED; 475 } 476 477 478 /** 479 * \brief Checks current audio driver name with initialized audio. 480 * 481 * \sa https://wiki.libsdl.org/SDL_GetCurrentAudioDriver 482 */ 483 int audio_printCurrentAudioDriver() 484 { 485 /* Check current audio driver */ 486 const char *name = SDL_GetCurrentAudioDriver(); 487 SDLTest_AssertPass("Call to SDL_GetCurrentAudioDriver()"); 488 SDLTest_AssertCheck(name != NULL, "Verify returned name is not NULL"); 489 if (name != NULL) { 490 SDLTest_AssertCheck(name[0] != '\0', "Verify returned name is not empty, got: '%s'", name); 491 } 492 493 return TEST_COMPLETED; 494 } 495 496 /* Definition of all formats, channels, and frequencies used to test audio conversions */ 497 const int _numAudioFormats = 18; 498 SDL_AudioFormat _audioFormats[] = { AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S16SYS, AUDIO_S16, AUDIO_U16LSB, 499 AUDIO_U16MSB, AUDIO_U16SYS, AUDIO_U16, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_S32SYS, AUDIO_S32, 500 AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_F32SYS, AUDIO_F32 }; 501 char *_audioFormatsVerbose[] = { "AUDIO_S8", "AUDIO_U8", "AUDIO_S16LSB", "AUDIO_S16MSB", "AUDIO_S16SYS", "AUDIO_S16", "AUDIO_U16LSB", 502 "AUDIO_U16MSB", "AUDIO_U16SYS", "AUDIO_U16", "AUDIO_S32LSB", "AUDIO_S32MSB", "AUDIO_S32SYS", "AUDIO_S32", 503 "AUDIO_F32LSB", "AUDIO_F32MSB", "AUDIO_F32SYS", "AUDIO_F32" }; 504 const int _numAudioChannels = 4; 505 Uint8 _audioChannels[] = { 1, 2, 4, 6 }; 506 const int _numAudioFrequencies = 4; 507 int _audioFrequencies[] = { 11025, 22050, 44100, 48000 }; 508 509 510 /** 511 * \brief Builds various audio conversion structures 512 * 513 * \sa https://wiki.libsdl.org/SDL_BuildAudioCVT 514 */ 515 int audio_buildAudioCVT() 516 { 517 int result; 518 SDL_AudioCVT cvt; 519 SDL_AudioSpec spec1; 520 SDL_AudioSpec spec2; 521 int i, ii, j, jj, k, kk; 522 523 /* No conversion needed */ 524 spec1.format = AUDIO_S16LSB; 525 spec1.channels = 2; 526 spec1.freq = 22050; 527 result = SDL_BuildAudioCVT(&cvt, spec1.format, spec1.channels, spec1.freq, 528 spec1.format, spec1.channels, spec1.freq); 529 SDLTest_AssertPass("Call to SDL_BuildAudioCVT(spec1 ==> spec1)"); 530 SDLTest_AssertCheck(result == 0, "Verify result value; expected: 0, got: %i", result); 531 532 /* Typical conversion */ 533 spec1.format = AUDIO_S8; 534 spec1.channels = 1; 535 spec1.freq = 22050; 536 spec2.format = AUDIO_S16LSB; 537 spec2.channels = 2; 538 spec2.freq = 44100; 539 result = SDL_BuildAudioCVT(&cvt, spec1.format, spec1.channels, spec1.freq, 540 spec2.format, spec2.channels, spec2.freq); 541 SDLTest_AssertPass("Call to SDL_BuildAudioCVT(spec1 ==> spec2)"); 542 SDLTest_AssertCheck(result == 1, "Verify result value; expected: 1, got: %i", result); 543 544 /* All source conversions with random conversion targets, allow 'null' conversions */ 545 for (i = 0; i < _numAudioFormats; i++) { 546 for (j = 0; j < _numAudioChannels; j++) { 547 for (k = 0; k < _numAudioFrequencies; k++) { 548 spec1.format = _audioFormats[i]; 549 spec1.channels = _audioChannels[j]; 550 spec1.freq = _audioFrequencies[k]; 551 ii = SDLTest_RandomIntegerInRange(0, _numAudioFormats - 1); 552 jj = SDLTest_RandomIntegerInRange(0, _numAudioChannels - 1); 553 kk = SDLTest_RandomIntegerInRange(0, _numAudioFrequencies - 1); 554 spec2.format = _audioFormats[ii]; 555 spec2.channels = _audioChannels[jj]; 556 spec2.freq = _audioFrequencies[kk]; 557 result = SDL_BuildAudioCVT(&cvt, spec1.format, spec1.channels, spec1.freq, 558 spec2.format, spec2.channels, spec2.freq); 559 SDLTest_AssertPass("Call to SDL_BuildAudioCVT(format[%i]=%s(%i),channels[%i]=%i,freq[%i]=%i ==> format[%i]=%s(%i),channels[%i]=%i,freq[%i]=%i)", 560 i, _audioFormatsVerbose[i], spec1.format, j, spec1.channels, k, spec1.freq, ii, _audioFormatsVerbose[ii], spec2.format, jj, spec2.channels, kk, spec2.freq); 561 SDLTest_AssertCheck(result == 0 || result == 1, "Verify result value; expected: 0 or 1, got: %i", result); 562 if (result<0) { 563 SDLTest_LogError("%s", SDL_GetError()); 564 } else { 565 SDLTest_AssertCheck(cvt.len_mult > 0, "Verify that cvt.len_mult value; expected: >0, got: %i", cvt.len_mult); 566 } 567 } 568 } 569 } 570 571 return TEST_COMPLETED; 572 } 573 574 /** 575 * \brief Checkes calls with invalid input to SDL_BuildAudioCVT 576 * 577 * \sa https://wiki.libsdl.org/SDL_BuildAudioCVT 578 */ 579 int audio_buildAudioCVTNegative() 580 { 581 const char *expectedError = "Parameter 'cvt' is invalid"; 582 const char *error; 583 int result; 584 SDL_AudioCVT cvt; 585 SDL_AudioSpec spec1; 586 SDL_AudioSpec spec2; 587 int i; 588 char message[256]; 589 590 /* Valid format */ 591 spec1.format = AUDIO_S8; 592 spec1.channels = 1; 593 spec1.freq = 22050; 594 spec2.format = AUDIO_S16LSB; 595 spec2.channels = 2; 596 spec2.freq = 44100; 597 598 SDL_ClearError(); 599 SDLTest_AssertPass("Call to SDL_ClearError()"); 600 601 /* NULL input for CVT buffer */ 602 result = SDL_BuildAudioCVT((SDL_AudioCVT *)NULL, spec1.format, spec1.channels, spec1.freq, 603 spec2.format, spec2.channels, spec2.freq); 604 SDLTest_AssertPass("Call to SDL_BuildAudioCVT(NULL,...)"); 605 SDLTest_AssertCheck(result == -1, "Verify result value; expected: -1, got: %i", result); 606 error = SDL_GetError(); 607 SDLTest_AssertPass("Call to SDL_GetError()"); 608 SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL"); 609 if (error != NULL) { 610 SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0, 611 "Validate error message, expected: '%s', got: '%s'", expectedError, error); 612 } 613 614 /* Invalid conversions */ 615 for (i = 1; i < 64; i++) { 616 /* Valid format to start with */ 617 spec1.format = AUDIO_S8; 618 spec1.channels = 1; 619 spec1.freq = 22050; 620 spec2.format = AUDIO_S16LSB; 621 spec2.channels = 2; 622 spec2.freq = 44100; 623 624 SDL_ClearError(); 625 SDLTest_AssertPass("Call to SDL_ClearError()"); 626 627 /* Set various invalid format inputs */ 628 SDL_strlcpy(message, "Invalid: ", 256); 629 if (i & 1) { 630 SDL_strlcat(message, " spec1.format", 256); 631 spec1.format = 0; 632 } 633 if (i & 2) { 634 SDL_strlcat(message, " spec1.channels", 256); 635 spec1.channels = 0; 636 } 637 if (i & 4) { 638 SDL_strlcat(message, " spec1.freq", 256); 639 spec1.freq = 0; 640 } 641 if (i & 8) { 642 SDL_strlcat(message, " spec2.format", 256); 643 spec2.format = 0; 644 } 645 if (i & 16) { 646 SDL_strlcat(message, " spec2.channels", 256); 647 spec2.channels = 0; 648 } 649 if (i & 32) { 650 SDL_strlcat(message, " spec2.freq", 256); 651 spec2.freq = 0; 652 } 653 SDLTest_Log("%s", message); 654 result = SDL_BuildAudioCVT(&cvt, spec1.format, spec1.channels, spec1.freq, 655 spec2.format, spec2.channels, spec2.freq); 656 SDLTest_AssertPass("Call to SDL_BuildAudioCVT(spec1 ==> spec2)"); 657 SDLTest_AssertCheck(result == -1, "Verify result value; expected: -1, got: %i", result); 658 error = SDL_GetError(); 659 SDLTest_AssertPass("Call to SDL_GetError()"); 660 SDLTest_AssertCheck(error != NULL && error[0] != '\0', "Validate that error message was not NULL or empty"); 661 } 662 663 SDL_ClearError(); 664 SDLTest_AssertPass("Call to SDL_ClearError()"); 665 666 return TEST_COMPLETED; 667 } 668 669 /** 670 * \brief Checks current audio status. 671 * 672 * \sa https://wiki.libsdl.org/SDL_GetAudioStatus 673 */ 674 int audio_getAudioStatus() 675 { 676 SDL_AudioStatus result; 677 678 /* Check current audio status */ 679 result = SDL_GetAudioStatus(); 680 SDLTest_AssertPass("Call to SDL_GetAudioStatus()"); 681 SDLTest_AssertCheck(result == SDL_AUDIO_STOPPED || result == SDL_AUDIO_PLAYING || result == SDL_AUDIO_PAUSED, 682 "Verify returned value; expected: STOPPED (%i) | PLAYING (%i) | PAUSED (%i), got: %i", 683 SDL_AUDIO_STOPPED, SDL_AUDIO_PLAYING, SDL_AUDIO_PAUSED, result); 684 685 return TEST_COMPLETED; 686 } 687 688 689 690 /** 691 * \brief Opens, checks current audio status, and closes a device. 692 * 693 * \sa https://wiki.libsdl.org/SDL_GetAudioStatus 694 */ 695 int audio_openCloseAndGetAudioStatus() 696 { 697 SDL_AudioStatus result; 698 int i; 699 int count; 700 char *device; 701 SDL_AudioDeviceID id; 702 SDL_AudioSpec desired, obtained; 703 704 /* Get number of devices. */ 705 count = SDL_GetNumAudioDevices(0); 706 SDLTest_AssertPass("Call to SDL_GetNumAudioDevices(0)"); 707 if (count > 0) { 708 for (i = 0; i < count; i++) { 709 /* Get device name */ 710 device = (char *)SDL_GetAudioDeviceName(i, 0); 711 SDLTest_AssertPass("SDL_GetAudioDeviceName(%i,0)", i); 712 SDLTest_AssertCheck(device != NULL, "Validate device name is not NULL; got: %s", (device != NULL) ? device : "NULL"); 713 if (device == NULL) return TEST_ABORTED; 714 715 /* Set standard desired spec */ 716 desired.freq=22050; 717 desired.format=AUDIO_S16SYS; 718 desired.channels=2; 719 desired.samples=4096; 720 desired.callback=_audio_testCallback; 721 desired.userdata=NULL; 722 723 /* Open device */ 724 id = SDL_OpenAudioDevice((const char *)device, 0, &desired, &obtained, SDL_AUDIO_ALLOW_ANY_CHANGE); 725 SDLTest_AssertPass("SDL_OpenAudioDevice('%s',...)", device); 726 SDLTest_AssertCheck(id > 1, "Validate device ID; expected: >=2, got: %i", id); 727 if (id > 1) { 728 729 /* Check device audio status */ 730 result = SDL_GetAudioDeviceStatus(id); 731 SDLTest_AssertPass("Call to SDL_GetAudioDeviceStatus()"); 732 SDLTest_AssertCheck(result == SDL_AUDIO_STOPPED || result == SDL_AUDIO_PLAYING || result == SDL_AUDIO_PAUSED, 733 "Verify returned value; expected: STOPPED (%i) | PLAYING (%i) | PAUSED (%i), got: %i", 734 SDL_AUDIO_STOPPED, SDL_AUDIO_PLAYING, SDL_AUDIO_PAUSED, result); 735 736 /* Close device again */ 737 SDL_CloseAudioDevice(id); 738 SDLTest_AssertPass("Call to SDL_CloseAudioDevice()"); 739 } 740 } 741 } else { 742 SDLTest_Log("No devices to test with"); 743 } 744 745 return TEST_COMPLETED; 746 } 747 748 /** 749 * \brief Locks and unlocks open audio device. 750 * 751 * \sa https://wiki.libsdl.org/SDL_LockAudioDevice 752 * \sa https://wiki.libsdl.org/SDL_UnlockAudioDevice 753 */ 754 int audio_lockUnlockOpenAudioDevice() 755 { 756 int i; 757 int count; 758 char *device; 759 SDL_AudioDeviceID id; 760 SDL_AudioSpec desired, obtained; 761 762 /* Get number of devices. */ 763 count = SDL_GetNumAudioDevices(0); 764 SDLTest_AssertPass("Call to SDL_GetNumAudioDevices(0)"); 765 if (count > 0) { 766 for (i = 0; i < count; i++) { 767 /* Get device name */ 768 device = (char *)SDL_GetAudioDeviceName(i, 0); 769 SDLTest_AssertPass("SDL_GetAudioDeviceName(%i,0)", i); 770 SDLTest_AssertCheck(device != NULL, "Validate device name is not NULL; got: %s", (device != NULL) ? device : "NULL"); 771 if (device == NULL) return TEST_ABORTED; 772 773 /* Set standard desired spec */ 774 desired.freq=22050; 775 desired.format=AUDIO_S16SYS; 776 desired.channels=2; 777 desired.samples=4096; 778 desired.callback=_audio_testCallback; 779 desired.userdata=NULL; 780 781 /* Open device */ 782 id = SDL_OpenAudioDevice((const char *)device, 0, &desired, &obtained, SDL_AUDIO_ALLOW_ANY_CHANGE); 783 SDLTest_AssertPass("SDL_OpenAudioDevice('%s',...)", device); 784 SDLTest_AssertCheck(id > 1, "Validate device ID; expected: >=2, got: %i", id); 785 if (id > 1) { 786 /* Lock to protect callback */ 787 SDL_LockAudioDevice(id); 788 SDLTest_AssertPass("SDL_LockAudioDevice(%i)", id); 789 790 /* Simulate callback processing */ 791 SDL_Delay(10); 792 SDLTest_Log("Simulate callback processing - delay"); 793 794 /* Unlock again */ 795 SDL_UnlockAudioDevice(id); 796 SDLTest_AssertPass("SDL_UnlockAudioDevice(%i)", id); 797 798 /* Close device again */ 799 SDL_CloseAudioDevice(id); 800 SDLTest_AssertPass("Call to SDL_CloseAudioDevice()"); 801 } 802 } 803 } else { 804 SDLTest_Log("No devices to test with"); 805 } 806 807 return TEST_COMPLETED; 808 } 809 810 811 /** 812 * \brief Convert audio using various conversion structures 813 * 814 * \sa https://wiki.libsdl.org/SDL_BuildAudioCVT 815 * \sa https://wiki.libsdl.org/SDL_ConvertAudio 816 */ 817 int audio_convertAudio() 818 { 819 int result; 820 SDL_AudioCVT cvt; 821 SDL_AudioSpec spec1; 822 SDL_AudioSpec spec2; 823 int c; 824 char message[128]; 825 int i, ii, j, jj, k, kk, l, ll; 826 827 /* Iterate over bitmask that determines which parameters are modified in the conversion */ 828 for (c = 1; c < 8; c++) { 829 SDL_strlcpy(message, "Changing:", 128); 830 if (c & 1) { 831 SDL_strlcat(message, " Format", 128); 832 } 833 if (c & 2) { 834 SDL_strlcat(message, " Channels", 128); 835 } 836 if (c & 4) { 837 SDL_strlcat(message, " Frequencies", 128); 838 } 839 SDLTest_Log("%s", message); 840 /* All source conversions with random conversion targets */ 841 for (i = 0; i < _numAudioFormats; i++) { 842 for (j = 0; j < _numAudioChannels; j++) { 843 for (k = 0; k < _numAudioFrequencies; k++) { 844 spec1.format = _audioFormats[i]; 845 spec1.channels = _audioChannels[j]; 846 spec1.freq = _audioFrequencies[k]; 847 848 /* Ensure we have a different target format */ 849 do { 850 if (c & 1) { 851 ii = SDLTest_RandomIntegerInRange(0, _numAudioFormats - 1); 852 } else { 853 ii = 1; 854 } 855 if (c & 2) { 856 jj = SDLTest_RandomIntegerInRange(0, _numAudioChannels - 1); 857 } else { 858 jj= j; 859 } 860 if (c & 4) { 861 kk = SDLTest_RandomIntegerInRange(0, _numAudioFrequencies - 1); 862 } else { 863 kk = k; 864 } 865 } while ((i == ii) && (j == jj) && (k == kk)); 866 spec2.format = _audioFormats[ii]; 867 spec2.channels = _audioChannels[jj]; 868 spec2.freq = _audioFrequencies[kk]; 869 870 result = SDL_BuildAudioCVT(&cvt, spec1.format, spec1.channels, spec1.freq, 871 spec2.format, spec2.channels, spec2.freq); 872 SDLTest_AssertPass("Call to SDL_BuildAudioCVT(format[%i]=%s(%i),channels[%i]=%i,freq[%i]=%i ==> format[%i]=%s(%i),channels[%i]=%i,freq[%i]=%i)", 873 i, _audioFormatsVerbose[i], spec1.format, j, spec1.channels, k, spec1.freq, ii, _audioFormatsVerbose[ii], spec2.format, jj, spec2.channels, kk, spec2.freq); 874 SDLTest_AssertCheck(result == 1, "Verify result value; expected: 1, got: %i", result); 875 if (result != 1) { 876 SDLTest_LogError("%s", SDL_GetError()); 877 } else { 878 SDLTest_AssertCheck(cvt.len_mult > 0, "Verify that cvt.len_mult value; expected: >0, got: %i", cvt.len_mult); 879 if (cvt.len_mult < 1) return TEST_ABORTED; 880 881 /* Create some random data to convert */ 882 l = 64; 883 ll = l * cvt.len_mult; 884 SDLTest_Log("Creating dummy sample buffer of %i length (%i bytes)", l, ll); 885 cvt.len = l; 886 cvt.buf = (Uint8 *)SDL_malloc(ll); 887 SDLTest_AssertCheck(cvt.buf != NULL, "Check data buffer to convert is not NULL"); 888 if (cvt.buf == NULL) return TEST_ABORTED; 889 890 /* Convert the data */ 891 result = SDL_ConvertAudio(&cvt); 892 SDLTest_AssertPass("Call to SDL_ConvertAudio()"); 893 SDLTest_AssertCheck(result == 0, "Verify result value; expected: 0; got: %i", result); 894 SDLTest_AssertCheck(cvt.buf != NULL, "Verify conversion buffer is not NULL"); 895 SDLTest_AssertCheck(cvt.len_ratio > 0.0, "Verify conversion length ratio; expected: >0; got: %f", cvt.len_ratio); 896 897 /* Free converted buffer */ 898 SDL_free(cvt.buf); 899 cvt.buf = NULL; 900 } 901 } 902 } 903 } 904 } 905 906 return TEST_COMPLETED; 907 } 908 909 910 /** 911 * \brief Opens, checks current connected status, and closes a device. 912 * 913 * \sa https://wiki.libsdl.org/SDL_AudioDeviceConnected 914 */ 915 int audio_openCloseAudioDeviceConnected() 916 { 917 int result = -1; 918 int i; 919 int count; 920 char *device; 921 SDL_AudioDeviceID id; 922 SDL_AudioSpec desired, obtained; 923 924 /* Get number of devices. */ 925 count = SDL_GetNumAudioDevices(0); 926 SDLTest_AssertPass("Call to SDL_GetNumAudioDevices(0)"); 927 if (count > 0) { 928 for (i = 0; i < count; i++) { 929 /* Get device name */ 930 device = (char *)SDL_GetAudioDeviceName(i, 0); 931 SDLTest_AssertPass("SDL_GetAudioDeviceName(%i,0)", i); 932 SDLTest_AssertCheck(device != NULL, "Validate device name is not NULL; got: %s", (device != NULL) ? device : "NULL"); 933 if (device == NULL) return TEST_ABORTED; 934 935 /* Set standard desired spec */ 936 desired.freq=22050; 937 desired.format=AUDIO_S16SYS; 938 desired.channels=2; 939 desired.samples=4096; 940 desired.callback=_audio_testCallback; 941 desired.userdata=NULL; 942 943 /* Open device */ 944 id = SDL_OpenAudioDevice((const char *)device, 0, &desired, &obtained, SDL_AUDIO_ALLOW_ANY_CHANGE); 945 SDLTest_AssertPass("SDL_OpenAudioDevice('%s',...)", device); 946 SDLTest_AssertCheck(id > 1, "Validate device ID; expected: >1, got: %i", id); 947 if (id > 1) { 948 949 /* TODO: enable test code when function is available in SDL2 */ 950 951 #ifdef AUDIODEVICECONNECTED_DEFINED 952 /* Get connected status */ 953 result = SDL_AudioDeviceConnected(id); 954 SDLTest_AssertPass("Call to SDL_AudioDeviceConnected()"); 955 #endif 956 SDLTest_AssertCheck(result == 1, "Verify returned value; expected: 1; got: %i", result); 957 958 /* Close device again */ 959 SDL_CloseAudioDevice(id); 960 SDLTest_AssertPass("Call to SDL_CloseAudioDevice()"); 961 } 962 } 963 } else { 964 SDLTest_Log("No devices to test with"); 965 } 966 967 return TEST_COMPLETED; 968 } 969 970 971 972 /* ================= Test Case References ================== */ 973 974 /* Audio test cases */ 975 static const SDLTest_TestCaseReference audioTest1 = 976 { (SDLTest_TestCaseFp)audio_enumerateAndNameAudioDevices, "audio_enumerateAndNameAudioDevices", "Enumerate and name available audio devices (output and capture)", TEST_ENABLED }; 977 978 static const SDLTest_TestCaseReference audioTest2 = 979 { (SDLTest_TestCaseFp)audio_enumerateAndNameAudioDevicesNegativeTests, "audio_enumerateAndNameAudioDevicesNegativeTests", "Negative tests around enumeration and naming of audio devices.", TEST_ENABLED }; 980 981 static const SDLTest_TestCaseReference audioTest3 = 982 { (SDLTest_TestCaseFp)audio_printAudioDrivers, "audio_printAudioDrivers", "Checks available audio driver names.", TEST_ENABLED }; 983 984 static const SDLTest_TestCaseReference audioTest4 = 985 { (SDLTest_TestCaseFp)audio_printCurrentAudioDriver, "audio_printCurrentAudioDriver", "Checks current audio driver name with initialized audio.", TEST_ENABLED }; 986 987 static const SDLTest_TestCaseReference audioTest5 = 988 { (SDLTest_TestCaseFp)audio_buildAudioCVT, "audio_buildAudioCVT", "Builds various audio conversion structures.", TEST_ENABLED }; 989 990 static const SDLTest_TestCaseReference audioTest6 = 991 { (SDLTest_TestCaseFp)audio_buildAudioCVTNegative, "audio_buildAudioCVTNegative", "Checks calls with invalid input to SDL_BuildAudioCVT", TEST_ENABLED }; 992 993 static const SDLTest_TestCaseReference audioTest7 = 994 { (SDLTest_TestCaseFp)audio_getAudioStatus, "audio_getAudioStatus", "Checks current audio status.", TEST_ENABLED }; 995 996 static const SDLTest_TestCaseReference audioTest8 = 997 { (SDLTest_TestCaseFp)audio_openCloseAndGetAudioStatus, "audio_openCloseAndGetAudioStatus", "Opens and closes audio device and get audio status.", TEST_ENABLED }; 998 999 static const SDLTest_TestCaseReference audioTest9 = 1000 { (SDLTest_TestCaseFp)audio_lockUnlockOpenAudioDevice, "audio_lockUnlockOpenAudioDevice", "Locks and unlocks an open audio device.", TEST_ENABLED }; 1001 1002 /* TODO: enable test when SDL_ConvertAudio segfaults on cygwin have been fixed. */ 1003 /* For debugging, test case can be run manually using --filter audio_convertAudio */ 1004 1005 static const SDLTest_TestCaseReference audioTest10 = 1006 { (SDLTest_TestCaseFp)audio_convertAudio, "audio_convertAudio", "Convert audio using available formats.", TEST_DISABLED }; 1007 1008 /* TODO: enable test when SDL_AudioDeviceConnected has been implemented. */ 1009 1010 static const SDLTest_TestCaseReference audioTest11 = 1011 { (SDLTest_TestCaseFp)audio_openCloseAudioDeviceConnected, "audio_openCloseAudioDeviceConnected", "Opens and closes audio device and get connected status.", TEST_DISABLED }; 1012 1013 static const SDLTest_TestCaseReference audioTest12 = 1014 { (SDLTest_TestCaseFp)audio_quitInitAudioSubSystem, "audio_quitInitAudioSubSystem", "Quit and re-init audio subsystem.", TEST_ENABLED }; 1015 1016 static const SDLTest_TestCaseReference audioTest13 = 1017 { (SDLTest_TestCaseFp)audio_initQuitAudio, "audio_initQuitAudio", "Init and quit audio drivers directly.", TEST_ENABLED }; 1018 1019 static const SDLTest_TestCaseReference audioTest14 = 1020 { (SDLTest_TestCaseFp)audio_initOpenCloseQuitAudio, "audio_initOpenCloseQuitAudio", "Cycle through init, open, close and quit with various audio specs.", TEST_ENABLED }; 1021 1022 static const SDLTest_TestCaseReference audioTest15 = 1023 { (SDLTest_TestCaseFp)audio_pauseUnpauseAudio, "audio_pauseUnpauseAudio", "Pause and Unpause audio for various audio specs while testing callback.", TEST_ENABLED }; 1024 1025 /* Sequence of Audio test cases */ 1026 static const SDLTest_TestCaseReference *audioTests[] = { 1027 &audioTest1, &audioTest2, &audioTest3, &audioTest4, &audioTest5, &audioTest6, 1028 &audioTest7, &audioTest8, &audioTest9, &audioTest10, &audioTest11, 1029 &audioTest12, &audioTest13, &audioTest14, &audioTest15, NULL 1030 }; 1031 1032 /* Audio test suite (global) */ 1033 SDLTest_TestSuiteReference audioTestSuite = { 1034 "Audio", 1035 _audioSetUp, 1036 audioTests, 1037 _audioTearDown 1038 };