src/test/SDL_test_fuzzer.c
author Andreas Schiffler <aschiffler@ferzkopp.net>
Fri, 08 Feb 2013 07:14:50 -0800
changeset 6839 2494f667555c
parent 6811 60d95fcfaf3c
child 6872 2f4c95464651
permissions -rw-r--r--
Add SDL_test test suite; add fuzzer test cases; fix fuzzer bug; fix compiler warnings
aschiffler@6711
     1
/*
aschiffler@6711
     2
  Simple DirectMedia Layer
aschiffler@6711
     3
  Copyright (C) 1997-2012 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@6711
    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@6711
   170
	number = SDLTest_RandomUint32(); // invocation count increment in there
aschiffler@6711
   171
aschiffler@6711
   172
	return (Sint32)((number % ((max + 1) - min)) + min);
aschiffler@6711
   173
}
aschiffler@6711
   174
aschiffler@6711
   175
/*!
aschiffler@6711
   176
 * Generates boundary values between the given boundaries.
aschiffler@6711
   177
 * Boundary values are inclusive. See the examples below.
aschiffler@6711
   178
 * If boundary2 < boundary1, the values are swapped.
aschiffler@6711
   179
 * If boundary1 == boundary2, value of boundary1 will be returned
aschiffler@6711
   180
 *
aschiffler@6711
   181
 * Generating boundary values for Uint8:
aschiffler@6711
   182
 * BoundaryValues(sizeof(Uint8), 10, 20, True) -> [10,11,19,20]
aschiffler@6711
   183
 * BoundaryValues(sizeof(Uint8), 10, 20, False) -> [9,21]
aschiffler@6711
   184
 * BoundaryValues(sizeof(Uint8), 0, 15, True) -> [0, 1, 14, 15]
aschiffler@6711
   185
 * BoundaryValues(sizeof(Uint8), 0, 15, False) -> [16]
aschiffler@6711
   186
 * BoundaryValues(sizeof(Uint8), 0, 255, False) -> NULL
aschiffler@6711
   187
 *
aschiffler@6711
   188
 * Generator works the same for other types of unsigned integers.
aschiffler@6711
   189
 *
aschiffler@6711
   190
 * Note: outBuffer will be allocated and needs to be freed later.
aschiffler@6711
   191
 * If outbuffer != NULL, it'll be freed.
aschiffler@6711
   192
 *
aschiffler@6711
   193
 * \param maxValue The biggest value that is acceptable for this data type.
aschiffler@6711
   194
 * 					For instance, for Uint8 -> 255, Uint16 -> 65536 etc.
aschiffler@6711
   195
 * \param pBoundary1 defines lower boundary
aschiffler@6711
   196
 * \param pBoundary2 defines upper boundary
aschiffler@6711
   197
 * \param validDomain Generate only for valid domain (for the data type)
aschiffler@6711
   198
 *
aschiffler@6711
   199
 * \param outBuffer The generated boundary values are put here
aschiffler@6711
   200
 *
aschiffler@6711
   201
 * \returns Returns the number of elements in outBuffer or -1 in case of error
aschiffler@6711
   202
 */
aschiffler@6711
   203
Uint32
aschiffler@6711
   204
SDLTest_GenerateUnsignedBoundaryValues(const Uint64 maxValue,
aschiffler@6711
   205
					Uint64 pBoundary1, Uint64 pBoundary2, SDL_bool validDomain,
aschiffler@6711
   206
					Uint64 *outBuffer)
