src/test/SDL_test_fuzzer.c
author Ryan C. Gordon <icculus@icculus.org>
Sun, 31 Mar 2013 12:48:50 -0400
changeset 7037 3fedf1f25b94
parent 6885 700f1b25f77f
child 7172 b3569dff1c6e
permissions -rw-r--r--
Make SDL_SetError and friends unconditionally return -1.

This lets us change things like this...

if (Failed) {
SDL_SetError("We failed");
return -1;
}

...into this...

if (Failed) {
return SDL_SetError("We failed");
}


Fixes Bugzilla #1778.
aschiffler@6711
     1
/*
aschiffler@6711
     2
  Simple DirectMedia Layer
slouken@6885
     3
  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
aschiffler@6711
     4
aschiffler@6711
     5
  This software is provided 'as-is', without any express or implied
aschiffler@6711
     6
  warranty.  In no event will the authors be held liable for any damages
aschiffler@6711
     7
  arising from the use of this software.
aschiffler@6711
     8
aschiffler@6711
     9
  Permission is granted to anyone to use this software for any purpose,
aschiffler@6711
    10
  including commercial applications, and to alter it and redistribute it
aschiffler@6711
    11
  freely, subject to the following restrictions:
aschiffler@6711
    12
aschiffler@6711
    13
  1. The origin of this software must not be misrepresented; you must not
aschiffler@6711
    14
     claim that you wrote the original software. If you use this software
aschiffler@6711
    15
     in a product, an acknowledgment in the product documentation would be
aschiffler@6711
    16
     appreciated but is not required.
aschiffler@6711
    17
  2. Altered source versions must be plainly marked as such, and must not be
aschiffler@6711
    18
     misrepresented as being the original software.
aschiffler@6711
    19
  3. This notice may not be removed or altered from any source distribution.
aschiffler@6711
    20
*/
aschiffler@6711
    21
aschiffler@6711
    22
/* 
aschiffler@6711
    23
aschiffler@6711
    24
  Data generators for fuzzing test data in a reproducible way.
aschiffler@6711
    25
 
aschiffler@6711
    26
*/
aschiffler@6711
    27
aschiffler@6711
    28
#include "SDL_config.h"
aschiffler@6711
    29
slouken@6789
    30
/* Visual Studio 2008 doesn't have stdint.h */
slouken@6789
    31
#if defined(_MSC_VER) && _MSC_VER <= 1500
slouken@6789
    32
#define UINT8_MAX   ~(Uint8)0
slouken@6789
    33
#define UINT16_MAX  ~(Uint16)0
slouken@6789
    34
#define UINT32_MAX  ~(Uint32)0
slouken@6789
    35
#define UINT64_MAX  ~(Uint64)0
slouken@6789
    36
#else
aschiffler@6711
    37
#include <stdint.h>
slouken@6789
    38
#endif
aschiffler@6711
    39
#include <stdio.h>
aschiffler@6711
    40
#include <stdlib.h>
aschiffler@6711
    41
#include <limits.h>
aschiffler@6711
    42
#include <float.h>
aschiffler@6711
    43
aschiffler@6711
    44
#include "SDL_test.h"
aschiffler@6711
    45
aschiffler@6711
    46
/** 
aschiffler@6872
    47
 * Counter for fuzzer invocations
aschiffler@6711
    48
 */
aschiffler@6757
    49
static int fuzzerInvocationCounter = 0;
aschiffler@6711
    50
aschiffler@6711
    51
/**
aschiffler@6711
    52
 * Context for shared random number generator
aschiffler@6711
    53
 */
aschiffler@6711
    54
static SDLTest_RandomContext rndContext;
aschiffler@6711
    55
aschiffler@6711
    56
/*
aschiffler@6711
    57
 * Note: doxygen documentation markup for functions is in the header file.
aschiffler@6711
    58
 */
aschiffler@6711
    59
aschiffler@6711
    60
void
aschiffler@6711
    61
