SDL  2.0
testautomation_audio.c File Reference
#include <stdio.h>
#include <string.h>
#include "SDL.h"
#include "SDL_test.h"
+ Include dependency graph for testautomation_audio.c:

Go to the source code of this file.

Macros

#define _CRT_SECURE_NO_WARNINGS
 

Functions

void _audioSetUp (void *arg)
 
void _audioTearDown (void *arg)
 
void _audio_testCallback (void *userdata, Uint8 *stream, int len)
 
int audio_quitInitAudioSubSystem ()
 Stop and restart audio subsystem. More...
 
int audio_initQuitAudio ()
 Start and stop audio directly. More...
 
int audio_initOpenCloseQuitAudio ()
 Start, open, close and stop audio. More...
 
int audio_pauseUnpauseAudio ()
 Pause and unpause audio. More...
 
int audio_enumerateAndNameAudioDevices ()
 Enumerate and name available audio devices (output and capture). More...
 
int audio_enumerateAndNameAudioDevicesNegativeTests ()
 Negative tests around enumeration and naming of audio devices. More...
 
int audio_printAudioDrivers ()
 Checks available audio driver names. More...
 
int audio_printCurrentAudioDriver ()
 Checks current audio driver name with initialized audio. More...
 
int audio_buildAudioCVT ()
 Builds various audio conversion structures. More...
 
int audio_buildAudioCVTNegative ()
 Checkes calls with invalid input to SDL_BuildAudioCVT. More...
 
int audio_getAudioStatus ()
 Checks current audio status. More...
 
int audio_openCloseAndGetAudioStatus ()
 Opens, checks current audio status, and closes a device. More...
 
int audio_lockUnlockOpenAudioDevice ()
 Locks and unlocks open audio device. More...
 
int audio_convertAudio ()
 Convert audio using various conversion structures. More...
 
int audio_openCloseAudioDeviceConnected ()
 Opens, checks current connected status, and closes a device. More...
 

Variables

int _audio_testCallbackCounter
 
int _audio_testCallbackLength
 
const int _numAudioFormats = 18
 
SDL_AudioFormat _audioFormats []
 
char * _audioFormatsVerbose []
 
const int _numAudioChannels = 4
 
Uint8 _audioChannels [] = { 1, 2, 4, 6 }
 
const int _numAudioFrequencies = 4
 
int _audioFrequencies [] = { 11025, 22050, 44100, 48000 }
 
static const SDLTest_TestCaseReference audioTest1
 
static const SDLTest_TestCaseReference audioTest2
 
static const SDLTest_TestCaseReference audioTest3
 
static const SDLTest_TestCaseReference audioTest4
 
static const SDLTest_TestCaseReference audioTest5
 
static const SDLTest_TestCaseReference audioTest6
 
static const SDLTest_TestCaseReference audioTest7
 
static const SDLTest_TestCaseReference audioTest8
 
static const SDLTest_TestCaseReference audioTest9
 
static const SDLTest_TestCaseReference audioTest10
 
static const SDLTest_TestCaseReference audioTest11
 
static const SDLTest_TestCaseReference audioTest12
 
static const SDLTest_TestCaseReference audioTest13
 
static const SDLTest_TestCaseReference audioTest14
 
static const SDLTest_TestCaseReference audioTest15
 
static const SDLTest_TestCaseReferenceaudioTests []
 
SDLTest_TestSuiteReference audioTestSuite
 

Macro Definition Documentation

◆ _CRT_SECURE_NO_WARNINGS

#define _CRT_SECURE_NO_WARNINGS

Original code: automated SDL audio test written by Edgar Simo "bobbens" New/updated tests: aschiffler at ferzkopp dot net

Definition at line 7 of file testautomation_audio.c.

Function Documentation

◆ _audio_testCallback()

void _audio_testCallback ( void userdata,
Uint8 stream,
int  len 
)

◆ _audioSetUp()

void _audioSetUp ( void arg)

Definition at line 20 of file testautomation_audio.c.

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) {
28  }
29 }

References SDL_GetError, SDL_INIT_AUDIO, SDL_InitSubSystem, SDLTest_AssertCheck(), SDLTest_AssertPass(), and SDLTest_LogError().

Referenced by audio_initOpenCloseQuitAudio(), audio_initQuitAudio(), audio_pauseUnpauseAudio(), and audio_quitInitAudioSubSystem().

◆ _audioTearDown()

void _audioTearDown ( void arg)

Definition at line 32 of file testautomation_audio.c.

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 }

References SDLTest_AssertPass().

◆ audio_buildAudioCVT()

int audio_buildAudioCVT ( )

Builds various audio conversion structures.

See also
https://wiki.libsdl.org/SDL_BuildAudioCVT

Definition at line 515 of file testautomation_audio.c.

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];
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) {
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 }

References _audioChannels, _audioFormats, _audioFormatsVerbose, _audioFrequencies, _numAudioChannels, _numAudioFormats, _numAudioFrequencies, AUDIO_S16LSB, AUDIO_S8, SDL_AudioSpec::channels, SDL_AudioSpec::format, SDL_AudioSpec::freq, i, j, k, SDL_AudioCVT::len_mult, SDL_BuildAudioCVT, SDL_GetError, SDLTest_AssertCheck(), SDLTest_AssertPass(), SDLTest_LogError(), SDLTest_RandomIntegerInRange(), and TEST_COMPLETED.

