SDL  2.0
testautomation_audio.c
Go to the documentation of this file.
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 };