aschiffler@6711
   207
{
aschiffler@6711
   208
	Uint64 boundary1 = pBoundary1, boundary2 = pBoundary2;
aschiffler@6711
   209
	Uint64 temp;
aschiffler@6711
   210
	Uint64 tempBuf[4];
aschiffler@6711
   211
	int index;
aschiffler@6711
   212
aschiffler@6711
   213
	if(outBuffer != NULL) {
aschiffler@6711
   214
		SDL_free(outBuffer);
aschiffler@6711
   215
	}
aschiffler@6711
   216
aschiffler@6711
   217
	if(boundary1 > boundary2) {
aschiffler@6711
   218
		temp = boundary1;
aschiffler@6711
   219
		boundary1 = boundary2;
aschiffler@6711
   220
		boundary2 = temp;
aschiffler@6711
   221
	}
aschiffler@6711
   222
aschiffler@6711
   223
	index = 0;
aschiffler@6711
   224
	if(boundary1 == boundary2) {
aschiffler@6711
   225
		tempBuf[index++] = boundary1;
aschiffler@6711
   226
	}
aschiffler@6711
   227
	else if(validDomain) {
aschiffler@6711
   228
		tempBuf[index++] = boundary1;
aschiffler@6711
   229
aschiffler@6711
   230
		if(boundary1 < UINT64_MAX)
aschiffler@6711
   231
			tempBuf[index++] = boundary1 + 1;
aschiffler@6711
   232
aschiffler@6711
   233
		tempBuf[index++] = boundary2 - 1;
aschiffler@6711
   234
		tempBuf[index++] = boundary2;
aschiffler@6711
   235
	}
aschiffler@6711
   236
	else {
aschiffler@6711
   237
		if(boundary1 > 0) {
aschiffler@6711
   238
			tempBuf[index++] = boundary1 - 1;
aschiffler@6711
   239
		}
aschiffler@6711
   240
aschiffler@6711
   241
		if(boundary2 < maxValue && boundary2 < UINT64_MAX) {
aschiffler@6711
   242
			tempBuf[index++] = boundary2 + 1;
aschiffler@6711
   243
		}
aschiffler@6711
   244
	}
aschiffler@6711
   245
aschiffler@6711
   246
	if(index == 0) {
aschiffler@6711
   247
		// There are no valid boundaries
aschiffler@6711
   248
		return 0;
aschiffler@6711
   249
	}
aschiffler@6711
   250
aschiffler@6711
   251
	// Create the return buffer
aschiffler@6711
   252
	outBuffer = (Uint64 *)SDL_malloc(index * sizeof(Uint64));
aschiffler@6711
   253
	if(outBuffer == NULL) {
aschiffler@6711
   254
		return 0;
aschiffler@6711
   255
	}
aschiffler@6711
   256
aschiffler@6711
   257
	SDL_memcpy(outBuffer, tempBuf, index * sizeof(Uint64));
aschiffler@6711
   258
aschiffler@6711
   259
	return index;
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@6711
   265
	Uint64 *buffer = NULL;
aschiffler@6711
   266
	Uint32 size;
aschiffler@6711
   267
	Uint32 index;
aschiffler@6711
   268
	Uint8 retVal;
aschiffler@6711
   269
aschiffler@6711
   270
	// max value for Uint8
aschiffler@6711
   271
	const Uint64 maxValue = UINT8_MAX;
aschiffler@6711
   272
aschiffler@6711
   273
	size = SDLTest_GenerateUnsignedBoundaryValues(maxValue,
aschiffler@6711
   274
				(Uint64) boundary1, (Uint64) boundary2,
aschiffler@6711
   275
				validDomain, buffer);
aschiffler@6719
   276
	if (buffer == NULL || size == 0) {
aschiffler@6711
   277
		return 0;
aschiffler@6711
   278
	}
aschiffler@6711
   279
aschiffler@6711
   280
	index = SDLTest_RandomSint32() % size;
aschiffler@6711
   281
	retVal = (Uint8)buffer[index];
aschiffler@6711
   282
aschiffler@6711
   283
	SDL_free(buffer);
aschiffler@6711
   284
aschiffler@6711
   285
	fuzzerInvocationCounter++;
aschiffler@6711
   286
aschiffler@6711
   287
	return retVal;
aschiffler@6711
   288
}
aschiffler@6711
   289
aschiffler@6711
   290
Uint16
aschiffler@6711
   291