◆ audio_buildAudioCVTNegative()

int audio_buildAudioCVTNegative ( )

Checkes calls with invalid input to SDL_BuildAudioCVT.

See also
https://wiki.libsdl.org/SDL_BuildAudioCVT

Definition at line 579 of file testautomation_audio.c.

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 }

References AUDIO_S16LSB, AUDIO_S8, SDL_AudioSpec::channels, SDL_AudioSpec::format, SDL_AudioSpec::freq, i, NULL, SDL_BuildAudioCVT, SDL_ClearError, SDL_GetError, SDL_strcmp, SDL_strlcat, SDL_strlcpy, SDLTest_AssertCheck(), SDLTest_AssertPass(), SDLTest_Log(), and TEST_COMPLETED.

◆ audio_convertAudio()

int audio_convertAudio ( )

Convert audio using various conversion structures.

See also
https://wiki.libsdl.org/SDL_BuildAudioCVT
https://wiki.libsdl.org/SDL_ConvertAudio

Definition at line 817 of file testautomation_audio.c.

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) {
852  } else {
853  ii = 1;
854  }
855  if (c & 2) {
857  } else {
858  jj= j;
859  }
860  if (c & 4) {
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) {
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 }

References _audioChannels, _audioFormats, _audioFormatsVerbose, _audioFrequencies, _numAudioChannels, _numAudioFormats, _numAudioFrequencies, SDL_AudioCVT::buf, SDL_AudioSpec::channels, SDL_AudioSpec::format, SDL_AudioSpec::freq, i, j, k, SDL_AudioCVT::len, SDL_AudioCVT::len_mult, SDL_AudioCVT::len_ratio, NULL, SDL_BuildAudioCVT, SDL_ConvertAudio, SDL_free, SDL_GetError, SDL_malloc, SDL_strlcat, SDL_strlcpy, SDLTest_AssertCheck(), SDLTest_AssertPass(), SDLTest_Log(), SDLTest_LogError(), SDLTest_RandomIntegerInRange(), TEST_ABORTED, and TEST_COMPLETED.

◆ audio_enumerateAndNameAudioDevices()

int audio_enumerateAndNameAudioDevices ( )

Enumerate and name available audio devices (output and capture).

See also
https://wiki.libsdl.org/SDL_GetNumAudioDevices
https://wiki.libsdl.org/SDL_GetAudioDeviceName

Definition at line 346 of file testautomation_audio.c.

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. */
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++) {
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 }

References i, NULL, SDL_GetAudioDeviceName, SDL_GetNumAudioDevices, SDL_strcmp, SDLTest_AssertCheck(), SDLTest_AssertPass(), SDLTest_Log(), SDLTest_RandomIntegerInRange(), and TEST_COMPLETED.

◆ audio_enumerateAndNameAudioDevicesNegativeTests()

int audio_enumerateAndNameAudioDevicesNegativeTests ( )

Negative tests around enumeration and naming of audio devices.

See also
https://wiki.libsdl.org/SDL_GetNumAudioDevices
https://wiki.libsdl.org/SDL_GetAudioDeviceName

Definition at line 404 of file testautomation_audio.c.

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 */
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;
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;
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 }

References i, j, NULL, SDL_GetAudioDeviceName, SDL_GetNumAudioDevices, SDLTest_AssertCheck(), SDLTest_AssertPass(), SDLTest_RandomIntegerInRange(), and TEST_COMPLETED.

◆ audio_getAudioStatus()

int audio_getAudioStatus ( )

Checks current audio status.

See also
https://wiki.libsdl.org/SDL_GetAudioStatus

Definition at line 674 of file testautomation_audio.c.

675 {
677 
678  /* Check current audio status */
680  SDLTest_AssertPass("Call to SDL_GetAudioStatus()");
682  "Verify returned value; expected: STOPPED (%i) | PLAYING (%i) | PAUSED (%i), got: %i",
684 
685  return TEST_COMPLETED;
686 }

References SDL_AUDIO_PAUSED, SDL_AUDIO_PLAYING, SDL_AUDIO_STOPPED, SDL_GetAudioStatus, SDLTest_AssertCheck(), SDLTest_AssertPass(), and TEST_COMPLETED.

◆ audio_initOpenCloseQuitAudio()

int audio_initOpenCloseQuitAudio ( )

Start, open, close and stop audio.

See also
https://wiki.libsdl.org/SDL_InitAudio
https://wiki.libsdl.org/SDL_OpenAudio
https://wiki.libsdl.org/SDL_CloseAudio
https://wiki.libsdl.org/SDL_QuitAudio

Definition at line 139 of file testautomation_audio.c.

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 */
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 }

References _audio_testCallback(), _audioSetUp(), AUDIO_F32SYS, AUDIO_S16SYS, SDL_AudioSpec::callback, SDL_AudioSpec::channels, SDL_AudioSpec::format, SDL_AudioSpec::freq, i, j, k, NULL, SDL_AudioSpec::samples, SDL_AudioInit, SDL_AudioQuit, SDL_CloseAudio, SDL_GetAudioDriver, SDL_GetNumAudioDrivers, SDL_INIT_AUDIO, SDL_memset, SDL_OpenAudio, SDL_QuitSubSystem, SDLTest_AssertCheck(), SDLTest_AssertPass(), TEST_COMPLETED, and SDL_AudioSpec::userdata.