SDLTest_FuzzerInit(Uint64 execKey)
aschiffler@6711
    62
{
aschiffler@6757
    63
	Uint32 a = (execKey >> 32) & 0x00000000FFFFFFFF;
aschiffler@6711
    64
	Uint32 b = execKey & 0x00000000FFFFFFFF;
aschiffler@6757
    65
	SDL_memset((void *)&rndContext, 0, sizeof(SDLTest_RandomContext));
aschiffler@6711
    66
	SDLTest_RandomInit(&rndContext, a, b);
aschiffler@6757
    67
	fuzzerInvocationCounter = 0;
aschiffler@6711
    68
}
aschiffler@6711
    69
aschiffler@6711
    70
int
aschiffler@6756
    71
SDLTest_GetFuzzerInvocationCount()
aschiffler@6711
    72
{
aschiffler@6711
    73
	return fuzzerInvocationCounter;
aschiffler@6711
    74
}
aschiffler@6711
    75
aschiffler@6711
    76
Uint8
aschiffler@6711
    77
SDLTest_RandomUint8()
aschiffler@6711
    78
{
aschiffler@6711
    79
	fuzzerInvocationCounter++;
aschiffler@6711
    80
aschiffler@6711
    81
	return (Uint8) SDLTest_RandomInt(&rndContext) & 0x000000FF;
aschiffler@6711
    82
}
aschiffler@6711
    83
aschiffler@6711
    84
Sint8
aschiffler@6711
    85
SDLTest_RandomSint8()
aschiffler@6711
    86
{
aschiffler@6711
    87
	fuzzerInvocationCounter++;
aschiffler@6711
    88
aschiffler@6711
    89
	return (Sint8) SDLTest_RandomInt(&rndContext) & 0x000000FF;
aschiffler@6711
    90
}
aschiffler@6711
    91
aschiffler@6711
    92
Uint16
aschiffler@6711
    93
SDLTest_RandomUint16()
aschiffler@6711
    94
{
aschiffler@6711
    95
	fuzzerInvocationCounter++;
aschiffler@6711
    96
aschiffler@6711
    97
	return (Uint16) SDLTest_RandomInt(&rndContext) & 0x0000FFFF;
aschiffler@6711
    98
}
aschiffler@6711
    99
aschiffler@6711
   100
Sint16
aschiffler@6711
   101
SDLTest_RandomSint16()
aschiffler@6711
   102
{
aschiffler@6711
   103
	fuzzerInvocationCounter++;
aschiffler@6711
   104
aschiffler@6711
   105
	return (Sint16) SDLTest_RandomInt(&rndContext) & 0x0000FFFF;
aschiffler@6711
   106
}
aschiffler@6711
   107
aschiffler@6711
   108
Sint32
aschiffler@6711
   109
SDLTest_RandomSint32()
aschiffler@6711
   110
{
aschiffler@6711
   111
	fuzzerInvocationCounter++;
aschiffler@6711
   112
aschiffler@6711
   113
	return (Sint32) SDLTest_RandomInt(&rndContext);
aschiffler@6711
   114
}
aschiffler@6711
   115
aschiffler@6711
   116
Uint32
aschiffler@6711
   117
SDLTest_RandomUint32()
aschiffler@6711
   118
{
aschiffler@6711
   119
	fuzzerInvocationCounter++;
aschiffler@6711
   120
aschiffler@6711
   121
	return (Uint32) SDLTest_RandomInt(&rndContext);
aschiffler@6711
   122
}
aschiffler@6711
   123
aschiffler@6711
   124
Uint64
aschiffler@6711
   125
SDLTest_RandomUint64()
aschiffler@6711
   126
{
aschiffler@6763
   127
	Uint64 value = 0;
aschiffler@6763
   128
	Uint32 *vp = (void *)&value;
aschiffler@6711
   129
aschiffler@6711
   130
	fuzzerInvocationCounter++;
aschiffler@6711
   131
aschiffler@6711
   132
	vp[0] = SDLTest_RandomSint32();
aschiffler@6711
   133
	vp[1] = SDLTest_RandomSint32();
aschiffler@6711
   134
aschiffler@6711
   135
	return value;
aschiffler@6711
   136
}
aschiffler@6711
   137
