29 #include <gtest/gtest-spi.h>
30 #include <gtest/gtest.h>
43 TEST(SatCounterDeathTest, BitCountExceeds)
46 GTEST_SKIP() <<
"Skipping as assertions are "
47 "stripped out of fast builds";
52 ASSERT_NE(
gtestLogOutput.str().find(
"Number of bits exceeds counter size"),
60 TEST(SatCounterDeathTest, InitialValueExceeds)
63 GTEST_SKIP() <<
"Skipping as assertions are "
64 "stripped out of fast builds";
69 ASSERT_NE(
gtestLogOutput.str().find(
"initial value exceeds max value"),
76 TEST(SatCounterTest, MaximumValue)
78 const unsigned bits = 3;
79 const unsigned max_value = (1 <<
bits) - 1;
82 for (
int i = 0;
i < 2*max_value;
i++) {
86 ASSERT_EQ(counter, max_value);
92 TEST(SatCounterTest, MinimumValue)
94 const unsigned bits = 3;
97 for (
int i = 0;
i < 2;
i++) {
101 ASSERT_EQ(counter, 0);
107 TEST(SatCounterTest, InitialValue)
109 const unsigned bits = 3;
110 const unsigned initial_value = 4;
112 ASSERT_EQ(counter, initial_value);
115 ASSERT_EQ(counter, initial_value);
121 TEST(SatCounterTest, SaturationPercentile)
123 const unsigned bits = 3;
124 const unsigned max_value = (1 <<
bits) - 1;
128 for (
double value = 0.0; value <= max_value; value++, counter++) {
129 const double saturation = value / max_value;
140 const unsigned bits = 3;
141 const unsigned max_value = (1 <<
bits) - 1;
147 const unsigned diff = counter.
saturate();
148 ASSERT_EQ(diff, max_value - 1);
155 TEST(SatCounterTest, IntComparison)
157 const unsigned bits = 3;
161 ASSERT_EQ(counter++, value++);
162 ASSERT_EQ(counter++, value++);
163 ASSERT_EQ(counter--, value--);
164 ASSERT_EQ(counter++, value++);
165 ASSERT_EQ(counter++, value++);
166 ASSERT_EQ(counter--, value--);
167 ASSERT_EQ(counter++, value++);
168 ASSERT_EQ(counter--, value--);
169 ASSERT_EQ(counter--, value--);
170 ASSERT_EQ(counter++, value++);
171 ASSERT_EQ(counter--, value--);
172 ASSERT_EQ(counter--, value--);
173 ASSERT_EQ(counter, 0);
181 const unsigned bits = 3;
182 const unsigned max_value = (1 <<
bits) - 1;
183 const unsigned initial_value = 1;
189 int value = initial_value;
194 ASSERT_EQ(counter, value);
197 ASSERT_EQ(counter, value);
201 ASSERT_EQ(counter, max_value);
205 ASSERT_EQ(counter, 0);
209 value = initial_value;
212 ASSERT_EQ(counter, value);
213 counter <<= saturated_counter;
215 ASSERT_EQ(counter, max_value);
220 ASSERT_EQ(counter, value);
221 counter >>= saturated_counter;
222 ASSERT_EQ(counter, 0);
229 TEST(SatCounterDeathTest, RightShiftNegative)
232 GTEST_SKIP() <<
"Skipping as assertions are "
233 "stripped out of fast builds";
237 ASSERT_DEATH(counter >>= -1,
"");
244 TEST(SatCounterDeathTest, LeftShiftNegative)
247 GTEST_SKIP() <<
"Skipping as assertions are "
248 "stripped out of fast builds";
252 ASSERT_DEATH(counter <<= -1,
"");
258 TEST(SatCounterTest, PrePostOperators)
260 const unsigned bits = 3;
261 const unsigned max_value = (1 <<
bits) - 1;
265 for (
int i = 0;
i < 2*max_value;
i++) {
268 ASSERT_EQ(counter_post, value_pre);
271 ASSERT_EQ(counter_pre, max_value);
272 ASSERT_EQ(counter_post, max_value);
274 for (
int i = 0;
i < 2*max_value;
i++) {
277 ASSERT_EQ(counter_post, value_pre);
280 ASSERT_EQ(counter_pre, 0);
281 ASSERT_EQ(counter_post, 0);
289 const unsigned bits = 3;
290 const unsigned max_value = (1 <<
bits) - 1;
291 const unsigned initial_value = 1;
302 deep_copy = counter_copy = counter;
303 ASSERT_EQ(counter_copy_constructor, initial_value + 1);
304 ASSERT_EQ(counter_copy, initial_value + 1);
305 ASSERT_EQ(deep_copy, initial_value + 1);
309 for (
int i = 0;
i < 2*max_value;
i++) {
310 counter_copy_constructor++;
314 ASSERT_EQ(counter, initial_value + 1);
315 ASSERT_EQ(counter_copy_constructor, max_value);
316 ASSERT_EQ(counter_copy, max_value);
317 ASSERT_EQ(deep_copy, max_value);
320 counter_copy_constructor.
reset();
321 counter_copy.
reset();
323 ASSERT_EQ(counter_copy_constructor, initial_value);
324 ASSERT_EQ(counter_copy, initial_value);
325 ASSERT_EQ(deep_copy, initial_value);
328 SatCounter8 counter_move_constructor(std::move(counter));
329 ASSERT_EQ(counter, 0);
330 ASSERT_EQ(counter_move_constructor, initial_value + 1);
333 counter_move = std::move(counter_move_constructor);
334 ASSERT_EQ(counter_move_constructor, 0);
335 ASSERT_EQ(counter_move, initial_value + 1);
341 TEST(SatCounterTest, AddSubAssignment)
343 const unsigned bits = 3;
344 const unsigned max_value = (1 <<
bits) - 1;
353 ASSERT_EQ(counter, value);
356 ASSERT_EQ(counter, value);
357 counter += max_value;
359 ASSERT_EQ(counter, value);
364 ASSERT_EQ(counter, value);
367 ASSERT_EQ(counter, value);
368 counter -= max_value;
370 ASSERT_EQ(counter, value);
375 ASSERT_EQ(counter, value);
376 counter += saturated_counter;
378 ASSERT_EQ(counter, saturated_counter);
383 ASSERT_EQ(counter, value);
384 counter -= saturated_counter;
385 ASSERT_EQ(counter, 0);
391 TEST(SatCounterTest, NegativeAddSubAssignment)
393 const unsigned bits = 3;
394 const unsigned max_value = (1 <<
bits) - 1;
396 int value = max_value;
401 ASSERT_EQ(counter, value);
404 ASSERT_EQ(counter, value);
405 counter += (int)-max_value;
407 ASSERT_EQ(counter, value);
412 ASSERT_EQ(counter, value);
415 ASSERT_EQ(counter, value);
416 counter -= (int)-max_value;
418 ASSERT_EQ(counter, value);
424 const uint16_t bits_16 = 9;
425 const uint16_t max_value_16 = (1 << bits_16) - 1;
430 ASSERT_EQ(counter_16, 1);
432 ASSERT_EQ(counter_16, 2);
433 counter_16 += 2 * max_value_16;
434 ASSERT_EQ(counter_16, max_value_16);
436 ASSERT_EQ(counter_16, max_value_16);
438 ASSERT_EQ(counter_16, max_value_16);
442 ASSERT_EQ(counter_16, max_value_16 - 1);
444 ASSERT_EQ(counter_16, (max_value_16 - 1) >> 1);
445 counter_16 -= 2 * max_value_16;
446 ASSERT_EQ(counter_16, 0);
448 ASSERT_EQ(counter_16, 0);
450 ASSERT_EQ(counter_16, 0);
456 const uint32_t bits_32 = 17;
457 const uint32_t max_value_32 = (1 << bits_32) - 1;
462 ASSERT_EQ(counter_32, 1);
464 ASSERT_EQ(counter_32, 2);
465 counter_32 += 2 * max_value_32;
466 ASSERT_EQ(counter_32, max_value_32);
468 ASSERT_EQ(counter_32, max_value_32);
470 ASSERT_EQ(counter_32, max_value_32);
474 ASSERT_EQ(counter_32, max_value_32 - 1);
476 ASSERT_EQ(counter_32, (max_value_32 - 1) >> 1);
477 counter_32 -= 2 * max_value_32;
478 ASSERT_EQ(counter_32, 0);
480 ASSERT_EQ(counter_32, 0);
482 ASSERT_EQ(counter_32, 0);
488 const uint64_t bits_64 = 33;
489 const uint64_t max_value_64 = (1ULL << bits_64) - 1;
494 ASSERT_EQ(counter_64, 1);
496 ASSERT_EQ(counter_64, 2);
497 counter_64 += max_value_64;
498 ASSERT_EQ(counter_64, max_value_64);
500 ASSERT_EQ(counter_64, max_value_64);
502 ASSERT_EQ(counter_64, max_value_64);
506 ASSERT_EQ(counter_64, max_value_64 - 1);
508 ASSERT_EQ(counter_64, (max_value_64 - 1) >> 1);
509 counter_64 -= max_value_64;
510 ASSERT_EQ(counter_64, 0);
512 ASSERT_EQ(counter_64, 0);
514 ASSERT_EQ(counter_64, 0);
constexpr T bits(T val, unsigned first, unsigned last)
Extract the bitfield from position 'first' to 'last' (inclusive) from 'val' and right justify it.
bool isSaturated() const
Whether the counter has achieved its maximum value or not.
double calcSaturation() const
Calculate saturation percentile of the current counter's value with regard to its maximum possible va...
uint8_t saturate()
Saturate the counter.
void reset()
Reset the counter to its initial value.
Reference material can be found at the JEDEC website: UFS standard http://www.jedec....
thread_local GTestLogOutput gtestLogOutput
TEST(SatCounterDeathTest, BitCountExceeds)
Test that an error is triggered when the number of bits exceeds the counter's capacity.