◆ audio_initQuitAudio()

int audio_initQuitAudio ( )

Start and stop audio directly.

See also
https://wiki.libsdl.org/SDL_InitAudio
https://wiki.libsdl.org/SDL_QuitAudio

Definition at line 83 of file testautomation_audio.c.

84 {
85  int result;
86  int i, iMax;
87  const char* audioDriver;
88 
89  /* Stop SDL audio subsystem */
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 }

References _audioSetUp(), i, NULL, SDL_AudioInit, SDL_AudioQuit, SDL_GetAudioDriver, SDL_GetNumAudioDrivers, SDL_INIT_AUDIO, SDL_QuitSubSystem, SDLTest_AssertCheck(), SDLTest_AssertPass(), and TEST_COMPLETED.

◆ audio_lockUnlockOpenAudioDevice()

int audio_lockUnlockOpenAudioDevice ( )

Locks and unlocks open audio device.

See also
https://wiki.libsdl.org/SDL_LockAudioDevice
https://wiki.libsdl.org/SDL_UnlockAudioDevice

Definition at line 754 of file testautomation_audio.c.

755 {
756  int i;
757  int count;
758  char *device;
760  SDL_AudioSpec desired, obtained;
761 
762  /* Get number of devices. */
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;
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 */
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 */
796  SDLTest_AssertPass("SDL_UnlockAudioDevice(%i)", id);
797 
798  /* Close device again */
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 }

References _audio_testCallback(), AUDIO_S16SYS, SDL_AudioSpec::callback, SDL_AudioSpec::channels, device, SDL_AudioSpec::format, SDL_AudioSpec::freq, i, NULL, SDL_AudioSpec::samples, SDL_AUDIO_ALLOW_ANY_CHANGE, SDL_CloseAudioDevice, SDL_Delay, SDL_GetAudioDeviceName, SDL_GetNumAudioDevices, SDL_LockAudioDevice, SDL_OpenAudioDevice, SDL_UnlockAudioDevice, SDLTest_AssertCheck(), SDLTest_AssertPass(), SDLTest_Log(), TEST_ABORTED, TEST_COMPLETED, and SDL_AudioSpec::userdata.

◆ audio_openCloseAndGetAudioStatus()

int audio_openCloseAndGetAudioStatus ( )

Opens, checks current audio status, and closes a device.

See also
https://wiki.libsdl.org/SDL_GetAudioStatus

Definition at line 695 of file testautomation_audio.c.

696 {
698  int i;
699  int count;
700  char *device;
702  SDL_AudioSpec desired, obtained;
703 
704  /* Get number of devices. */
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;
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 */
731  SDLTest_AssertPass("Call to SDL_GetAudioDeviceStatus()");
733  "Verify returned value; expected: STOPPED (%i) | PLAYING (%i) | PAUSED (%i), got: %i",
735 
736  /* Close device again */
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 }

References _audio_testCallback(), AUDIO_S16SYS, SDL_AudioSpec::callback, SDL_AudioSpec::channels, device, SDL_AudioSpec::format, SDL_AudioSpec::freq, i, NULL, SDL_AudioSpec::samples, SDL_AUDIO_ALLOW_ANY_CHANGE, SDL_AUDIO_PAUSED, SDL_AUDIO_PLAYING, SDL_AUDIO_STOPPED, SDL_CloseAudioDevice, SDL_GetAudioDeviceName, SDL_GetAudioDeviceStatus, SDL_GetNumAudioDevices, SDL_OpenAudioDevice, SDLTest_AssertCheck(), SDLTest_AssertPass(), SDLTest_Log(), TEST_ABORTED, TEST_COMPLETED, and SDL_AudioSpec::userdata.

◆ audio_openCloseAudioDeviceConnected()

int audio_openCloseAudioDeviceConnected ( )

Opens, checks current connected status, and closes a device.

See also
https://wiki.libsdl.org/SDL_AudioDeviceConnected

Definition at line 915 of file testautomation_audio.c.

916 {
917  int result = -1;
918  int i;
919  int count;
920  char *device;
922  SDL_AudioSpec desired, obtained;
923 
924  /* Get number of devices. */
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;
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 */
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 }

References _audio_testCallback(), AUDIO_S16SYS, SDL_AudioSpec::callback, SDL_AudioSpec::channels, device, SDL_AudioSpec::format, SDL_AudioSpec::freq, i, NULL, SDL_AudioSpec::samples, SDL_AUDIO_ALLOW_ANY_CHANGE, SDL_CloseAudioDevice, SDL_GetAudioDeviceName, SDL_GetNumAudioDevices, SDL_OpenAudioDevice, SDLTest_AssertCheck(), SDLTest_AssertPass(), SDLTest_Log(), TEST_ABORTED, TEST_COMPLETED, and SDL_AudioSpec::userdata.

◆ audio_pauseUnpauseAudio()