aschiffler@6711
   138
Sint64
aschiffler@6711
   139
SDLTest_RandomSint64()
aschiffler@6711
   140
{
aschiffler@6763
   141
	Uint64 value = 0;
aschiffler@6763
   142
	Uint32 *vp = (void *)&value;
aschiffler@6711
   143
aschiffler@6711
   144
	fuzzerInvocationCounter++;
aschiffler@6711
   145
aschiffler@6711
   146
	vp[0] = SDLTest_RandomSint32();
aschiffler@6711
   147
	vp[1] = SDLTest_RandomSint32();
aschiffler@6711
   148
aschiffler@6711
   149
	return value;
aschiffler@6711
   150
}
aschiffler@6711
   151
aschiffler@6711
   152
aschiffler@6711
   153
aschiffler@6711
   154
Sint32
aschiffler@6711
   155
SDLTest_RandomIntegerInRange(Sint32 pMin, Sint32 pMax)
aschiffler@6711
   156
{
aschiffler@6711
   157
	Sint64 min = pMin;
aschiffler@6711
   158
	Sint64 max = pMax;
aschiffler@6711
   159
	Sint64 temp;
aschiffler@6711
   160
	Sint64 number;
aschiffler@6711
   161
aschiffler@6711
   162
	if(pMin > pMax) {
aschiffler@6711
   163
		temp = min;
aschiffler@6711
   164
		min = max;
aschiffler@6711
   165
		max = temp;
aschiffler@6711
   166
	} else if(pMin == pMax) {
aschiffler@6711
   167
		return (Sint32)min;
aschiffler@6711
   168
	}
aschiffler@6711
   169
aschiffler@6872
   170
	number = SDLTest_RandomUint32(); 
aschiffler@6872
   171
	/* invocation count increment in preceeding call */
aschiffler@6711
   172
aschiffler@6711
   173
	return (Sint32)((number % ((max + 1) - min)) + min);
aschiffler@6711
   174
}
aschiffler@6711
   175
aschiffler@6711
   176
/*!
aschiffler@6872
   177
 * Generates a unsigned boundary value between the given boundaries.
aschiffler@6711
   178
 * Boundary values are inclusive. See the examples below.
aschiffler@6711
   179
 * If boundary2 < boundary1, the values are swapped.
aschiffler@6711
   180
 * If boundary1 == boundary2, value of boundary1 will be returned
aschiffler@6711
   181
 *
aschiffler@6711
   182
 * Generating boundary values for Uint8:
aschiffler@6872
   183
 * BoundaryValues(UINT8_MAX, 10, 20, True) -> [10,11,19,20]
aschiffler@6872
   184
 * BoundaryValues(UINT8_MAX, 10, 20, False) -> [9,21]
aschiffler@6872
   185
 * BoundaryValues(UINT8_MAX, 0, 15, True) -> [0, 1, 14, 15]
aschiffler@6872
   186
 * BoundaryValues(UINT8_MAX, 0, 15, False) -> [16]
aschiffler@6872
   187
 * BoundaryValues(UINT8_MAX, 0, 0xFF, False) -> [0], error set
aschiffler@6711
   188
 *
aschiffler@6711
   189
 * Generator works the same for other types of unsigned integers.
aschiffler@6711
   190
 *
aschiffler@6711
   191
 * \param maxValue The biggest value that is acceptable for this data type.
aschiffler@6711
   192
 * 					For instance, for Uint8 -> 255, Uint16 -> 65536 etc.
aschiffler@6872
   193
 * \param boundary1 defines lower boundary
aschiffler@6872
   194
 * \param boundary2 defines upper boundary
aschiffler@6711
   195
 * \param validDomain Generate only for valid domain (for the data type)
aschiffler@6711
   196
 *
aschiffler@6872
   197
 * \returns Returns a random boundary value for the domain or 0 in case of error
aschiffler@6711
   198
 */