SDLTest_RandomUint16BoundaryValue(Uint16 boundary1, Uint16 boundary2, SDL_bool validDomain)
aschiffler@6711
   292
{
aschiffler@6711
   293
	Uint64 *buffer = NULL;
aschiffler@6711
   294
	Uint32 size;
aschiffler@6711
   295
	Uint32 index;
aschiffler@6711
   296
	Uint16 retVal;
aschiffler@6711
   297
aschiffler@6711
   298
	// max value for Uint16
aschiffler@6711
   299
	const Uint64 maxValue = UINT16_MAX;
aschiffler@6711
   300
aschiffler@6711
   301
	size = SDLTest_GenerateUnsignedBoundaryValues(maxValue,
aschiffler@6711
   302
				(Uint64) boundary1, (Uint64) boundary2,
aschiffler@6711
   303
				validDomain, buffer);
aschiffler@6719
   304
	if (buffer == NULL || size == 0) {
aschiffler@6711
   305
		return 0;
aschiffler@6711
   306
	}
aschiffler@6711
   307
aschiffler@6711
   308
	index = SDLTest_RandomSint32() % size;
aschiffler@6711
   309
	retVal = (Uint16) buffer[index];
aschiffler@6711
   310
aschiffler@6711
   311
	SDL_free(buffer);
aschiffler@6711
   312
aschiffler@6711
   313
	fuzzerInvocationCounter++;
aschiffler@6711
   314
aschiffler@6711
   315
	return retVal;
aschiffler@6711
   316
}
aschiffler@6711
   317
aschiffler@6711
   318
Uint32
aschiffler@6711
   319
SDLTest_RandomUint32BoundaryValue(Uint32 boundary1, Uint32 boundary2, SDL_bool validDomain)
aschiffler@6711
   320
{
aschiffler@6711
   321
	Uint64 *buffer = NULL;
aschiffler@6711
   322
	Uint32 size;
aschiffler@6711
   323
	Uint32 index;
aschiffler@6711
   324
	Uint32 retVal;
aschiffler@6711
   325
aschiffler@6711
   326
	// max value for Uint32
aschiffler@6711
   327
	const Uint64 maxValue = UINT32_MAX;
aschiffler@6711
   328
aschiffler@6711
   329
	size = SDLTest_GenerateUnsignedBoundaryValues(maxValue,
aschiffler@6711
   330
				(Uint64) boundary1, (Uint64) boundary2,
aschiffler@6711
   331
				validDomain, buffer);
aschiffler@6719
   332
	if (buffer == NULL || size == 0) {
aschiffler@6711
   333
		return 0;
aschiffler@6711
   334
	}
aschiffler@6711
   335
aschiffler@6711
   336
	index = SDLTest_RandomSint32() % size;
aschiffler@6711
   337
	retVal = (Uint32) buffer[index];
aschiffler@6711
   338
aschiffler@6711
   339
	SDL_free(buffer);
aschiffler@6711
   340
aschiffler@6711
   341
	fuzzerInvocationCounter++;
aschiffler@6711
   342
aschiffler@6711
   343
	return retVal;
aschiffler@6711
   344
}
aschiffler@6711
   345
aschiffler@6711
   346
Uint64
aschiffler@6711
   347
SDLTest_RandomUint64BoundaryValue(Uint64 boundary1, Uint64 boundary2, SDL_bool validDomain)
aschiffler@6711
   348
{
aschiffler@6711
   349
	Uint64 *buffer = NULL;
aschiffler@6711
   350
	Uint32 size;
aschiffler@6711
   351
	Uint32 index;
aschiffler@6711
   352
	Uint64 retVal;
aschiffler@6711
   353
aschiffler@6711
   354
	// max value for Uint64
aschiffler@6711
   355
	const Uint64 maxValue = UINT64_MAX;
aschiffler@6711
   356
aschiffler@6711
   357
	size = SDLTest_GenerateUnsignedBoundaryValues(maxValue,
aschiffler@6711
   358
				(Uint64) boundary1, (Uint64) boundary2,
aschiffler@6711
   359
				validDomain, buffer);
aschiffler@6719
   360
	if (buffer == NULL || size == 0) {
aschiffler@6711
   361
		return 0;
aschiffler@6711
   362
	}
aschiffler@6711
   363
aschiffler@6711
   364
	index = SDLTest_RandomSint32() % size;
aschiffler@6711
   365
	retVal = (Uint64) buffer[index];
aschiffler@6711
   366
aschiffler@6711
   367
	SDL_free(buffer);
aschiffler@6711
   368
aschiffler@6711
   369
	fuzzerInvocationCounter++;
aschiffler@6711
   370
aschiffler@6711
   371
	return retVal;
aschiffler@6711
   372
}
aschiffler@6711
   373
aschiffler@6711
   374