int audio_pauseUnpauseAudio ( )

Pause and unpause audio.

See also
https://wiki.libsdl.org/SDL_PauseAudio

Definition at line 225 of file testautomation_audio.c.

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 */
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 */
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 }

References _audio_testCallback(), _audio_testCallbackCounter, _audio_testCallbackLength, _audioSetUp(), AUDIO_F32SYS, AUDIO_S16SYS, SDL_AudioSpec::callback, SDL_AudioSpec::channels, SDL_AudioSpec::format, SDL_AudioSpec::freq, i, j, k, NULL, SDL_AudioSpec::samples, SDL_AudioInit, SDL_AudioQuit, SDL_CloseAudio, SDL_Delay, SDL_GetAudioDriver, SDL_GetNumAudioDrivers, SDL_INIT_AUDIO, SDL_memset, SDL_OpenAudio, SDL_PauseAudio, SDL_QuitSubSystem, SDLTest_AssertCheck(), SDLTest_AssertPass(), SDLTest_Log(), SDLTest_RandomIntegerInRange(), TEST_COMPLETED, and SDL_AudioSpec::userdata.

◆ audio_printAudioDrivers()

int audio_printAudioDrivers ( )

Checks available audio driver names.

See also
https://wiki.libsdl.org/SDL_GetNumAudioDrivers
https://wiki.libsdl.org/SDL_GetAudioDriver

Definition at line 451 of file testautomation_audio.c.

452 {
453  int i, n;
454  const char *name;
455 
456  /* Get number of drivers */
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++) {
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 }

References i, NULL, SDL_GetAudioDriver, SDL_GetNumAudioDrivers, SDLTest_AssertCheck(), SDLTest_AssertPass(), and TEST_COMPLETED.

◆ audio_printCurrentAudioDriver()

int audio_printCurrentAudioDriver ( )

Checks current audio driver name with initialized audio.

See also
https://wiki.libsdl.org/SDL_GetCurrentAudioDriver

Definition at line 483 of file testautomation_audio.c.

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 }

References NULL, SDL_GetCurrentAudioDriver, SDLTest_AssertCheck(), SDLTest_AssertPass(), and TEST_COMPLETED.

◆ audio_quitInitAudioSubSystem()

int audio_quitInitAudioSubSystem ( )

Stop and restart audio subsystem.

See also
https://wiki.libsdl.org/SDL_QuitSubSystem
https://wiki.libsdl.org/SDL_InitSubSystem

Definition at line 65 of file testautomation_audio.c.

66 {
67  /* Stop SDL audio subsystem */
69  SDLTest_AssertPass("Call to SDL_QuitSubSystem(SDL_INIT_AUDIO)");
70 
71  /* Restart audio again */
73 
74  return TEST_COMPLETED;
75 }

References _audioSetUp(), NULL, SDL_INIT_AUDIO, SDL_QuitSubSystem, SDLTest_AssertPass(), and TEST_COMPLETED.

Variable Documentation

◆ _audio_testCallbackCounter

int _audio_testCallbackCounter

Definition at line 42 of file testautomation_audio.c.

Referenced by _audio_testCallback(), and audio_pauseUnpauseAudio().

◆ _audio_testCallbackLength

int _audio_testCallbackLength

Definition at line 45 of file testautomation_audio.c.

Referenced by _audio_testCallback(), and audio_pauseUnpauseAudio().

◆ _audioChannels

Uint8 _audioChannels[] = { 1, 2, 4, 6 }

Definition at line 505 of file testautomation_audio.c.

Referenced by audio_buildAudioCVT(), and audio_convertAudio().

◆ _audioFormats

◆ _audioFormatsVerbose

char* _audioFormatsVerbose[]
Initial value:
= { "AUDIO_S8", "AUDIO_U8", "AUDIO_S16LSB", "AUDIO_S16MSB", "AUDIO_S16SYS", "AUDIO_S16", "AUDIO_U16LSB",
"AUDIO_U16MSB", "AUDIO_U16SYS", "AUDIO_U16", "AUDIO_S32LSB", "AUDIO_S32MSB", "AUDIO_S32SYS", "AUDIO_S32",
"AUDIO_F32LSB", "AUDIO_F32MSB", "AUDIO_F32SYS", "AUDIO_F32" }

Definition at line 501 of file testautomation_audio.c.

Referenced by audio_buildAudioCVT(), and audio_convertAudio().

◆ _audioFrequencies

int _audioFrequencies[] = { 11025, 22050, 44100, 48000 }

Definition at line 507 of file testautomation_audio.c.

Referenced by audio_buildAudioCVT(), and audio_convertAudio().

◆ _numAudioChannels

const int _numAudioChannels = 4

Definition at line 504 of file testautomation_audio.c.

Referenced by audio_buildAudioCVT(), and audio_convertAudio().

◆ _numAudioFormats

const int _numAudioFormats = 18

Definition at line 497 of file testautomation_audio.c.

Referenced by audio_buildAudioCVT(), and audio_convertAudio().

◆ _numAudioFrequencies

const int _numAudioFrequencies = 4

Definition at line 506 of file testautomation_audio.c.

Referenced by audio_buildAudioCVT(), and audio_convertAudio().