aschiffler@6872
   199
Uint64
aschiffler@6872
   200
SDLTest_GenerateUnsignedBoundaryValues(const Uint64 maxValue, Uint64 boundary1, Uint64 boundary2, SDL_bool validDomain)
aschiffler@6711
   201
{
aschiffler@6872
   202
        Uint64 b1, b2;
aschiffler@6872
   203
	Uint64 delta;
aschiffler@6711
   204
	Uint64 tempBuf[4];
aschiffler@6872
   205
	Uint8 index;
aschiffler@6872
   206
	
aschiffler@6872
   207
        /* Maybe swap */
aschiffler@6872
   208
	if (boundary1 > boundary2) {
aschiffler@6872
   209
		b1 = boundary2;
aschiffler@6872
   210
		b2 = boundary1;
aschiffler@6872
   211
	} else {
aschiffler@6872
   212
		b1 = boundary1;
aschiffler@6872
   213
		b2 = boundary2;
aschiffler@6872
   214
        }
aschiffler@6711
   215
aschiffler@6711
   216
	index = 0;
aschiffler@6872
   217
	if (validDomain == SDL_TRUE) {
aschiffler@6872
   218
	        if (b1 == b2) {
aschiffler@6872
   219
	            return b1;
aschiffler@6872
   220
	        }
aschiffler@6872
   221
	        
aschiffler@6872
   222
	        /* Generate up to 4 values within bounds */
aschiffler@6872
   223
	        delta = b2 - b1;
aschiffler@6872
   224
	        if (delta < 4) {
aschiffler@6872
   225
	            do {
aschiffler@6872
   226
		        tempBuf[index] = b1 + index;
aschiffler@6872
   227
		        index++;
aschiffler@6872
   228
                    } while (index < delta);
aschiffler@6872
   229
	        } else {
aschiffler@6872
   230
		  tempBuf[index] = b1;
aschiffler@6872
   231
		  index++;
aschiffler@6872
   232
		  tempBuf[index] = b1 + 1;
aschiffler@6872
   233
		  index++;
aschiffler@6872
   234
		  tempBuf[index] = b2 - 1;
aschiffler@6872
   235
		  index++;
aschiffler@6872
   236
		  tempBuf[index] = b2;
aschiffler@6872
   237
		  index++;
aschiffler@6872
   238
	        }
aschiffler@6872
   239
        } else {                
aschiffler@6872
   240
	        /* Generate up to 2 values outside of bounds */
aschiffler@6872
   241
		if (b1 > 0) {
aschiffler@6872
   242
			tempBuf[index] = b1 - 1;
aschiffler@6872
   243
			index++;
aschiffler@6711
   244
		}
aschiffler@6711
   245
aschiffler@6872
   246
		if (b2 < maxValue) {
aschiffler@6872
   247
			tempBuf[index] = b2 + 1;
aschiffler@6872
   248
			index++;
aschiffler@6711
   249
		}
aschiffler@6711
   250
	}
aschiffler@6711
   251
aschiffler@6872
   252
	if (index == 0) {
aschiffler@6872
   253
		/* There are no valid boundaries */
icculus@7037
   254
		SDL_Unsupported();
aschiffler@6711
   255
		return 0;
aschiffler@6711
   256
	}
aschiffler@6711
   257
aschiffler@6872
   258
	return tempBuf[SDLTest_RandomUint8() % index];
aschiffler@6872
   259
}
aschiffler@6711
   260
aschiffler@6711
   261
aschiffler@6711
   262
Uint8
aschiffler@6711
   263
