test/testautomation_audio.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 07 Dec 2017 16:08:09 -0800
changeset 11730 ac6c607e065c
parent 11272 d60ede5a0c2e
permissions -rw-r--r--
Enable building the Metal renderer by default, and weak link the Metal framework so the SDL library is safe to use on older Macs
Also generate iOS versions of the Metal shaders
     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 };