/*!
aschiffler@6711
   375
 * Generates boundary values between the given boundaries.
aschiffler@6711
   376
 * Boundary values are inclusive. See the examples below.
aschiffler@6711
   377
 * If boundary2 < boundary1, the values are swapped.
aschiffler@6711
   378
 * If boundary1 == boundary2, value of boundary1 will be returned
aschiffler@6711
   379
 *
aschiffler@6711
   380
 * Generating boundary values for Sint8:
aschiffler@6711
   381
 * SignedBoundaryValues(sizeof(Sint8), -10, 20, True) -> [-11,-10,19,20]
aschiffler@6711
   382
 * SignedBoundaryValues(sizeof(Sint8), -10, 20, False) -> [-11,21]
aschiffler@6711
   383
 * SignedBoundaryValues(sizeof(Sint8), -30, -15, True) -> [-30, -29, -16, -15]
aschiffler@6711
   384
 * SignedBoundaryValues(sizeof(Sint8), -128, 15, False) -> [16]
aschiffler@6711
   385
 * SignedBoundaryValues(sizeof(Sint8), -128, 127, False) -> NULL
aschiffler@6711
   386
 *
aschiffler@6711
   387
 * Generator works the same for other types of signed integers.
aschiffler@6711
   388
 *
aschiffler@6711
   389
 * Note: outBuffer will be allocated and needs to be freed later.
aschiffler@6711
   390
 * If outbuffer != NULL, it'll be freed.
aschiffler@6711
   391
 *
aschiffler@6711
   392
 *
aschiffler@6711
   393
 * \param minValue The smallest value  that is acceptable for this data type.
aschiffler@6711
   394
 *					For instance, for Uint8 -> -128, Uint16 -> -32,768 etc.
aschiffler@6711
   395
 * \param maxValue The biggest value that is acceptable for this data type.
aschiffler@6711
   396
 * 					For instance, for Uint8 -> 127, Uint16 -> 32767 etc.
aschiffler@6711
   397
 * \param pBoundary1 defines lower boundary
aschiffler@6711
   398
 * \param pBoundary2 defines upper boundary
aschiffler@6711
   399
 * \param validDomain Generate only for valid domain (for the data type)
aschiffler@6711
   400
 *
aschiffler@6711
   401
 * \param outBuffer The generated boundary values are put here
aschiffler@6711
   402
 *
aschiffler@6711
   403
 * \returns Returns the number of elements in outBuffer or -1 in case of error
aschiffler@6711
   404
 */
aschiffler@6711
   405
Uint32
aschiffler@6711
   406
SDLTest_GenerateSignedBoundaryValues(const Sint64 minValue, const Sint64 maxValue,
aschiffler@6711
   407
					Sint64 pBoundary1, Sint64 pBoundary2, SDL_bool validDomain,
aschiffler@6711
   408
					Sint64 *outBuffer)