SDLTest_RandomUint8BoundaryValue(Uint8 boundary1, Uint8 boundary2, SDL_bool validDomain)
aschiffler@6711
   264
{
aschiffler@6872
   265
	/* max value for Uint8 */
aschiffler@6872
   266
	const Uint64 maxValue = UCHAR_MAX;
aschiffler@6872
   267
	return (Uint8)SDLTest_GenerateUnsignedBoundaryValues(maxValue,
aschiffler@6711
   268
				(Uint64) boundary1, (Uint64) boundary2,
aschiffler@6872
   269
				validDomain);
aschiffler@6711
   270
}
aschiffler@6711
   271
aschiffler@6711
   272
Uint16
aschiffler@6711
   273
SDLTest_RandomUint16BoundaryValue(Uint16 boundary1, Uint16 boundary2, SDL_bool validDomain)
aschiffler@6711
   274
{
aschiffler@6872
   275
	/* max value for Uint16 */
aschiffler@6872
   276
	const Uint64 maxValue = USHRT_MAX;
aschiffler@6872
   277
	return (Uint16)SDLTest_GenerateUnsignedBoundaryValues(maxValue,
aschiffler@6711
   278
				(Uint64) boundary1, (Uint64) boundary2,
aschiffler@6872
   279
				validDomain);
aschiffler@6711
   280
}
aschiffler@6711
   281
aschiffler@6711
   282
Uint32
aschiffler@6711
   283
SDLTest_RandomUint32BoundaryValue(Uint32 boundary1, Uint32 boundary2, SDL_bool validDomain)
aschiffler@6711
   284
{
aschiffler@6872
   285
	/* max value for Uint32 */
aschiffler@6872
   286
	const Uint64 maxValue = ULONG_MAX;
aschiffler@6872
   287
	return (Uint32)SDLTest_GenerateUnsignedBoundaryValues(maxValue,
aschiffler@6711
   288
				(Uint64) boundary1, (Uint64) boundary2,
aschiffler@6872
   289
				validDomain);
aschiffler@6711
   290
}
aschiffler@6711
   291
aschiffler@6711
   292
Uint64
aschiffler@6711
   293
SDLTest_RandomUint64BoundaryValue(Uint64 boundary1, Uint64 boundary2, SDL_bool validDomain)
aschiffler@6711
   294
{
aschiffler@6872
   295
	/* max value for Uint64 */
aschiffler@6872
   296
	const Uint64 maxValue = ULLONG_MAX;
aschiffler@6872
   297
	return SDLTest_GenerateUnsignedBoundaryValues(maxValue,
aschiffler@6711
   298
				(Uint64) boundary1, (Uint64) boundary2,
aschiffler@6872
   299
				validDomain);
aschiffler@6711
   300
}
aschiffler@6711
   301
aschiffler@6711
   302
/*!
aschiffler@6872
   303
 * Generates a signed boundary value between the given boundaries.
aschiffler@6711
   304
 * Boundary values are inclusive. See the examples below.
aschiffler@6711
   305
 * If boundary2 < boundary1, the values are swapped.
aschiffler@6711
   306
 * If boundary1 == boundary2, value of boundary1 will be returned
aschiffler@6711
   307
 *
aschiffler@6711
   308
 * Generating boundary values for Sint8:
aschiffler@6872
   309
 * SignedBoundaryValues(SCHAR_MIN, SCHAR_MAX, -10, 20, True) -> [-10,-9,19,20]
aschiffler@6872
   310
 * SignedBoundaryValues(SCHAR_MIN, SCHAR_MAX, -10, 20, False) -> [-11,21]
aschiffler@6872
   311
 * SignedBoundaryValues(SCHAR_MIN, SCHAR_MAX, -30, -15, True) -> [-30, -29, -16, -15]
aschiffler@6872
   312
 * SignedBoundaryValues(SCHAR_MIN, SCHAR_MAX, -127, 15, False) -> [16]
aschiffler@6872
   313
 * SignedBoundaryValues(SCHAR_MIN, SCHAR_MAX, -127, 127, False) -> [0], error set
aschiffler@6711
   314
 *
aschiffler@6711
   315
 * Generator works the same for other types of signed integers.
aschiffler@6711
   316
 *
aschiffler@6872
   317
 * \param minValue The smallest value that is acceptable for this data type.
aschiffler@6872
   318
 * 					For instance, for Uint8 -> -127, etc.
aschiffler@6711
   319
 * \param maxValue The biggest value that is acceptable for this data type.
aschiffler@6872
   320
 * 					For instance, for Uint8 -> 127, etc.
aschiffler@6872
   321
 * \param boundary1 defines lower boundary
aschiffler@6872
   322
 * \param boundary2 defines upper boundary
aschiffler@6711
   323
 * \param validDomain Generate only for valid domain (for the data type)
aschiffler@6711
   324
 *
aschiffler@6872
   325
 * \returns Returns a random boundary value for the domain or 0 in case of error
aschiffler@6711
   326
 */
