Mercurial > hg > sv-dependency-builds

annotate src/portaudio/qa/paqa_errs.c @ 114:241db1b1eff2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
added includes as well
author Matthias Mauch <matthiasmauch@gmail.com>
date Thu, 09 Jan 2014 13:23:08 +0000
parents 8a15ff55d9af
children
rev   line source
cannam@89 1 /** @file paqa_errs.c
cannam@89 2 @ingroup qa_src
cannam@89 3 @brief Self Testing Quality Assurance app for PortAudio
cannam@89 4 Do lots of bad things to test error reporting.
cannam@89 5 @author Phil Burk http://www.softsynth.com
cannam@89 6 Pieter Suurmond adapted to V19 API.
cannam@89 7 */
cannam@89 8 /*
cannam@89 9 * $Id: paqa_errs.c 1756 2011-09-08 06:09:29Z philburk $
cannam@89 10 *
cannam@89 11 * This program uses the PortAudio Portable Audio Library.
cannam@89 12 * For more information see: http://www.portaudio.com
cannam@89 13 * Copyright (c) 1999-2000 Ross Bencina and Phil Burk
cannam@89 14 *
cannam@89 15 * Permission is hereby granted, free of charge, to any person obtaining
cannam@89 16 * a copy of this software and associated documentation files
cannam@89 17 * (the "Software"), to deal in the Software without restriction,
cannam@89 18 * including without limitation the rights to use, copy, modify, merge,
cannam@89 19 * publish, distribute, sublicense, and/or sell copies of the Software,
cannam@89 20 * and to permit persons to whom the Software is furnished to do so,
cannam@89 21 * subject to the following conditions:
cannam@89 22 *
cannam@89 23 * The above copyright notice and this permission notice shall be
cannam@89 24 * included in all copies or substantial portions of the Software.
cannam@89 25 *
cannam@89 26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
cannam@89 27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
cannam@89 28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
cannam@89 29 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
cannam@89 30 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
cannam@89 31 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
cannam@89 32 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
cannam@89 33 */
cannam@89 34
cannam@89 35 /*
cannam@89 36 * The text above constitutes the entire PortAudio license; however,
cannam@89 37 * the PortAudio community also makes the following non-binding requests:
cannam@89 38 *
cannam@89 39 * Any person wishing to distribute modifications to the Software is
cannam@89 40 * requested to send the modifications to the original developer so that
cannam@89 41 * they can be incorporated into the canonical version. It is also
cannam@89 42 * requested that these non-binding requests be included along with the
cannam@89 43 * license above.
cannam@89 44 */
cannam@89 45
cannam@89 46 #include <stdio.h>
cannam@89 47 #include <math.h>
cannam@89 48
cannam@89 49 #include "portaudio.h"
cannam@89 50
cannam@89 51 /*--------- Definitions ---------*/
cannam@89 52 #define MODE_INPUT (0)
cannam@89 53 #define MODE_OUTPUT (1)
cannam@89 54 #define FRAMES_PER_BUFFER (64)
cannam@89 55 #define SAMPLE_RATE (44100.0)
cannam@89 56
cannam@89 57 typedef struct PaQaData
cannam@89 58 {
cannam@89 59 unsigned long framesLeft;
cannam@89 60 int numChannels;
cannam@89 61 int bytesPerSample;
cannam@89 62 int mode;
cannam@89 63 }
cannam@89 64 PaQaData;
cannam@89 65
cannam@89 66 static int gNumPassed = 0; /* Two globals */
cannam@89 67 static int gNumFailed = 0;
cannam@89 68
cannam@89 69 /*------------------- Macros ------------------------------*/
cannam@89 70 /* Print ERROR if it fails. Tally success or failure. Odd */
cannam@89 71 /* do-while wrapper seems to be needed for some compilers. */
cannam@89 72
cannam@89 73 #define EXPECT(_exp) \
cannam@89 74 do \
cannam@89 75 { \
cannam@89 76 if ((_exp)) {\
cannam@89 77 gNumPassed++; \
cannam@89 78 } \
cannam@89 79 else { \
cannam@89 80 printf("\nERROR - 0x%x - %s for %s\n", result, Pa_GetErrorText(result), #_exp ); \
cannam@89 81 gNumFailed++; \
cannam@89 82 goto error; \
cannam@89 83 } \
cannam@89 84 } while(0)
cannam@89 85
cannam@89 86 #define HOPEFOR(_exp) \
cannam@89 87 do \
cannam@89 88 { \
cannam@89 89 if ((_exp)) {\
cannam@89 90 gNumPassed++; \
cannam@89 91 } \
cannam@89 92 else { \
cannam@89 93 printf("\nERROR - 0x%x - %s for %s\n", result, Pa_GetErrorText(result), #_exp ); \
cannam@89 94 gNumFailed++; \
cannam@89 95 } \
cannam@89 96 } while(0)
cannam@89 97
cannam@89 98 /*-------------------------------------------------------------------------*/
cannam@89 99 /* This routine will be called by the PortAudio engine when audio is needed.
cannam@89 100 It may be called at interrupt level on some machines so don't do anything
cannam@89 101 that could mess up the system like calling malloc() or free().
cannam@89 102 */
cannam@89 103 static int QaCallback( const void* inputBuffer,
cannam@89 104 void* outputBuffer,
cannam@89 105 unsigned long framesPerBuffer,
cannam@89 106 const PaStreamCallbackTimeInfo* timeInfo,
cannam@89 107 PaStreamCallbackFlags statusFlags,
cannam@89 108 void* userData )
cannam@89 109 {
cannam@89 110 unsigned long i;
cannam@89 111 unsigned char* out = (unsigned char *) outputBuffer;
cannam@89 112 PaQaData* data = (PaQaData *) userData;
cannam@89 113
cannam@89 114 (void)inputBuffer; /* Prevent "unused variable" warnings. */
cannam@89 115
cannam@89 116 /* Zero out buffer so we don't hear terrible noise. */
cannam@89 117 if( data->mode == MODE_OUTPUT )
cannam@89 118 {
cannam@89 119 unsigned long numBytes = framesPerBuffer * data->numChannels * data->bytesPerSample;
cannam@89 120 for( i=0; i<numBytes; i++ )
cannam@89 121 {
cannam@89 122 *out++ = 0;
cannam@89 123 }
cannam@89 124 }
cannam@89 125 /* Are we through yet? */
cannam@89 126 if( data->framesLeft > framesPerBuffer )
cannam@89 127 {
cannam@89 128 data->framesLeft -= framesPerBuffer;
cannam@89 129 return 0;
cannam@89 130 }
cannam@89 131 else
cannam@89 132 {
cannam@89 133 data->framesLeft = 0;
cannam@89 134 return 1;
cannam@89 135 }
cannam@89 136 }
cannam@89 137
cannam@89 138 static PaDeviceIndex FindInputOnlyDevice(void)
cannam@89 139 {
cannam@89 140 PaDeviceIndex result = Pa_GetDefaultInputDevice();
cannam@89 141 if( result != paNoDevice && Pa_GetDeviceInfo(result)->maxOutputChannels == 0 )
cannam@89 142 return result;
cannam@89 143
cannam@89 144 for( result = 0; result < Pa_GetDeviceCount(); ++result )
cannam@89 145 {
cannam@89 146 if( Pa_GetDeviceInfo(result)->maxOutputChannels == 0 )
cannam@89 147 return result;
cannam@89 148 }
cannam@89 149
cannam@89 150 return paNoDevice;
cannam@89 151 }
cannam@89 152
cannam@89 153 static PaDeviceIndex FindOutputOnlyDevice(void)
cannam@89 154 {
cannam@89 155 PaDeviceIndex result = Pa_GetDefaultOutputDevice();
cannam@89 156 if( result != paNoDevice && Pa_GetDeviceInfo(result)->maxInputChannels == 0 )
cannam@89 157 return result;
cannam@89 158
cannam@89 159 for( result = 0; result < Pa_GetDeviceCount(); ++result )
cannam@89 160 {
cannam@89 161 if( Pa_GetDeviceInfo(result)->maxInputChannels == 0 )
cannam@89 162 return result;
cannam@89 163 }
cannam@89 164
cannam@89 165 return paNoDevice;
cannam@89 166 }
cannam@89 167
cannam@89 168 /*-------------------------------------------------------------------------------------------------*/
cannam@89 169 static int TestBadOpens( void )
cannam@89 170 {
cannam@89 171 PaStream* stream = NULL;
cannam@89 172 PaError result;
cannam@89 173 PaQaData myData;
cannam@89 174 PaStreamParameters ipp, opp;
cannam@89 175 const PaDeviceInfo* info = NULL;
cannam@89 176
cannam@89 177
cannam@89 178 /* Setup data for synthesis thread. */
cannam@89 179 myData.framesLeft = (unsigned long) (SAMPLE_RATE * 100); /* 100 seconds */
cannam@89 180 myData.numChannels = 1;
cannam@89 181 myData.mode = MODE_OUTPUT;
cannam@89 182
cannam@89 183 /*----------------------------- No devices specified: */
cannam@89 184 ipp.device = opp.device = paNoDevice;
cannam@89 185 ipp.channelCount = opp.channelCount = 0; /* Also no channels. */
cannam@89 186 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 187 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 188 /* Take the low latency of the default device for all subsequent tests. */
cannam@89 189 info = Pa_GetDeviceInfo(Pa_GetDefaultInputDevice());
cannam@89 190 ipp.suggestedLatency = info ? info->defaultLowInputLatency : 0.100;
cannam@89 191 info = Pa_GetDeviceInfo(Pa_GetDefaultOutputDevice());
cannam@89 192 opp.suggestedLatency = info ? info->defaultLowOutputLatency : 0.100;
cannam@89 193 HOPEFOR(((result = Pa_OpenStream(&stream, &ipp, &opp,
cannam@89 194 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 195 paClipOff, QaCallback, &myData )) == paInvalidDevice));
cannam@89 196
cannam@89 197 /*----------------------------- No devices specified #2: */
cannam@89 198 HOPEFOR(((result = Pa_OpenStream(&stream, NULL, NULL,
cannam@89 199 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 200 paClipOff, QaCallback, &myData )) == paInvalidDevice));
cannam@89 201
cannam@89 202 /*----------------------------- Out of range input device specified: */
cannam@89 203 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 204 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 205 ipp.channelCount = 0; ipp.device = Pa_GetDeviceCount(); /* And no output device, and no channels. */
cannam@89 206 opp.channelCount = 0; opp.device = paNoDevice;
cannam@89 207 HOPEFOR(((result = Pa_OpenStream(&stream, &ipp, NULL,
cannam@89 208 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 209 paClipOff, QaCallback, &myData )) == paInvalidDevice));
cannam@89 210
cannam@89 211 /*----------------------------- Out of range output device specified: */
cannam@89 212 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 213 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 214 ipp.channelCount = 0; ipp.device = paNoDevice; /* And no input device, and no channels. */
cannam@89 215 opp.channelCount = 0; opp.device = Pa_GetDeviceCount();
cannam@89 216 HOPEFOR(((result = Pa_OpenStream(&stream, NULL, &opp,
cannam@89 217 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 218 paClipOff, QaCallback, &myData )) == paInvalidDevice));
cannam@89 219
cannam@89 220 if (Pa_GetDefaultInputDevice() != paNoDevice) {
cannam@89 221 /*----------------------------- Zero input channels: */
cannam@89 222 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 223 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 224 ipp.channelCount = 0; ipp.device = Pa_GetDefaultInputDevice();
cannam@89 225 opp.channelCount = 0; opp.device = paNoDevice; /* And no output device, and no output channels. */
cannam@89 226 HOPEFOR(((result = Pa_OpenStream(&stream, &ipp, NULL,
cannam@89 227 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 228 paClipOff, QaCallback, &myData )) == paInvalidChannelCount));
cannam@89 229 }
cannam@89 230
cannam@89 231 if (Pa_GetDefaultOutputDevice() != paNoDevice) {
cannam@89 232 /*----------------------------- Zero output channels: */
cannam@89 233 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 234 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 235 ipp.channelCount = 0; ipp.device = paNoDevice; /* And no input device, and no input channels. */
cannam@89 236 opp.channelCount = 0; opp.device = Pa_GetDefaultOutputDevice();
cannam@89 237 HOPEFOR(((result = Pa_OpenStream(&stream, NULL, &opp,
cannam@89 238 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 239 paClipOff, QaCallback, &myData )) == paInvalidChannelCount));
cannam@89 240 }
cannam@89 241 /*----------------------------- Nonzero input and output channels but no output device: */
cannam@89 242 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 243 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 244 ipp.channelCount = 2; ipp.device = Pa_GetDefaultInputDevice(); /* Both stereo. */
cannam@89 245 opp.channelCount = 2; opp.device = paNoDevice;
cannam@89 246 HOPEFOR(((result = Pa_OpenStream(&stream, &ipp, &opp,
cannam@89 247 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 248 paClipOff, QaCallback, &myData )) == paInvalidDevice));
cannam@89 249
cannam@89 250 /*----------------------------- Nonzero input and output channels but no input device: */
cannam@89 251 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 252 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 253 ipp.channelCount = 2; ipp.device = paNoDevice;
cannam@89 254 opp.channelCount = 2; opp.device = Pa_GetDefaultOutputDevice();
cannam@89 255 HOPEFOR(((result = Pa_OpenStream(&stream, &ipp, &opp,
cannam@89 256 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 257 paClipOff, QaCallback, &myData )) == paInvalidDevice));
cannam@89 258
cannam@89 259 if (Pa_GetDefaultOutputDevice() != paNoDevice) {
cannam@89 260 /*----------------------------- NULL stream pointer: */
cannam@89 261 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 262 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 263 ipp.channelCount = 0; ipp.device = paNoDevice; /* Output is more likely than input. */
cannam@89 264 opp.channelCount = 2; opp.device = Pa_GetDefaultOutputDevice(); /* Only 2 output channels. */
cannam@89 265 HOPEFOR(((result = Pa_OpenStream(NULL, &ipp, &opp,
cannam@89 266 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 267 paClipOff, QaCallback, &myData )) == paBadStreamPtr));
cannam@89 268
cannam@89 269 /*----------------------------- Low sample rate: */
cannam@89 270 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 271 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 272 ipp.channelCount = 0; ipp.device = paNoDevice;
cannam@89 273 opp.channelCount = 2; opp.device = Pa_GetDefaultOutputDevice();
cannam@89 274 HOPEFOR(((result = Pa_OpenStream(&stream, NULL, &opp,
cannam@89 275 1.0, FRAMES_PER_BUFFER, /* 1 cycle per second (1 Hz) is too low. */
cannam@89 276 paClipOff, QaCallback, &myData )) == paInvalidSampleRate));
cannam@89 277
cannam@89 278 /*----------------------------- High sample rate: */
cannam@89 279 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 280 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 281 ipp.channelCount = 0; ipp.device = paNoDevice;
cannam@89 282 opp.channelCount = 2; opp.device = Pa_GetDefaultOutputDevice();
cannam@89 283 HOPEFOR(((result = Pa_OpenStream(&stream, NULL, &opp,
cannam@89 284 10000000.0, FRAMES_PER_BUFFER, /* 10^6 cycles per second (10 MHz) is too high. */
cannam@89 285 paClipOff, QaCallback, &myData )) == paInvalidSampleRate));
cannam@89 286
cannam@89 287 /*----------------------------- NULL callback: */
cannam@89 288 /* NULL callback is valid in V19 -- it means use blocking read/write stream
cannam@89 289
cannam@89 290 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 291 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 292 ipp.channelCount = 0; ipp.device = paNoDevice;
cannam@89 293 opp.channelCount = 2; opp.device = Pa_GetDefaultOutputDevice();
cannam@89 294 HOPEFOR(((result = Pa_OpenStream(&stream, NULL, &opp,
cannam@89 295 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 296 paClipOff,
cannam@89 297 NULL,
cannam@89 298 &myData )) == paNullCallback));
cannam@89 299 */
cannam@89 300
cannam@89 301 /*----------------------------- Bad flag: */
cannam@89 302 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 303 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 304 ipp.channelCount = 0; ipp.device = paNoDevice;
cannam@89 305 opp.channelCount = 2; opp.device = Pa_GetDefaultOutputDevice();
cannam@89 306 HOPEFOR(((result = Pa_OpenStream(&stream, NULL, &opp,
cannam@89 307 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 308 255, /* Is 8 maybe legal V19 API? */
cannam@89 309 QaCallback, &myData )) == paInvalidFlag));
cannam@89 310 }
cannam@89 311
cannam@89 312 /*----------------------------- using input device as output device: */
cannam@89 313 if( FindInputOnlyDevice() != paNoDevice )
cannam@89 314 {
cannam@89 315 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 316 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 317 ipp.channelCount = 0; ipp.device = paNoDevice; /* And no input device, and no channels. */
cannam@89 318 opp.channelCount = 2; opp.device = FindInputOnlyDevice();
cannam@89 319 HOPEFOR(((result = Pa_OpenStream(&stream, NULL, &opp,
cannam@89 320 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 321 paClipOff, QaCallback, &myData )) == paInvalidChannelCount));
cannam@89 322 }
cannam@89 323
cannam@89 324 /*----------------------------- using output device as input device: */
cannam@89 325 if( FindOutputOnlyDevice() != paNoDevice )
cannam@89 326 {
cannam@89 327 ipp.hostApiSpecificStreamInfo = opp.hostApiSpecificStreamInfo = NULL;
cannam@89 328 ipp.sampleFormat = opp.sampleFormat = paFloat32;
cannam@89 329 ipp.channelCount = 2; ipp.device = FindOutputOnlyDevice();
cannam@89 330 opp.channelCount = 0; opp.device = paNoDevice; /* And no output device, and no channels. */
cannam@89 331 HOPEFOR(((result = Pa_OpenStream(&stream, &ipp, NULL,
cannam@89 332 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 333 paClipOff, QaCallback, &myData )) == paInvalidChannelCount));
cannam@89 334
cannam@89 335 }
cannam@89 336
cannam@89 337 if( stream != NULL ) Pa_CloseStream( stream );
cannam@89 338 return result;
cannam@89 339 }
cannam@89 340
cannam@89 341 /*-----------------------------------------------------------------------------------------*/
cannam@89 342 static int TestBadActions( void )
cannam@89 343 {
cannam@89 344 PaStream* stream = NULL;
cannam@89 345 const PaDeviceInfo* deviceInfo = NULL;
cannam@89 346 PaError result = 0;
cannam@89 347 PaQaData myData;
cannam@89 348 PaStreamParameters opp;
cannam@89 349 const PaDeviceInfo* info = NULL;
cannam@89 350
cannam@89 351 /* Setup data for synthesis thread. */
cannam@89 352 myData.framesLeft = (unsigned long)(SAMPLE_RATE * 100); /* 100 seconds */
cannam@89 353 myData.numChannels = 1;
cannam@89 354 myData.mode = MODE_OUTPUT;
cannam@89 355
cannam@89 356 opp.device = Pa_GetDefaultOutputDevice(); /* Default output. */
cannam@89 357 opp.channelCount = 2; /* Stereo output. */
cannam@89 358 opp.hostApiSpecificStreamInfo = NULL;
cannam@89 359 opp.sampleFormat = paFloat32;
cannam@89 360 info = Pa_GetDeviceInfo(opp.device);
cannam@89 361 opp.suggestedLatency = info ? info->defaultLowOutputLatency : 0.100;
cannam@89 362
cannam@89 363 if (opp.device != paNoDevice) {
cannam@89 364 HOPEFOR(((result = Pa_OpenStream(&stream, NULL, /* Take NULL as input parame- */
cannam@89 365 &opp, /* ters, meaning try only output. */
cannam@89 366 SAMPLE_RATE, FRAMES_PER_BUFFER,
cannam@89 367 paClipOff, QaCallback, &myData )) == paNoError));
cannam@89 368 }
cannam@89 369
cannam@89 370 HOPEFOR(((deviceInfo = Pa_GetDeviceInfo(paNoDevice)) == NULL));
cannam@89 371 HOPEFOR(((deviceInfo = Pa_GetDeviceInfo(87654)) == NULL));
cannam@89 372 HOPEFOR(((result = Pa_StartStream(NULL)) == paBadStreamPtr));
cannam@89 373 HOPEFOR(((result = Pa_StopStream(NULL)) == paBadStreamPtr));
cannam@89 374 HOPEFOR(((result = Pa_IsStreamStopped(NULL)) == paBadStreamPtr));
cannam@89 375 HOPEFOR(((result = Pa_IsStreamActive(NULL)) == paBadStreamPtr));
cannam@89 376 HOPEFOR(((result = Pa_CloseStream(NULL)) == paBadStreamPtr));
cannam@89 377 HOPEFOR(((result = Pa_SetStreamFinishedCallback(NULL, NULL)) == paBadStreamPtr));
cannam@89 378 HOPEFOR(((result = !Pa_GetStreamInfo(NULL))));
cannam@89 379 HOPEFOR(((result = Pa_GetStreamTime(NULL)) == 0.0));
cannam@89 380 HOPEFOR(((result = Pa_GetStreamCpuLoad(NULL)) == 0.0));
cannam@89 381 HOPEFOR(((result = Pa_ReadStream(NULL, NULL, 0)) == paBadStreamPtr));
cannam@89 382 HOPEFOR(((result = Pa_WriteStream(NULL, NULL, 0)) == paBadStreamPtr));
cannam@89 383
cannam@89 384 /** @todo test Pa_GetStreamReadAvailable and Pa_GetStreamWriteAvailable */
cannam@89 385
cannam@89 386 if (stream != NULL) Pa_CloseStream(stream);
cannam@89 387 return result;
cannam@89 388 }
cannam@89 389
cannam@89 390 /*---------------------------------------------------------------------*/
cannam@89 391 int main(void);
cannam@89 392 int main(void)
cannam@89 393 {
cannam@89 394 PaError result;
cannam@89 395
cannam@89 396 EXPECT(((result = Pa_Initialize()) == paNoError));
cannam@89 397 TestBadOpens();
cannam@89 398 TestBadActions();
cannam@89 399 error:
cannam@89 400 Pa_Terminate();
cannam@89 401 printf("QA Report: %d passed, %d failed.\n", gNumPassed, gNumFailed);
cannam@89 402 return 0;
cannam@89 403 }