aschiffler@6711
   409
{
aschiffler@6711
   410
	int index;
aschiffler@6711
   411
	Sint64 tempBuf[4];
aschiffler@6711
   412
	Sint64 boundary1 = pBoundary1, boundary2 = pBoundary2;
aschiffler@6711
   413
aschiffler@6711
   414
	if(outBuffer != NULL) {
aschiffler@6711
   415
		SDL_free(outBuffer);
aschiffler@6711
   416
	}
aschiffler@6711
   417
aschiffler@6711
   418
	if(boundary1 > boundary2) {
aschiffler@6711
   419
		Sint64 temp = boundary1;
aschiffler@6711
   420
		boundary1 = boundary2;
aschiffler@6711
   421
		boundary2 = temp;
aschiffler@6711
   422
	}
aschiffler@6711
   423
aschiffler@6711
   424
	index = 0;
aschiffler@6711
   425
	if(boundary1 == boundary2) {
aschiffler@6711
   426
		tempBuf[index++] = boundary1;
aschiffler@6711
   427
	}
aschiffler@6711
   428
	else if(validDomain) {
aschiffler@6711
   429
		tempBuf[index++] = boundary1;
aschiffler@6711
   430
aschiffler@6711
   431
		if(boundary1 < LLONG_MAX)
aschiffler@6711
   432
			tempBuf[index++] = boundary1 + 1;
aschiffler@6711
   433
aschiffler@6711
   434
		if(boundary2 > LLONG_MIN)
aschiffler@6711
   435
			tempBuf[index++] = boundary2 - 1;
aschiffler@6711
   436
aschiffler@6711
   437
		tempBuf[index++] = boundary2;
aschiffler@6711
   438
	}
aschiffler@6711
   439
	else {
aschiffler@6711
   440
		if(boundary1 > minValue &&  boundary1 > LLONG_MIN) {
aschiffler@6711
   441
			tempBuf[index++] = boundary1 - 1;
aschiffler@6711
   442
		}
aschiffler@6711
   443
aschiffler@6711
   444
		if(boundary2 < maxValue && boundary2 < UINT64_MAX) {
aschiffler@6711
   445
			tempBuf[index++] = boundary2 + 1;
aschiffler@6711
   446
		}
aschiffler@6711
   447
	}
aschiffler@6711
   448
aschiffler@6711
   449
	if(index == 0) {
aschiffler@6711
   450
		// There are no valid boundaries
aschiffler@6711
   451
		return 0;
aschiffler@6711
   452
	}
aschiffler@6711
   453
aschiffler@6711
   454
	// Create the return buffer
aschiffler@6711
   455
	outBuffer = (Sint64 *)SDL_malloc(index * sizeof(Sint64));
aschiffler@6711
   456
	if(outBuffer == NULL) {
aschiffler@6711
   457
		return 0;
aschiffler@6711
   458
	}
aschiffler@6711
   459
aschiffler@6711
   460
	SDL_memcpy((void *)outBuffer, (void *)tempBuf, index * sizeof(Sint64));
aschiffler@6711
   461
aschiffler@6711
   462
	return (Uint32)index;
aschiffler@6711
   463
}
aschiffler@6711
   464
aschiffler@6711
   465
Sint8
aschiffler@6711
   466
SDLTest_RandomSint8BoundaryValue(Sint8 boundary1, Sint8 boundary2, SDL_bool validDomain)
aschiffler@6711
   467
{
aschiffler@6711
   468
	// min & max values for Sint8
aschiffler@6711
   469
	const Sint64 maxValue = CHAR_MAX;
aschiffler@6711
   470
	const Sint64 minValue = CHAR_MIN;
aschiffler@6711
   471
aschiffler@6711
   472
	Sint64 *buffer = NULL;
aschiffler@6711
   473
	Uint32 size;
aschiffler@6711
   474
	Uint32 index;
aschiffler@6711
   475
	Sint8 retVal;
aschiffler@6711
   476
aschiffler@6711
   477
	size = SDLTest_GenerateSignedBoundaryValues(minValue, maxValue,
aschiffler@6711
   478
				(Sint64) boundary1, (Sint64) boundary2,
aschiffler@6711
   479
				validDomain, buffer);
aschiffler@6719
   480
	if (buffer == NULL || size == 0) {
aschiffler@6711
   481
		return CHAR_MIN;
aschiffler@6711
   482
	}
aschiffler@6711
   483
aschiffler@6711
   484
	index = SDLTest_RandomSint32() % size;
aschiffler@6711
   485
	retVal = (Sint8) buffer[index];
aschiffler@6711
   486
aschiffler@6711
   487
	SDL_free(buffer);
aschiffler@6711
   488
aschiffler@6711
   489
	fuzzerInvocationCounter++;
aschiffler@6711
   490
aschiffler@6711
   491
	return retVal;
aschiffler@6711
   492
}
aschiffler@6711
   493
aschiffler@6711
   494
Sint16
aschiffler@6711
   495
SDLTest_RandomSint16BoundaryValue(Sint16 boundary1, Sint16 boundary2, SDL_bool validDomain)
aschiffler@6711
   496
{
aschiffler@6711
   497
	// min & max values for Sint16
aschiffler@6711
   498
	const Sint64 maxValue = SHRT_MAX;
aschiffler@6711
   499
	const Sint64 minValue = SHRT_MIN;
aschiffler@6711
   500
	Sint64 *buffer = NULL;
aschiffler@6711
   501
	Uint32 size;
aschiffler@6711
   502
	Uint32 index;
aschiffler@6711
   503
	Sint16 retVal;
aschiffler@6711
   504
aschiffler@6711
   505
	size = SDLTest_GenerateSignedBoundaryValues(minValue, maxValue,
aschiffler@6711
   506
					(Sint64) boundary1, (Sint64) boundary2,
aschiffler@6711
   507
					validDomain, buffer);
aschiffler@6719
   508
	if (buffer == NULL || size == 0) {
aschiffler@6711
   509
		return SHRT_MIN;
aschiffler@6711
   510
	}
aschiffler@6711
   511
aschiffler@6711
   512
	index = SDLTest_RandomSint32() % size;
aschiffler@6711
   513
	retVal = (Sint16) buffer[index];
aschiffler@6711
   514
aschiffler@6711
   515
	SDL_free(buffer);
aschiffler@6711
   516
aschiffler@6711
   517
	fuzzerInvocationCounter++;
aschiffler@6711
   518
aschiffler@6711
   519
	return retVal;
aschiffler@6711
   520
}
aschiffler@6711
   521