aschiffler@6872
   327
Sint64
aschiffler@6872
   328
SDLTest_GenerateSignedBoundaryValues(const Sint64 minValue, const Sint64 maxValue, Sint64 boundary1, Sint64 boundary2, SDL_bool validDomain)
aschiffler@6711
   329
{
aschiffler@6872
   330
        Sint64 b1, b2;
aschiffler@6872
   331
	Sint64 delta;
aschiffler@6711
   332
	Sint64 tempBuf[4];
aschiffler@6872
   333
	Uint8 index;
aschiffler@6872
   334
	
aschiffler@6872
   335
        /* Maybe swap */
aschiffler@6872
   336
	if (boundary1 > boundary2) {
aschiffler@6872
   337
		b1 = boundary2;
aschiffler@6872
   338
		b2 = boundary1;
aschiffler@6872
   339
	} else {
aschiffler@6872
   340
		b1 = boundary1;
aschiffler@6872
   341
		b2 = boundary2;
aschiffler@6872
   342
        }
aschiffler@6711
   343
aschiffler@6711
   344
	index = 0;
aschiffler@6872
   345
	if (validDomain == SDL_TRUE) {
aschiffler@6872
   346
	        if (b1 == b2) {
aschiffler@6872
   347
	            return b1;
aschiffler@6872
   348
	        }
aschiffler@6872
   349
	        
aschiffler@6872
   350
	        /* Generate up to 4 values within bounds */
aschiffler@6872
   351
	        delta = b2 - b1;
aschiffler@6872
   352
	        if (delta < 4) {
aschiffler@6872
   353
	            do {
aschiffler@6872
   354
		        tempBuf[index] = b1 + index;
aschiffler@6872
   355
		        index++;
aschiffler@6872
   356
                    } while (index < delta);
aschiffler@6872
   357
	        } else {
aschiffler@6872
   358
		  tempBuf[index] = b1;
aschiffler@6872
   359
		  index++;
aschiffler@6872
   360
		  tempBuf[index] = b1 + 1;
aschiffler@6872
   361
		  index++;
aschiffler@6872
   362
		  tempBuf[index] = b2 - 1;
aschiffler@6872
   363
		  index++;
aschiffler@6872
   364
		  tempBuf[index] = b2;
aschiffler@6872
   365
		  index++;
aschiffler@6872
   366
	        }
aschiffler@6872
   367
        } else {                
aschiffler@6872
   368
	        /* Generate up to 2 values outside of bounds */
aschiffler@6872
   369
		if (b1 > minValue) {
aschiffler@6872
   370
			tempBuf[index] = b1 - 1;
aschiffler@6872
   371
			index++;
aschiffler@6711
   372
		}
aschiffler@6711
   373
aschiffler@6872
   374
		if (b2 < maxValue) {
aschiffler@6872
   375
			tempBuf[index] = b2 + 1;
aschiffler@6872
   376
			index++;
aschiffler@6711
   377
		}
aschiffler@6711
   378
	}
aschiffler@6711
   379
aschiffler@6872
   380
	if (index == 0) {
aschiffler@6872
   381
		/* There are no valid boundaries */
icculus@7037
   382
		SDL_Unsupported();
aschiffler@6872
   383
		return minValue;
aschiffler@6711
   384
	}
aschiffler@6711
   385
aschiffler@6872
   386
	return tempBuf[SDLTest_RandomUint8() % index];
aschiffler@6872
   387
}
aschiffler@6711
   388
