123 lines
4.1 KiB
C
123 lines
4.1 KiB
C
/* 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"
|