Add TEST_CONTEXT

Avoid to require manual output in anticipation of failures.

Author: Flamefire

test/boostLocale/test/unit_test.hpp

@@ -48,16 +48,26 @@ namespace boost { namespace locale { namespace test {
         }
         int error_counter;
         int test_counter;
+        std::string context;
     };
     inline test_result& results()
     {
         static test_result instance;
         return instance;
     }
 
+    struct context {
+        const std::string oldCtx;
+        context(std::string ctx) : oldCtx(std::move(results().context)) { results().context = std::move(ctx); }
+        ~context() { results().context = std::move(oldCtx); }
+    };
+
     inline void report_error(const char* expr, const char* file, int line)
     {
         std::cerr << "Error at " << file << '#' << line << ": " << expr << std::endl;
+        std::string& ctx = results().context;
+        if(!ctx.empty())
+            std::cerr << " context: " << ctx << std::endl;
         if(++boost::locale::test::results().error_counter > BOOST_LOCALE_ERROR_LIMIT)
             throw std::runtime_error("Error limits reached, stopping unit test");
     }
@@ -97,6 +107,10 @@ namespace boost { namespace locale { namespace test {
         BOOST_LOCALE_START_CONST_CONDITION             \
     } while(0) BOOST_LOCALE_END_CONST_CONDITION
 
+#define TEST_CONTEXT(expr)                       \
+    boost::locale::test::context _##__COUNTER__( \
+      static_cast<const std::stringstream&>(std::stringstream{} << expr).str())
+
 void test_main(int argc, char** argv);
 
 int main(int argc, char** argv)

test/test_catalog.cpp

@@ -31,10 +31,8 @@ void test_plural_expr_rand(const T& ref, const char* expr)
         const auto n = getRandValue(minVal, maxVal);
         const auto result = ptr(n);
         const auto refResult = ref(n);
-        if(result != refResult) {
-            std::cerr << "Expression: " << expr << "; n=" << n << '\n'; // LCOV_EXCL_LINE
-            TEST_EQ(result, refResult);                                 // LCOV_EXCL_LINE
-        }
+        TEST_CONTEXT("Expression: " << expr << "; n=" << n);
+        TEST_EQ(result, refResult);
     }
 }
 

test/test_codecvt.cpp

@@ -53,10 +53,8 @@ void test_codecvt_in_n_m(const cvt_type& cvt, int n, int m)
         std::mbstate_t mb2 = mb;
         std::codecvt_base::result r = cvt.in(mb, from, end, from_next, to, to_end, to_next);
 
-        int count = cvt.length(mb2, from, end, to_end - to);
+        const int count = cvt.length(mb2, from, end, to_end - to);
         TEST_EQ(memcmp(&mb, &mb2, sizeof(mb)), 0);
-        if(count != from_next - from)
-            std::cout << count << " " << from_next - from << std::endl; // LCOV_EXCL_LINE
         TEST_EQ(count, from_next - from);
 
         if(r == cvt_type::partial) {

test/test_encoding.cpp

@@ -832,10 +832,9 @@ void test_simple_encodings()
     const auto encodings = get_simple_encodings();
     for(auto it = encodings.begin(), end = encodings.end(); it != end; ++it) {
         TEST_EQ(normalize_encoding(*it), *it); // Must be normalized
-        const auto it2 = std::find(it + 1, end, *it);
-        TEST(it2 == end);
-        if(it2 != end)
-            std::cerr << "Duplicate entry: " << *it << '\n'; // LCOV_EXCL_LINE
+        TEST_CONTEXT("Entry: " << *it);
+        // Must be unique
+        TEST(std::find(it + 1, end, *it) == end);
     }
     const auto it = std::is_sorted_until(encodings.begin(), encodings.end());
     TEST(it == encodings.end());
@@ -852,10 +851,9 @@ void test_win_codepages()
         auto is_same_win_codepage = [&it](const windows_encoding& rhs) -> bool {
             return it->codepage == rhs.codepage && std::strcmp(it->name, rhs.name) == 0;
         };
-        const auto* it2 = std::find_if(it + 1, end, is_same_win_codepage);
-        TEST(it2 == end);
-        if(it2 != end)
-            std::cerr << "Duplicate entry: " << it->name << ':' << it->codepage << '\n'; // LCOV_EXCL_LINE
+        TEST_CONTEXT("Entry: " << it->name << ':' << it->codepage);
+        // Must be unique
+        TEST(std::find_if(it + 1, end, is_same_win_codepage) == end);
     }
     const auto cmp = [](const windows_encoding& rhs, const windows_encoding& lhs) -> bool { return rhs < lhs.name; };
     const auto* it = std::is_sorted_until(all_windows_encodings, std::end(all_windows_encodings), cmp);