aschiffler@6711
   389
aschiffler@6711
   390
Sint8
aschiffler@6711
   391
SDLTest_RandomSint8BoundaryValue(Sint8 boundary1, Sint8 boundary2, SDL_bool validDomain)
aschiffler@6711
   392
{
aschiffler@6872
   393
	/* min & max values for Sint8 */
aschiffler@6872
   394
	const Sint64 maxValue = SCHAR_MAX;
aschiffler@6872
   395
	const Sint64 minValue = SCHAR_MIN;
aschiffler@6872
   396
	return (Sint8)SDLTest_GenerateSignedBoundaryValues(minValue, maxValue,
aschiffler@6711
   397
				(Sint64) boundary1, (Sint64) boundary2,
aschiffler@6872
   398
				validDomain);
aschiffler@6711
   399
}
aschiffler@6711
   400
aschiffler@6711
   401
Sint16
aschiffler@6711
   402
SDLTest_RandomSint16BoundaryValue(Sint16 boundary1, Sint16 boundary2, SDL_bool validDomain)
aschiffler@6711
   403
{
aschiffler@6872
   404
	/* min & max values for Sint16 */
aschiffler@6711
   405
	const Sint64 maxValue = SHRT_MAX;
aschiffler@6711
   406
	const Sint64 minValue = SHRT_MIN;
aschiffler@6872
   407
	return (Sint16)SDLTest_GenerateSignedBoundaryValues(minValue, maxValue,
aschiffler@6872
   408
				(Sint64) boundary1, (Sint64) boundary2,
aschiffler@6872
   409
				validDomain);
aschiffler@6711
   410
}
aschiffler@6711
   411
aschiffler@6711
   412
Sint32
aschiffler@6711
   413
SDLTest_RandomSint32BoundaryValue(Sint32 boundary1, Sint32 boundary2, SDL_bool validDomain)
aschiffler@6711
   414
{
aschiffler@6872
   415
	/* min & max values for Sint32 */
aschiffler@6872
   416
	const Sint64 maxValue = LONG_MAX;
aschiffler@6872
   417
	const Sint64 minValue = LONG_MIN;
aschiffler@6872
   418
	return (Sint32)SDLTest_GenerateSignedBoundaryValues(minValue, maxValue,
aschiffler@6711
   419
				(Sint64) boundary1, (Sint64) boundary2,
aschiffler@6872
   420
				validDomain);
aschiffler@6711
   421
}
aschiffler@6711
   422
aschiffler@6711
   423
Sint64
aschiffler@6711
   424
SDLTest_RandomSint64BoundaryValue(Sint64 boundary1, Sint64 boundary2, SDL_bool validDomain)
aschiffler@6711
   425
{
aschiffler@6872
   426
	/* min & max values for Sint64 */
aschiffler@6711
   427
	const Sint64 maxValue = LLONG_MAX;
aschiffler@6711
   428
	const Sint64 minValue = LLONG_MIN;
aschiffler@6872
   429
	return SDLTest_GenerateSignedBoundaryValues(minValue, maxValue,
aschiffler@6872
   430
				boundary1, boundary2,
aschiffler@6872
   431
				validDomain);
aschiffler@6711
   432
}
aschiffler@6711
   433
aschiffler@6711
   434
float
aschiffler@6711
   435
SDLTest_RandomUnitFloat()
aschiffler@6711
   436
{
aschiffler@6711
   437
	return (float) SDLTest_RandomUint32() / UINT_MAX;
aschiffler@6711
   438
}
aschiffler@6711
   439
aschiffler@6711
   440
float
aschiffler@6711
   441
