1 #include "test/jemalloc_test.h" 2 3 TEST_BEGIN(test_prng_lg_range_u32) { 4 uint32_t sa, sb; 5 uint32_t ra, rb; 6 unsigned lg_range; 7 8 sa = 42; 9 ra = prng_lg_range_u32(&sa, 32); 10 sa = 42; 11 rb = prng_lg_range_u32(&sa, 32); 12 expect_u32_eq(ra, rb, 13 "Repeated generation should produce repeated results"); 14 15 sb = 42; 16 rb = prng_lg_range_u32(&sb, 32); 17 expect_u32_eq(ra, rb, 18 "Equivalent generation should produce equivalent results"); 19 20 sa = 42; 21 ra = prng_lg_range_u32(&sa, 32); 22 rb = prng_lg_range_u32(&sa, 32); 23 expect_u32_ne(ra, rb, 24 "Full-width results must not immediately repeat"); 25 26 sa = 42; 27 ra = prng_lg_range_u32(&sa, 32); 28 for (lg_range = 31; lg_range > 0; lg_range--) { 29 sb = 42; 30 rb = prng_lg_range_u32(&sb, lg_range); 31 expect_u32_eq((rb & (UINT32_C(0xffffffff) << lg_range)), 32 0, "High order bits should be 0, lg_range=%u", lg_range); 33 expect_u32_eq(rb, (ra >> (32 - lg_range)), 34 "Expected high order bits of full-width result, " 35 "lg_range=%u", lg_range); 36 } 37 38 } 39 TEST_END 40 41 TEST_BEGIN(test_prng_lg_range_u64) { 42 uint64_t sa, sb, ra, rb; 43 unsigned lg_range; 44 45 sa = 42; 46 ra = prng_lg_range_u64(&sa, 64); 47 sa = 42; 48 rb = prng_lg_range_u64(&sa, 64); 49 expect_u64_eq(ra, rb, 50 "Repeated generation should produce repeated results"); 51 52 sb = 42; 53 rb = prng_lg_range_u64(&sb, 64); 54 expect_u64_eq(ra, rb, 55 "Equivalent generation should produce equivalent results"); 56 57 sa = 42; 58 ra = prng_lg_range_u64(&sa, 64); 59 rb = prng_lg_range_u64(&sa, 64); 60 expect_u64_ne(ra, rb, 61 "Full-width results must not immediately repeat"); 62 63 sa = 42; 64 ra = prng_lg_range_u64(&sa, 64); 65 for (lg_range = 63; lg_range > 0; lg_range--) { 66 sb = 42; 67 rb = prng_lg_range_u64(&sb, lg_range); 68 expect_u64_eq((rb & (UINT64_C(0xffffffffffffffff) << lg_range)), 69 0, "High order bits should be 0, lg_range=%u", lg_range); 70 expect_u64_eq(rb, (ra >> (64 - lg_range)), 71 "Expected high order bits of full-width result, " 72 "lg_range=%u", lg_range); 73 } 74 } 75 TEST_END 76 77 TEST_BEGIN(test_prng_lg_range_zu) { 78 size_t sa, sb; 79 size_t ra, rb; 80 unsigned lg_range; 81 82 sa = 42; 83 ra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR)); 84 sa = 42; 85 rb = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR)); 86 expect_zu_eq(ra, rb, 87 "Repeated generation should produce repeated results"); 88 89 sb = 42; 90 rb = prng_lg_range_zu(&sb, ZU(1) << (3 + LG_SIZEOF_PTR)); 91 expect_zu_eq(ra, rb, 92 "Equivalent generation should produce equivalent results"); 93 94 sa = 42; 95 ra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR)); 96 rb = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR)); 97 expect_zu_ne(ra, rb, 98 "Full-width results must not immediately repeat"); 99 100 sa = 42; 101 ra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR)); 102 for (lg_range = (ZU(1) << (3 + LG_SIZEOF_PTR)) - 1; lg_range > 0; 103 lg_range--) { 104 sb = 42; 105 rb = prng_lg_range_zu(&sb, lg_range); 106 expect_zu_eq((rb & (SIZE_T_MAX << lg_range)), 107 0, "High order bits should be 0, lg_range=%u", lg_range); 108 expect_zu_eq(rb, (ra >> ((ZU(1) << (3 + LG_SIZEOF_PTR)) - 109 lg_range)), "Expected high order bits of full-width " 110 "result, lg_range=%u", lg_range); 111 } 112 113 } 114 TEST_END 115 116 TEST_BEGIN(test_prng_range_u32) { 117 uint32_t range; 118 119 const uint32_t max_range = 10000000; 120 const uint32_t range_step = 97; 121 const unsigned nreps = 10; 122 123 for (range = 2; range < max_range; range += range_step) { 124 uint32_t s; 125 unsigned rep; 126 127 s = range; 128 for (rep = 0; rep < nreps; rep++) { 129 uint32_t r = prng_range_u32(&s, range); 130 131 expect_u32_lt(r, range, "Out of range"); 132 } 133 } 134 } 135 TEST_END 136 137 TEST_BEGIN(test_prng_range_u64) { 138 uint64_t range; 139 140 const uint64_t max_range = 10000000; 141 const uint64_t range_step = 97; 142 const unsigned nreps = 10; 143 144 for (range = 2; range < max_range; range += range_step) { 145 uint64_t s; 146 unsigned rep; 147 148 s = range; 149 for (rep = 0; rep < nreps; rep++) { 150 uint64_t r = prng_range_u64(&s, range); 151 152 expect_u64_lt(r, range, "Out of range"); 153 } 154 } 155 } 156 TEST_END 157 158 TEST_BEGIN(test_prng_range_zu) { 159 size_t range; 160 161 const size_t max_range = 10000000; 162 const size_t range_step = 97; 163 const unsigned nreps = 10; 164 165 166 for (range = 2; range < max_range; range += range_step) { 167 size_t s; 168 unsigned rep; 169 170 s = range; 171 for (rep = 0; rep < nreps; rep++) { 172 size_t r = prng_range_zu(&s, range); 173 174 expect_zu_lt(r, range, "Out of range"); 175 } 176 } 177 } 178 TEST_END 179 180 int 181 main(void) { 182 return test_no_reentrancy( 183 test_prng_lg_range_u32, 184 test_prng_lg_range_u64, 185 test_prng_lg_range_zu, 186 test_prng_range_u32, 187 test_prng_range_u64, 188 test_prng_range_zu); 189 } 190