1 | /* Test program for random(), srandom(), initstate(), setstate() |
2 | Placed in the public domain. */ |
3 | |
4 | /* This program primarily tests the correct functioning of srandom() |
5 | and setstate(). The strategy is generate and store a set of random |
6 | sequences, each with a specified starting seed. Then each sequence |
7 | is regenerated twice and checked against the stored values. |
8 | |
9 | First they are regenerated one sequence at a time, using srandom() |
10 | to set the initial state. A discrepency here would suggest that |
11 | srandom() was failing to completely initialize the random number |
12 | generator. |
13 | |
14 | Second the sequences are regenerated in an interleaved order. |
15 | A state vector is created for each sequence using initstate(). |
16 | setstate() is used to switch from sequence to sequence during |
17 | the interleaved generation. A discrepency here would suggest |
18 | a problem with either initstate() failing to initialize the |
19 | random number generator properly, or the failure of setstate() |
20 | to correctly save and restore state information. Also, each |
21 | time setstate() is called, the returned value is checked for |
22 | correctness (since we know what it should be). |
23 | |
24 | Note: We use default state vector for sequence 0 and our own |
25 | state vectors for the remaining sequences. This is to give a check |
26 | that the value returned by initstate() is valid and can indeed be |
27 | used in the future. */ |
28 | |
29 | /* Strategy: |
30 | 1. Use srandom() followed by calls on random to generate a set of |
31 | sequences of values. |
32 | 2. Regenerate and check the sequences. |
33 | 3. Use initstate() to create new states. |
34 | 4. Regenerate the sequences in an interleaved manner and check. |
35 | */ |
36 | |
37 | #include <stdlib.h> |
38 | #include <stdio.h> |
39 | |
40 | const int degree = 128; /* random number generator degree (should |
41 | be one of 8, 16, 32, 64, 128, 256) */ |
42 | const int nseq = 3; /* number of test sequences */ |
43 | const int nrnd = 50; /* length of each test sequence */ |
44 | const unsigned int seed[3] = { 0x12344321U, 0xEE11DD22U, 0xFEDCBA98 }; |
45 | |
46 | void fail (const char *msg, int s, int i) __attribute__ ((__noreturn__)); |
47 | |
48 | static int |
49 | do_test (void) |
50 | { |
51 | long int rnd[nseq][nrnd]; /* pseudorandom numbers */ |
52 | char* state[nseq]; /* state for PRNG */ |
53 | char* oldstate[nseq]; /* old PRNG state */ |
54 | int s; /* sequence index */ |
55 | int i; /* element index */ |
56 | |
57 | printf (format: "Begining random package test using %d sequences of length %d.\n" , |
58 | nseq, nrnd); |
59 | |
60 | /* 1. Generate and store the sequences. */ |
61 | printf (format: "Generating random sequences.\n" ); |
62 | for (s = 0; s < nseq; ++s) |
63 | { |
64 | srandom ( seed: seed[s] ); |
65 | for (i = 0; i < nrnd; ++i) |
66 | rnd[s][i] = random (); |
67 | } |
68 | |
69 | /* 2. Regenerate and check. */ |
70 | printf (format: "Regenerating and checking sequences.\n" ); |
71 | for (s = 0; s < nseq; ++s) |
72 | { |
73 | srandom (seed: seed[s]); |
74 | for (i = 0; i < nrnd; ++i) |
75 | if (rnd[s][i] != random ()) |
76 | fail (msg: "first regenerate test" , s, i); |
77 | } |
78 | |
79 | /* 3. Create state vector, one for each sequence. |
80 | First state is random's internal state; others are malloced. */ |
81 | printf (format: "Creating and checking state vector for each sequence.\n" ); |
82 | srandom (seed: seed[0]); /* reseed with first seed */ |
83 | for (s = 1; s < nseq; ++s) |
84 | { |
85 | state[s] = (char*) malloc (size: degree); |
86 | oldstate[s] = initstate (seed: seed[s], statebuf: state[s], statelen: degree); |
87 | } |
88 | state[0] = oldstate[1]; |
89 | |
90 | /* Check returned values. */ |
91 | for (s = 1; s < nseq - 1; ++s) |
92 | if (state[s] != oldstate[s + 1]) |
93 | fail (msg: "bad initstate() return value" , s, i); |
94 | |
95 | /* 4. Regenerate sequences interleaved and check. */ |
96 | printf (format: "Regenerating and checking sequences in interleaved order.\n" ); |
97 | for (i = 0; i < nrnd; ++i) |
98 | { |
99 | for (s = 0; s < nseq; ++s) |
100 | { |
101 | char *oldstate = (char *) setstate (state[s]); |
102 | if (oldstate != state[(s + nseq - 1) % nseq]) |
103 | fail (msg: "bad setstate() return value" , s, i); |
104 | if (rnd[s][i] != random ()) |
105 | fail (msg: "bad value generated in interleave test" , s, i); |
106 | } |
107 | } |
108 | printf (format: "All tests passed!\n" ); |
109 | return 0; |
110 | } |
111 | |
112 | void |
113 | fail (const char *msg, int s, int i) |
114 | { |
115 | printf (format: "\nTest FAILED: " ); |
116 | printf (format: "%s (seq %d, pos %d).\n" , msg, s, i); |
117 | exit (1); |
118 | } |
119 | |
120 | #define TEST_FUNCTION do_test () |
121 | #include "../test-skeleton.c" |
122 | |