SDLTest_RandomFloat()
aschiffler@6711
   442
{
aschiffler@6839
   443
        return (float) (SDLTest_RandomUnitDouble() * (double)2.0 * (double)FLT_MAX - (double)(FLT_MAX));
aschiffler@6711
   444
}
aschiffler@6711
   445
aschiffler@6711
   446
double
aschiffler@6711
   447
SDLTest_RandomUnitDouble()
aschiffler@6711
   448
{
aschiffler@6711
   449
	return (double) (SDLTest_RandomUint64() >> 11) * (1.0/9007199254740992.0);
aschiffler@6711
   450
}
aschiffler@6711
   451
aschiffler@6711
   452
double
aschiffler@6711
   453
SDLTest_RandomDouble()
aschiffler@6711
   454
{
aschiffler@6711
   455
	double r = 0.0;
aschiffler@6711
   456
	double s = 1.0;
aschiffler@6711
   457
	do {
aschiffler@6711
   458
	  s /= UINT_MAX + 1.0;
aschiffler@6711
   459
	  r += (double)SDLTest_RandomInt(&rndContext) * s;
aschiffler@6711
   460
	} while (s > DBL_EPSILON);
aschiffler@6711
   461
	  
aschiffler@6711
   462
	fuzzerInvocationCounter++;
aschiffler@6711
   463
	
aschiffler@6711
   464
	return r;
aschiffler@6711
   465
}
aschiffler@6711
   466
aschiffler@6711
   467
aschiffler@6711
   468
char *
aschiffler@6711
   469
SDLTest_RandomAsciiString()
aschiffler@6711
   470
{
aschiffler@6711
   471
	return SDLTest_RandomAsciiStringWithMaximumLength(255);
aschiffler@6711
   472
}
aschiffler@6711
   473
aschiffler@6711
   474
char *
aschiffler@6811
   475
SDLTest_RandomAsciiStringWithMaximumLength(int maxLength)
aschiffler@6711
   476
{
aschiffler@6711
   477
	int size;
aschiffler@6811
   478
aschiffler@6811
   479
	if(maxLength < 1) {
aschiffler@6811
   480
                SDL_InvalidParamError("maxLength");
aschiffler@6811
   481
		return NULL;
aschiffler@6811
   482
	}
aschiffler@6811
   483
aschiffler@6811
   484
	size = (SDLTest_RandomUint32() % (maxLength + 1));
aschiffler@6811
   485
	
aschiffler@6811
   486
	return SDLTest_RandomAsciiStringOfSize(size);	
aschiffler@6811
   487
}
aschiffler@6811
   488
aschiffler@6811
   489
char *
aschiffler@6811
   490
SDLTest_RandomAsciiStringOfSize(int size)
aschiffler@6811
   491
{
aschiffler@6711
   492
	char *string;
aschiffler@6711
   493
	int counter;
aschiffler@6711
   494
aschiffler@6711
   495
aschiffler@6811
   496
	if(size < 1) {
aschiffler@6811
   497
                SDL_InvalidParamError("size");
aschiffler@6711
   498
		return NULL;
aschiffler@6711
   499
	}
aschiffler@6711
   500
aschiffler@6811
   501
	string = (char *)SDL_malloc((size + 1) * sizeof(char));
aschiffler@6711
   502
	if (string==NULL) {
aschiffler@6711
   503
	  return NULL;
aschiffler@6711
   504
        }
aschiffler@6711
   505
aschiffler@6711
   506
	for(counter = 0; counter < size; ++counter) {
aschiffler@6760
   507
		string[counter] = (char)SDLTest_RandomIntegerInRange(32, 126);
aschiffler@6711
   508
	}
aschiffler@6711
   509
aschiffler@6711
   510
	string[counter] = '\0';
aschiffler@6711
   511
aschiffler@6811
   512
	fuzzerInvocationCounter++;
aschiffler@6811
   513
aschiffler@6711
   514
	return string;
aschiffler@6711
   515
}