◆ audioTest1

const SDLTest_TestCaseReference audioTest1
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_enumerateAndNameAudioDevices, "audio_enumerateAndNameAudioDevices", "Enumerate and name available audio devices (output and capture)", TEST_ENABLED }

Definition at line 975 of file testautomation_audio.c.

◆ audioTest10

const SDLTest_TestCaseReference audioTest10
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_convertAudio, "audio_convertAudio", "Convert audio using available formats.", TEST_DISABLED }

Definition at line 1005 of file testautomation_audio.c.

◆ audioTest11

const SDLTest_TestCaseReference audioTest11
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_openCloseAudioDeviceConnected, "audio_openCloseAudioDeviceConnected", "Opens and closes audio device and get connected status.", TEST_DISABLED }

Definition at line 1010 of file testautomation_audio.c.

◆ audioTest12

const SDLTest_TestCaseReference audioTest12
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_quitInitAudioSubSystem, "audio_quitInitAudioSubSystem", "Quit and re-init audio subsystem.", TEST_ENABLED }

Definition at line 1013 of file testautomation_audio.c.

◆ audioTest13

const SDLTest_TestCaseReference audioTest13
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_initQuitAudio, "audio_initQuitAudio", "Init and quit audio drivers directly.", TEST_ENABLED }

Definition at line 1016 of file testautomation_audio.c.

◆ audioTest14

const SDLTest_TestCaseReference audioTest14
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_initOpenCloseQuitAudio, "audio_initOpenCloseQuitAudio", "Cycle through init, open, close and quit with various audio specs.", TEST_ENABLED }

Definition at line 1019 of file testautomation_audio.c.

◆ audioTest15

const SDLTest_TestCaseReference audioTest15
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_pauseUnpauseAudio, "audio_pauseUnpauseAudio", "Pause and Unpause audio for various audio specs while testing callback.", TEST_ENABLED }

Definition at line 1022 of file testautomation_audio.c.

◆ audioTest2

const SDLTest_TestCaseReference audioTest2
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_enumerateAndNameAudioDevicesNegativeTests, "audio_enumerateAndNameAudioDevicesNegativeTests", "Negative tests around enumeration and naming of audio devices.", TEST_ENABLED }

Definition at line 978 of file testautomation_audio.c.

◆ audioTest3

const SDLTest_TestCaseReference audioTest3
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_printAudioDrivers, "audio_printAudioDrivers", "Checks available audio driver names.", TEST_ENABLED }

Definition at line 981 of file testautomation_audio.c.

◆ audioTest4

const SDLTest_TestCaseReference audioTest4
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_printCurrentAudioDriver, "audio_printCurrentAudioDriver", "Checks current audio driver name with initialized audio.", TEST_ENABLED }

Definition at line 984 of file testautomation_audio.c.

◆ audioTest5

const SDLTest_TestCaseReference audioTest5
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_buildAudioCVT, "audio_buildAudioCVT", "Builds various audio conversion structures.", TEST_ENABLED }

Definition at line 987 of file testautomation_audio.c.

◆ audioTest6

const SDLTest_TestCaseReference audioTest6
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_buildAudioCVTNegative, "audio_buildAudioCVTNegative", "Checks calls with invalid input to SDL_BuildAudioCVT", TEST_ENABLED }

Definition at line 990 of file testautomation_audio.c.

◆ audioTest7

const SDLTest_TestCaseReference audioTest7
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_getAudioStatus, "audio_getAudioStatus", "Checks current audio status.", TEST_ENABLED }

Definition at line 993 of file testautomation_audio.c.

◆ audioTest8

const SDLTest_TestCaseReference audioTest8
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_openCloseAndGetAudioStatus, "audio_openCloseAndGetAudioStatus", "Opens and closes audio device and get audio status.", TEST_ENABLED }

Definition at line 996 of file testautomation_audio.c.

◆ audioTest9

const SDLTest_TestCaseReference audioTest9
static
Initial value:
=
{ (SDLTest_TestCaseFp)audio_lockUnlockOpenAudioDevice, "audio_lockUnlockOpenAudioDevice", "Locks and unlocks an open audio device.", TEST_ENABLED }

Definition at line 999 of file testautomation_audio.c.

◆ audioTests

◆ audioTestSuite

Initial value:

Reference to all test suites.

Definition at line 1033 of file testautomation_audio.c.