aschiffler@6711
   522
Sint32
aschiffler@6711
   523
SDLTest_RandomSint32BoundaryValue(Sint32 boundary1, Sint32 boundary2, SDL_bool validDomain)
aschiffler@6711
   524
{
aschiffler@6711
   525
	// min & max values for Sint32
aschiffler@6711
   526
	const Sint64 maxValue = INT_MAX;
aschiffler@6711
   527
	const Sint64 minValue = INT_MIN;
aschiffler@6711
   528
aschiffler@6711
   529
	Sint64 *buffer = NULL;
aschiffler@6711
   530
	Uint32 size;
aschiffler@6711
   531
	Uint32 index;
aschiffler@6711
   532
	Sint32 retVal;
aschiffler@6711
   533
aschiffler@6711
   534
	size = SDLTest_GenerateSignedBoundaryValues(minValue, maxValue,
aschiffler@6711
   535
				(Sint64) boundary1, (Sint64) boundary2,
aschiffler@6711
   536
				validDomain, buffer);
aschiffler@6719
   537
	if (buffer == NULL || size == 0) {
aschiffler@6711
   538
		return INT_MIN;
aschiffler@6711
   539
	}
aschiffler@6711
   540
aschiffler@6711
   541
	index = SDLTest_RandomSint32() % size;
aschiffler@6711
   542
	retVal = (Sint32) buffer[index];
aschiffler@6711
   543
aschiffler@6711
   544
	SDL_free(buffer);
aschiffler@6711
   545
aschiffler@6711
   546
	fuzzerInvocationCounter++;
aschiffler@6711
   547
aschiffler@6711
   548
	return retVal;
aschiffler@6711
   549
}
aschiffler@6711
   550
aschiffler@6711
   551
Sint64
aschiffler@6711
   552
SDLTest_RandomSint64BoundaryValue(Sint64 boundary1, Sint64 boundary2, SDL_bool validDomain)
aschiffler@6711
   553
{
aschiffler@6711
   554
	Sint64 *buffer = NULL;
aschiffler@6711
   555
	Uint32 size;
aschiffler@6711
   556
	Uint32 index;
aschiffler@6711
   557
	Sint64 retVal;
aschiffler@6711
   558
aschiffler@6711
   559
	// min & max values for Sint64
aschiffler@6711
   560
	const Sint64 maxValue = LLONG_MAX;
aschiffler@6711
   561
	const Sint64 minValue = LLONG_MIN;
aschiffler@6711
   562
aschiffler@6711
   563
	size = SDLTest_GenerateSignedBoundaryValues(minValue, maxValue,
aschiffler@6711
   564
				(Sint64) boundary1, (Sint64) boundary2,
aschiffler@6711
   565
				validDomain, buffer);
aschiffler@6719
   566
	if (buffer == NULL || size == 0) {
aschiffler@6711
   567
		return LLONG_MIN;
aschiffler@6711
   568
	}
aschiffler@6711
   569
aschiffler@6711
   570
	index = SDLTest_RandomSint32() % size;
aschiffler@6711
   571
	retVal = (Sint64) buffer[index];
aschiffler@6711
   572
aschiffler@6711
   573
	SDL_free(buffer);
aschiffler@6711
   574
aschiffler@6711
   575
	fuzzerInvocationCounter++;
aschiffler@6711
   576
aschiffler@6711
   577
	return retVal;
aschiffler@6711
   578
}
aschiffler@6711
   579
aschiffler@6711
   580
float
aschiffler@6711
   581
