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