AUDIO_U16SYS
#define AUDIO_U16SYS
Definition: SDL_audio.h:122
SDL_CloseAudioDevice
#define SDL_CloseAudioDevice
Definition: SDL_dynapi_overrides.h:97
SDL_OpenAudio
#define SDL_OpenAudio
Definition: SDL_dynapi_overrides.h:78
SDL_GetAudioStatus
#define SDL_GetAudioStatus
Definition: SDL_dynapi_overrides.h:82
SDL_memset
#define SDL_memset
Definition: SDL_dynapi_overrides.h:386
SDL_AudioCVT::len_ratio
double len_ratio
Definition: SDL_audio.h:236
SDL_GetError
#define SDL_GetError
Definition: SDL_dynapi_overrides.h:113
SDL_AudioSpec::channels
Uint8 channels
Definition: SDL_audio.h:182
SDL_strlcat
#define SDL_strlcat
Definition: SDL_dynapi_overrides.h:396
_audioFormatsVerbose
char * _audioFormatsVerbose[]
Definition: testautomation_audio.c:501
audioTest13
static const SDLTest_TestCaseReference audioTest13
Definition: testautomation_audio.c:1016
SDL_strlcpy
#define SDL_strlcpy
Definition: SDL_dynapi_overrides.h:394
audioTest11
static const SDLTest_TestCaseReference audioTest11
Definition: testautomation_audio.c:1010
SDL_AudioInit
#define SDL_AudioInit
Definition: SDL_dynapi_overrides.h:75
AUDIO_U16LSB
#define AUDIO_U16LSB
Definition: SDL_audio.h:91
SDL_GetNumAudioDevices
#define SDL_GetNumAudioDevices
Definition: SDL_dynapi_overrides.h:79
SDL_ClearError
#define SDL_ClearError
Definition: SDL_dynapi_overrides.h:114
SDL_LockAudioDevice
#define SDL_LockAudioDevice
Definition: SDL_dynapi_overrides.h:93
SDL_BuildAudioCVT
#define SDL_BuildAudioCVT
Definition: SDL_dynapi_overrides.h:88
_numAudioChannels
const int _numAudioChannels
Definition: testautomation_audio.c:504
NULL
#define NULL
Definition: begin_code.h:167
AUDIO_S32MSB
#define AUDIO_S32MSB
Definition: SDL_audio.h:104
message
GLuint GLsizei const GLchar * message
Definition: SDL_opengl_glext.h:2483
SDL_OpenAudioDevice
#define SDL_OpenAudioDevice
Definition: SDL_dynapi_overrides.h:81
SDL_AudioSpec::samples
Uint16 samples
Definition: SDL_audio.h:184
SDL_AudioCVT::buf
Uint8 * buf
Definition: SDL_audio.h:232
audio_enumerateAndNameAudioDevicesNegativeTests
int audio_enumerateAndNameAudioDevicesNegativeTests()
Negative tests around enumeration and naming of audio devices.
Definition: testautomation_audio.c:404
SDL_AudioSpec::format
SDL_AudioFormat format
Definition: SDL_audio.h:181
count
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1570
SDLTest_Log
void SDLTest_Log(SDL_PRINTF_FORMAT_STRING const char *fmt,...) SDL_PRINTF_VARARG_FUNC(1)
Prints given message with a timestamp in the TEST category and INFO priority.
Definition: SDL_test_log.c:85
audio_initOpenCloseQuitAudio
int audio_initOpenCloseQuitAudio()
Start, open, close and stop audio.
Definition: testautomation_audio.c:139
SDL_AudioSpec::callback
SDL_AudioCallback callback
Definition: SDL_audio.h:187
SDL_QuitSubSystem
#define SDL_QuitSubSystem
Definition: SDL_dynapi_overrides.h:56
TEST_ENABLED
#define TEST_ENABLED
Definition: SDL_test_harness.h:47
audio_convertAudio
int audio_convertAudio()
Convert audio using various conversion structures.
Definition: testautomation_audio.c:817
SDL_AudioSpec
Definition: SDL_audio.h:178
audio_getAudioStatus
int audio_getAudioStatus()
Checks current audio status.
Definition: testautomation_audio.c:674
audio_buildAudioCVT
int audio_buildAudioCVT()
Builds various audio conversion structures.
Definition: testautomation_audio.c:515
SDL_AudioStatus
SDL_AudioStatus
Definition: SDL_audio.h:395
SDL_AudioSpec::userdata
void * userdata
Definition: SDL_audio.h:188
audio_pauseUnpauseAudio
int audio_pauseUnpauseAudio()
Pause and unpause audio.
Definition: testautomation_audio.c:225
audio_buildAudioCVTNegative
int audio_buildAudioCVTNegative()
Checkes calls with invalid input to SDL_BuildAudioCVT.
Definition: testautomation_audio.c:579
SDL_AudioQuit
#define SDL_AudioQuit
Definition: SDL_dynapi_overrides.h:76
SDL_InitSubSystem
#define SDL_InitSubSystem
Definition: SDL_dynapi_overrides.h:55
audio_printAudioDrivers
int audio_printAudioDrivers()
Checks available audio driver names.
Definition: testautomation_audio.c:451
c
const GLubyte * c
Definition: SDL_opengl_glext.h:11093
result
GLuint64EXT * result
Definition: SDL_opengl_glext.h:9432
SDL_AudioCVT::len_mult
int len_mult
Definition: SDL_audio.h:235
audioTest7
static const SDLTest_TestCaseReference audioTest7
Definition: testautomation_audio.c:993
audio_openCloseAndGetAudioStatus
int audio_openCloseAndGetAudioStatus()
Opens, checks current audio status, and closes a device.
Definition: testautomation_audio.c:695
AUDIO_S16SYS
#define AUDIO_S16SYS
Definition: SDL_audio.h:123
n
GLdouble n
Definition: SDL_opengl_glext.h:1952
_numAudioFrequencies
const int _numAudioFrequencies
Definition: testautomation_audio.c:506
_audioChannels
Uint8 _audioChannels[]
Definition: testautomation_audio.c:505
SDL_AUDIO_PAUSED
Definition: SDL_audio.h:399
AUDIO_U8
#define AUDIO_U8
Definition: SDL_audio.h:89
SDL_PauseAudio
#define SDL_PauseAudio
Definition: SDL_dynapi_overrides.h:84
_audioSetUp
void _audioSetUp(void *arg)
Definition: testautomation_audio.c:20
audioTest5
static const SDLTest_TestCaseReference audioTest5
Definition: testautomation_audio.c:987
len
GLenum GLsizei len
Definition: SDL_opengl_glext.h:2926
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179
_audio_testCallbackCounter
int _audio_testCallbackCounter
Definition: testautomation_audio.c:42
_audio_testCallbackLength
int _audio_testCallbackLength
Definition: testautomation_audio.c:45
SDL_ConvertAudio
#define SDL_ConvertAudio
Definition: SDL_dynapi_overrides.h:89
_audioFormats
SDL_AudioFormat _audioFormats[]
Definition: testautomation_audio.c:498
AUDIO_F32MSB
#define AUDIO_F32MSB
Definition: SDL_audio.h:113
SDL_GetAudioDeviceName
#define SDL_GetAudioDeviceName
Definition: SDL_dynapi_overrides.h:80
audioTest12
static const SDLTest_TestCaseReference audioTest12
Definition: testautomation_audio.c:1013
SDL_AUDIO_STOPPED
Definition: SDL_audio.h:397
SDLTest_TestCaseFp
int(* SDLTest_TestCaseFp)(void *arg)
Definition: SDL_test_harness.h:67
SDLTest_AssertPass
void SDLTest_AssertPass(SDL_PRINTF_FORMAT_STRING const char *assertDescription,...) SDL_PRINTF_VARARG_FUNC(1)
Explicitly pass without checking an assertion condition. Updates assertion counter.
Definition: SDL_test_assert.c:94
_audioTearDown
void _audioTearDown(void *arg)
Definition: testautomation_audio.c:32
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
TEST_ABORTED
#define TEST_ABORTED
Definition: SDL_test_harness.h:51
t
GLdouble GLdouble t
Definition: SDL_opengl.h:2070
AUDIO_S32
#define AUDIO_S32
Definition: SDL_audio.h:105
SDL_AUDIO_ALLOW_ANY_CHANGE
#define SDL_AUDIO_ALLOW_ANY_CHANGE
Definition: SDL_audio.h:144
audioTest6
static const SDLTest_TestCaseReference audioTest6
Definition: testautomation_audio.c:990
audio_quitInitAudioSubSystem
int audio_quitInitAudioSubSystem()
Stop and restart audio subsystem.
Definition: testautomation_audio.c:65
name
GLuint const GLchar * name
Definition: SDL_opengl_glext.h:660
AUDIO_F32SYS
#define AUDIO_F32SYS
Definition: SDL_audio.h:125
audioTest1
static const SDLTest_TestCaseReference audioTest1
Definition: testautomation_audio.c:975
SDLTest_AssertCheck
int SDLTest_AssertCheck(int assertCondition, SDL_PRINTF_FORMAT_STRING const char *assertDescription,...) SDL_PRINTF_VARARG_FUNC(2)
Assert for test cases that logs but does not break execution flow on failures. Updates assertion coun...
Definition: SDL_test_assert.c:65
k
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int int int return Display Window Cursor return Display Window return Display Drawable GC int int unsigned int unsigned int return Display Drawable GC int int _Xconst char int return Display Drawable GC int int unsigned int unsigned int return Display return Display Cursor return Display GC return XModifierKeymap return char Display Window int return Display return Display Atom return Display Window XWindowAttributes return Display Window return Display XEvent Bool(*) XPointer return Display Window Bool unsigned int int int Window Cursor Time return Display Window int return KeySym return Display _Xconst char Bool return Display _Xconst char return XKeyEvent char int KeySym XComposeStatus return Display int int int XVisualInfo return Display Window int int return _Xconst char return Display XEvent return Display Drawable GC XImage int int int int unsigned int unsigned int return Display Window Window Window int int int int unsigned int return Display Window Window int int return Display Window unsigned int unsigned int return Display Window Bool long XEvent return Display GC unsigned long return Display Window int Time return Display Window Window return Display Window unsigned long return Display Window XSizeHints Display Colormap XColor int return char int XTextProperty return XFontStruct _Xconst char int int int int XCharStruct return Display Window return Display Time return Display Colormap return Display Window Window int int unsigned int unsigned int int int return Display Window int return XExtensionInfo Display char XExtensionHooks int XPointer return XExtensionInfo XExtensionInfo Display return Display return Display unsigned long Display GC Display char long Display xReply int Bool return Display Bool return Display int SDL_X11_XESetEventToWireRetType return Display Window Window Window Window unsigned int return Display XShmSegmentInfo return Display Drawable GC XImage int int int int unsigned int unsigned int Boo k)
Definition: SDL_x11sym.h:213
audioTest14
static const SDLTest_TestCaseReference audioTest14
Definition: testautomation_audio.c:1019
audio_openCloseAudioDeviceConnected
int audio_openCloseAudioDeviceConnected()
Opens, checks current connected status, and closes a device.
Definition: testautomation_audio.c:915
SDL_GetAudioDeviceStatus
#define SDL_GetAudioDeviceStatus
Definition: SDL_dynapi_overrides.h:83
AUDIO_F32LSB
#define AUDIO_F32LSB
Definition: SDL_audio.h:112
TEST_COMPLETED
#define TEST_COMPLETED
Definition: SDL_test_harness.h:53
_audioFrequencies
int _audioFrequencies[]
Definition: testautomation_audio.c:507
audio_printCurrentAudioDriver
int audio_printCurrentAudioDriver()
Checks current audio driver name with initialized audio.
Definition: testautomation_audio.c:483
SDL_Delay
#define SDL_Delay
Definition: SDL_dynapi_overrides.h:486
SDL_AudioSpec::freq
int freq
Definition: SDL_audio.h:180
SDL_AudioDeviceID
Uint32 SDL_AudioDeviceID
Definition: SDL_audio.h:330
audioTest2
static const SDLTest_TestCaseReference audioTest2
Definition: testautomation_audio.c:978
AUDIO_S32LSB
#define AUDIO_S32LSB
Definition: SDL_audio.h:103
SDL_GetAudioDriver
#define SDL_GetAudioDriver
Definition: SDL_dynapi_overrides.h:74
SDL_GetCurrentAudioDriver
#define SDL_GetCurrentAudioDriver
Definition: SDL_dynapi_overrides.h:77
id
GLuint id
Definition: SDL_opengl_glext.h:528
audioTest3
static const SDLTest_TestCaseReference audioTest3
Definition: testautomation_audio.c:981
audio_initQuitAudio
int audio_initQuitAudio()
Start and stop audio directly.
Definition: testautomation_audio.c:83
SDL_AudioCVT::len
int len
Definition: SDL_audio.h:233
audio_enumerateAndNameAudioDevices
int audio_enumerateAndNameAudioDevices()
Enumerate and name available audio devices (output and capture).
Definition: testautomation_audio.c:346
audioTest8
static const SDLTest_TestCaseReference audioTest8
Definition: testautomation_audio.c:996
AUDIO_S16
#define AUDIO_S16
Definition: SDL_audio.h:96
SDL_AUDIO_PLAYING
Definition: SDL_audio.h:398
AUDIO_S32SYS
#define AUDIO_S32SYS
Definition: SDL_audio.h:124
j
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int int in j)
Definition: SDL_x11sym.h:50
SDLTest_LogError
void SDLTest_LogError(SDL_PRINTF_FORMAT_STRING const char *fmt,...) SDL_PRINTF_VARARG_FUNC(1)
Prints given message with a timestamp in the TEST category and the ERROR priority.
Definition: SDL_test_log.c:103
AUDIO_S16MSB
#define AUDIO_S16MSB
Definition: SDL_audio.h:94
audioTest9
static const SDLTest_TestCaseReference audioTest9
Definition: testautomation_audio.c:999
audio_lockUnlockOpenAudioDevice
int audio_lockUnlockOpenAudioDevice()
Locks and unlocks open audio device.
Definition: testautomation_audio.c:754
audioTest4
static const SDLTest_TestCaseReference audioTest4
Definition: testautomation_audio.c:984
SDL_CloseAudio
#define SDL_CloseAudio
Definition: SDL_dynapi_overrides.h:96
_numAudioFormats
const int _numAudioFormats
Definition: testautomation_audio.c:497
AUDIO_S16LSB
#define AUDIO_S16LSB
Definition: SDL_audio.h:92
TEST_DISABLED
#define TEST_DISABLED
Definition: SDL_test_harness.h:48
AUDIO_S8
#define AUDIO_S8
Definition: SDL_audio.h:90
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:374
audioTests
static const SDLTest_TestCaseReference * audioTests[]
Definition: testautomation_audio.c:1026
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:417
SDL_AudioCVT
A structure to hold a set of audio conversion filters and buffers.
Definition: SDL_audio.h:226
_audio_testCallback
void _audio_testCallback(void *userdata, Uint8 *stream, int len)
Definition: testautomation_audio.c:49
device
static SDL_AudioDeviceID device
Definition: loopwave.c:37
audioTest10
static const SDLTest_TestCaseReference audioTest10
Definition: testautomation_audio.c:1005
SDL_UnlockAudioDevice
#define SDL_UnlockAudioDevice
Definition: SDL_dynapi_overrides.h:95
AUDIO_F32
#define AUDIO_F32
Definition: SDL_audio.h:114
AUDIO_U16MSB
#define AUDIO_U16MSB
Definition: SDL_audio.h:93
i
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
AUDIO_U16
#define AUDIO_U16
Definition: SDL_audio.h:95
audioTest15
static const SDLTest_TestCaseReference audioTest15
Definition: testautomation_audio.c:1022
SDL_GetNumAudioDrivers
#define SDL_GetNumAudioDrivers
Definition: SDL_dynapi_overrides.h:73
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:78
SDLTest_RandomIntegerInRange
Sint32 SDLTest_RandomIntegerInRange(Sint32 min, Sint32 max)
Definition: SDL_test_fuzzer.c:163