SDLTest_RandomUnitFloat()
aschiffler@6711
   582
{
aschiffler@6711
   583
	return (float) SDLTest_RandomUint32() / UINT_MAX;
aschiffler@6711
   584
}
aschiffler@6711
   585
aschiffler@6711
   586
float
aschiffler@6711
   587
SDLTest_RandomFloat()
aschiffler@6711
   588
{
aschiffler@6839
   589
        return (float) (SDLTest_RandomUnitDouble() * (double)2.0 * (double)FLT_MAX - (double)(FLT_MAX));
aschiffler@6711
   590
}
aschiffler@6711
   591
aschiffler@6711
   592
double
aschiffler@6711
   593
SDLTest_RandomUnitDouble()
aschiffler@6711
   594
{
aschiffler@6711
   595
	return (double) (SDLTest_RandomUint64() >> 11) * (1.0/9007199254740992.0);
aschiffler@6711
   596
}
aschiffler@6711
   597
aschiffler@6711
   598
double
aschiffler@6711
   599
SDLTest_RandomDouble()
aschiffler@6711
   600
{
aschiffler@6711
   601
	double r = 0.0;
aschiffler@6711
   602
	double s = 1.0;
aschiffler@6711
   603
	do {
aschiffler@6711
   604
	  s /= UINT_MAX + 1.0;
aschiffler@6711
   605
	  r += (double)SDLTest_RandomInt(&rndContext) * s;
aschiffler@6711
   606
	} while (s > DBL_EPSILON);
aschiffler@6711
   607
	  
aschiffler@6711
   608
	fuzzerInvocationCounter++;
aschiffler@6711
   609
	
aschiffler@6711
   610
	return r;
aschiffler@6711
   611
}
aschiffler@6711
   612
aschiffler@6711
   613
aschiffler@6711
   614
char *
aschiffler@6711
   615
SDLTest_RandomAsciiString()
aschiffler@6711
   616
{
aschiffler@6711
   617
	return SDLTest_RandomAsciiStringWithMaximumLength(255);
aschiffler@6711
   618
}
aschiffler@6711
   619
aschiffler@6711
   620
char *
aschiffler@6811
   621
SDLTest_RandomAsciiStringWithMaximumLength(int maxLength)
aschiffler@6711
   622
{
aschiffler@6711
   623
	int size;
aschiffler@6811
   624
aschiffler@6811
   625
	if(maxLength < 1) {
aschiffler@6811
   626
                SDL_InvalidParamError("maxLength");
aschiffler@6811
   627
		return NULL;
aschiffler@6811
   628
	}
aschiffler@6811
   629
aschiffler@6811
   630
	size = (SDLTest_RandomUint32() % (maxLength + 1));
aschiffler@6811
   631
	
aschiffler@6811
   632
	return SDLTest_RandomAsciiStringOfSize(size);	
aschiffler@6811
   633
}
aschiffler@6811
   634
aschiffler@6811
   635
char *
aschiffler@6811
   636
SDLTest_RandomAsciiStringOfSize(int size)
aschiffler@6811
   637
{
aschiffler@6711
   638
	char *string;
aschiffler@6711
   639
	int counter;
aschiffler@6711
   640
aschiffler@6711
   641
aschiffler@6811
   642
	if(size < 1) {
aschiffler@6811
   643
                SDL_InvalidParamError("size");
aschiffler@6711
   644
		return NULL;
aschiffler@6711
   645
	}
aschiffler@6711
   646
aschiffler@6811
   647
	string = (char *)SDL_malloc((size + 1) * sizeof(char));
aschiffler@6711
   648
	if (string==NULL) {
aschiffler@6711
   649
	  return NULL;
aschiffler@6711
   650
        }
aschiffler@6711
   651
aschiffler@6711
   652
	for(counter = 0; counter < size; ++counter) {
aschiffler@6760
   653
		string[counter] = (char)SDLTest_RandomIntegerInRange(32, 126);
aschiffler@6711
   654
	}
aschiffler@6711
   655
aschiffler@6711
   656
	string[counter] = '\0';
aschiffler@6711
   657
aschiffler@6811
   658
	fuzzerInvocationCounter++;
aschiffler@6811
   659
aschiffler@6711
   660
	return string;
aschiffler@6711
   661
}