From 7504b1c319373c950e8b8c2c7a8b2f0d9abf1d8b Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 5 Oct 2023 10:17:09 -0400 Subject: SL-18837: When llrand_test.cpp fails, display the failing value. It's frustrating and unactionable to have a failing test report merely that the random value was greater than the specified high end. Okay, so what was the value? If it's supposed to be less than the high end, did it happen to be equal? Or was it garbage? We can't reproduce the failure by rerunning! The new ensure_in_exc_range(), ensure_in_inc_range() mechanism is somewhat complex because exactly one test allows equality with the high end of the expected range, where the rest mandate that the function return less than the high end. If that's a bug in the test -- if every llrand function is supposed to return less than the high end -- then we could simplify the test logic. --- indra/llcommon/tests/llrand_test.cpp | 60 +++++++++++++++++++----------------- 1 file changed, 32 insertions(+), 28 deletions(-) (limited to 'indra/llcommon/tests/llrand_test.cpp') diff --git a/indra/llcommon/tests/llrand_test.cpp b/indra/llcommon/tests/llrand_test.cpp index 383e6f9e0a..c8e2d19372 100644 --- a/indra/llcommon/tests/llrand_test.cpp +++ b/indra/llcommon/tests/llrand_test.cpp @@ -29,7 +29,30 @@ #include "../test/lltut.h" #include "../llrand.h" +#include "stringize.h" +template +void ensure_in_range_using(const std::string_view& name, + NUMBER value, NUMBER low, NUMBER high, + const std::string_view& compdesc, HIGHCOMP&& highcomp) +{ + auto failmsg{ stringize(name, " >= ", low, " (", value, ')') }; + tut::ensure(failmsg, (value >= low)); + failmsg = stringize(name, ' ', compdesc, ' ', high, " (", value, ')'); + tut::ensure(failmsg, std::forward(highcomp)(value, high)); +} + +template +void ensure_in_exc_range(const std::string_view& name, NUMBER value, NUMBER low, NUMBER high) +{ + ensure_in_range_using(name, value, low, high, "<", std::less()); +} + +template +void ensure_in_inc_range(const std::string_view& name, NUMBER value, NUMBER low, NUMBER high) +{ + ensure_in_range_using(name, value, low, high, "<=", std::less_equal()); +} namespace tut { @@ -44,84 +67,65 @@ namespace tut template<> template<> void random_object_t::test<1>() { - F32 number = 0.0f; for(S32 ii = 0; ii < 100000; ++ii) { - number = ll_frand(); - ensure("frand >= 0", (number >= 0.0f)); - ensure("frand < 1", (number < 1.0f)); + ensure_in_exc_range("frand", ll_frand(), 0.0f, 1.0f); } } template<> template<> void random_object_t::test<2>() { - F64 number = 0.0f; for(S32 ii = 0; ii < 100000; ++ii) { - number = ll_drand(); - ensure("drand >= 0", (number >= 0.0)); - ensure("drand < 1", (number < 1.0)); + ensure_in_exc_range("drand", ll_drand(), 0.0, 1.0); } } template<> template<> void random_object_t::test<3>() { - F32 number = 0.0f; for(S32 ii = 0; ii < 100000; ++ii) { - number = ll_frand(2.0f) - 1.0f; - ensure("frand >= 0", (number >= -1.0f)); - ensure("frand < 1", (number <= 1.0f)); + ensure_in_inc_range("frand(2.0f)", ll_frand(2.0f) - 1.0f, -1.0f, 1.0f); } } template<> template<> void random_object_t::test<4>() { - F32 number = 0.0f; for(S32 ii = 0; ii < 100000; ++ii) { - number = ll_frand(-7.0); - ensure("drand <= 0", (number <= 0.0)); - ensure("drand > -7", (number > -7.0)); + // Negate the result so we don't have to allow a templated low-end + // comparison as well. + ensure_in_exc_range("-frand(-7.0)", -ll_frand(-7.0), 0.0f, 7.0f); } } template<> template<> void random_object_t::test<5>() { - F64 number = 0.0f; for(S32 ii = 0; ii < 100000; ++ii) { - number = ll_drand(-2.0); - ensure("drand <= 0", (number <= 0.0)); - ensure("drand > -2", (number > -2.0)); + ensure_in_exc_range("-drand(-2.0)", -ll_drand(-2.0), 0.0, 2.0); } } template<> template<> void random_object_t::test<6>() { - S32 number = 0; for(S32 ii = 0; ii < 100000; ++ii) { - number = ll_rand(100); - ensure("rand >= 0", (number >= 0)); - ensure("rand < 100", (number < 100)); + ensure_in_exc_range("rand(100)", ll_rand(100), 0, 100); } } template<> template<> void random_object_t::test<7>() { - S32 number = 0; for(S32 ii = 0; ii < 100000; ++ii) { - number = ll_rand(-127); - ensure("rand <= 0", (number <= 0)); - ensure("rand > -127", (number > -127)); + ensure_in_exc_range("-rand(-127)", -ll_rand(-127), 0, 127); } } } -- cgit v1.2.3 From f5a34fd074bda091732a8ae0a4cf6f4e0358a140 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Thu, 12 Oct 2023 16:55:04 -0400 Subject: SL-18837: Unify all llrand_test.cpp in-range tests. The header file documents that no llrand function should ever return a value equal to the passed extent, so the one test in llrand_test.cpp that checked less than or equal to the high end of the range was anomalous. But changing that to an exclusive range means that we no longer need separate exclusive range and inclusive range functions. Replace ensure_in_range_using(), ensure_in_exc_range() and ensure_in_inc_range() with a grand unified (simplified) ensure_in_range() function. --- indra/llcommon/tests/llrand_test.cpp | 43 +++++++++++++++--------------------- 1 file changed, 18 insertions(+), 25 deletions(-) (limited to 'indra/llcommon/tests/llrand_test.cpp') diff --git a/indra/llcommon/tests/llrand_test.cpp b/indra/llcommon/tests/llrand_test.cpp index c8e2d19372..ac5a33d0ba 100644 --- a/indra/llcommon/tests/llrand_test.cpp +++ b/indra/llcommon/tests/llrand_test.cpp @@ -31,27 +31,20 @@ #include "../llrand.h" #include "stringize.h" -template -void ensure_in_range_using(const std::string_view& name, - NUMBER value, NUMBER low, NUMBER high, - const std::string_view& compdesc, HIGHCOMP&& highcomp) +// In llrand.h, every function is documented to return less than the high end +// -- specifically, because you can pass a negative extent, they're documented +// never to return a value equal to the extent. +// So that we don't need two different versions of ensure_in_range(), when +// testing extent < 0, negate the return value and the extent before passing +// into ensure_in_range(). +template +void ensure_in_range(const std::string_view& name, + NUMBER value, NUMBER low, NUMBER high) { auto failmsg{ stringize(name, " >= ", low, " (", value, ')') }; tut::ensure(failmsg, (value >= low)); - failmsg = stringize(name, ' ', compdesc, ' ', high, " (", value, ')'); - tut::ensure(failmsg, std::forward(highcomp)(value, high)); -} - -template -void ensure_in_exc_range(const std::string_view& name, NUMBER value, NUMBER low, NUMBER high) -{ - ensure_in_range_using(name, value, low, high, "<", std::less()); -} - -template -void ensure_in_inc_range(const std::string_view& name, NUMBER value, NUMBER low, NUMBER high) -{ - ensure_in_range_using(name, value, low, high, "<=", std::less_equal()); + failmsg = stringize(name, " < ", high, " (", value, ')'); + tut::ensure(failmsg, (value < high)); } namespace tut @@ -69,7 +62,7 @@ namespace tut { for(S32 ii = 0; ii < 100000; ++ii) { - ensure_in_exc_range("frand", ll_frand(), 0.0f, 1.0f); + ensure_in_range("frand", ll_frand(), 0.0f, 1.0f); } } @@ -78,7 +71,7 @@ namespace tut { for(S32 ii = 0; ii < 100000; ++ii) { - ensure_in_exc_range("drand", ll_drand(), 0.0, 1.0); + ensure_in_range("drand", ll_drand(), 0.0, 1.0); } } @@ -87,7 +80,7 @@ namespace tut { for(S32 ii = 0; ii < 100000; ++ii) { - ensure_in_inc_range("frand(2.0f)", ll_frand(2.0f) - 1.0f, -1.0f, 1.0f); + ensure_in_range("frand(2.0f)", ll_frand(2.0f) - 1.0f, -1.0f, 1.0f); } } @@ -98,7 +91,7 @@ namespace tut { // Negate the result so we don't have to allow a templated low-end // comparison as well. - ensure_in_exc_range("-frand(-7.0)", -ll_frand(-7.0), 0.0f, 7.0f); + ensure_in_range("-frand(-7.0)", -ll_frand(-7.0), 0.0f, 7.0f); } } @@ -107,7 +100,7 @@ namespace tut { for(S32 ii = 0; ii < 100000; ++ii) { - ensure_in_exc_range("-drand(-2.0)", -ll_drand(-2.0), 0.0, 2.0); + ensure_in_range("-drand(-2.0)", -ll_drand(-2.0), 0.0, 2.0); } } @@ -116,7 +109,7 @@ namespace tut { for(S32 ii = 0; ii < 100000; ++ii) { - ensure_in_exc_range("rand(100)", ll_rand(100), 0, 100); + ensure_in_range("rand(100)", ll_rand(100), 0, 100); } } @@ -125,7 +118,7 @@ namespace tut { for(S32 ii = 0; ii < 100000; ++ii) { - ensure_in_exc_range("-rand(-127)", -ll_rand(-127), 0, 127); + ensure_in_range("-rand(-127)", -ll_rand(-127), 0, 127); } } } -- cgit v1.2.3