Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
glibc/stdlib/tst-random.c
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
122 lines (105 sloc)
4.1 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* Test program for random(), srandom(), initstate(), setstate() | |
Written by Michael J. Fischer, August 21, 2000 | |
Placed in the public domain. */ | |
/* This program primarily tests the correct functioning of srandom() | |
and setstate(). The strategy is generate and store a set of random | |
sequences, each with a specified starting seed. Then each sequence | |
is regenerated twice and checked against the stored values. | |
First they are regenerated one sequence at a time, using srandom() | |
to set the initial state. A discrepency here would suggest that | |
srandom() was failing to completely initialize the random number | |
generator. | |
Second the sequences are regenerated in an interleaved order. | |
A state vector is created for each sequence using initstate(). | |
setstate() is used to switch from sequence to sequence during | |
the interleaved generation. A discrepency here would suggest | |
a problem with either initstate() failing to initialize the | |
random number generator properly, or the failure of setstate() | |
to correctly save and restore state information. Also, each | |
time setstate() is called, the returned value is checked for | |
correctness (since we know what it should be). | |
Note: We use default state vector for sequence 0 and our own | |
state vectors for the remaining sequences. This is to give a check | |
that the value returned by initstate() is valid and can indeed be | |
used in the future. */ | |
/* Strategy: | |
1. Use srandom() followed by calls on random to generate a set of | |
sequences of values. | |
2. Regenerate and check the sequences. | |
3. Use initstate() to create new states. | |
4. Regenerate the sequences in an interleaved manner and check. | |
*/ | |
#include <stdlib.h> | |
#include <stdio.h> | |
const int degree = 128; /* random number generator degree (should | |
be one of 8, 16, 32, 64, 128, 256) */ | |
const int nseq = 3; /* number of test sequences */ | |
const int nrnd = 50; /* length of each test sequence */ | |
const unsigned int seed[3] = { 0x12344321U, 0xEE11DD22U, 0xFEDCBA98 }; | |
void fail (const char *msg, int s, int i) __attribute__ ((__noreturn__)); | |
static int | |
do_test (void) | |
{ | |
long int rnd[nseq][nrnd]; /* pseudorandom numbers */ | |
char* state[nseq]; /* state for PRNG */ | |
char* oldstate[nseq]; /* old PRNG state */ | |
int s; /* sequence index */ | |
int i; /* element index */ | |
printf ("Begining random package test using %d sequences of length %d.\n", | |
nseq, nrnd); | |
/* 1. Generate and store the sequences. */ | |
printf ("Generating random sequences.\n"); | |
for (s = 0; s < nseq; ++s) | |
{ | |
srandom ( seed[s] ); | |
for (i = 0; i < nrnd; ++i) | |
rnd[s][i] = random (); | |
} | |
/* 2. Regenerate and check. */ | |
printf ("Regenerating and checking sequences.\n"); | |
for (s = 0; s < nseq; ++s) | |
{ | |
srandom (seed[s]); | |
for (i = 0; i < nrnd; ++i) | |
if (rnd[s][i] != random ()) | |
fail ("first regenerate test", s, i); | |
} | |
/* 3. Create state vector, one for each sequence. | |
First state is random's internal state; others are malloced. */ | |
printf ("Creating and checking state vector for each sequence.\n"); | |
srandom (seed[0]); /* reseed with first seed */ | |
for (s = 1; s < nseq; ++s) | |
{ | |
state[s] = (char*) malloc (degree); | |
oldstate[s] = initstate (seed[s], state[s], degree); | |
} | |
state[0] = oldstate[1]; | |
/* Check returned values. */ | |
for (s = 1; s < nseq - 1; ++s) | |
if (state[s] != oldstate[s + 1]) | |
fail ("bad initstate() return value", s, i); | |
/* 4. Regenerate sequences interleaved and check. */ | |
printf ("Regenerating and checking sequences in interleaved order.\n"); | |
for (i = 0; i < nrnd; ++i) | |
{ | |
for (s = 0; s < nseq; ++s) | |
{ | |
char *oldstate = (char *) setstate (state[s]); | |
if (oldstate != state[(s + nseq - 1) % nseq]) | |
fail ("bad setstate() return value", s, i); | |
if (rnd[s][i] != random ()) | |
fail ("bad value generated in interleave test", s, i); | |
} | |
} | |
printf ("All tests passed!\n"); | |
return 0; | |
} | |
void | |
fail (const char *msg, int s, int i) | |
{ | |
printf ("\nTest FAILED: "); | |
printf ("%s (seq %d, pos %d).\n", msg, s, i); | |
exit (1); | |
} | |
#define TEST_FUNCTION do_test () | |
#include "../test-skeleton.c" |