[PPL-devel] [GIT] ppl/ppl(devel): Empty expression statements avoided.

Roberto Bagnara roberto.bagnara at bugseng.com
Thu Aug 6 16:32:12 CEST 2020


Module: ppl/ppl
Branch: devel
Commit: b10f76b0260b1cb47c29be2b511127c67aedcc7d
URL:    http://www.cs.unipr.it/git/gitweb.cgi?p=ppl/ppl.git;a=commit;h=b10f76b0260b1cb47c29be2b511127c67aedcc7d

Author: Roberto Bagnara <roberto.bagnara at bugseng.com>
Date:   Thu Aug  6 16:31:44 2020 +0200

Empty expression statements avoided.

---

 tests/BD_Shape/max_min1.cc |   2 +-
 tests/ppl_test.hh          | 100 ++++++++++++++++++++++++++-------------------
 2 files changed, 59 insertions(+), 43 deletions(-)

diff --git a/tests/BD_Shape/max_min1.cc b/tests/BD_Shape/max_min1.cc
index e0cf68421..525244da1 100644
--- a/tests/BD_Shape/max_min1.cc
+++ b/tests/BD_Shape/max_min1.cc
@@ -773,7 +773,7 @@ BEGIN_MAIN
   DO_TEST(test13);
   DO_TEST(test14);
   DO_TEST(test15);
-  DO_TEST(test16);;
+  DO_TEST(test16);
   DO_TEST(test17);
   DO_TEST(test18);
   DO_TEST(test19);
diff --git a/tests/ppl_test.hh b/tests/ppl_test.hh
index 5e78f0f6f..fbee295cf 100644
--- a/tests/ppl_test.hh
+++ b/tests/ppl_test.hh
@@ -105,54 +105,70 @@ catch (const std::exception& e) {                                       \
   nout << "\n=== " #test " ===" << std::endl
 
 #define RUN_TEST(test)                                                  \
-  try {                                                                 \
-    overflow = false;                                                   \
-    succeeded = test();                                                 \
-  }                                                                     \
-  catch (const std::overflow_error& e) {                                \
-    nout << "arithmetic overflow (" << e.what() << ")"                  \
-         << std::endl;                                                  \
-    overflow = true;                                                    \
-    succeeded = false;                                                  \
-  }                                                                     \
-  catch (const std::exception& e) {                                     \
-    nout << "std::exception caught: "                                   \
-         << e.what() << " (type == " << typeid(e).name() << ")"         \
-         << std::endl;                                                  \
-    succeeded = false;                                                  \
-  }                                                                     \
-  catch (...) {                                                         \
-    nout << "unknown exception caught"                                  \
-         << std::endl;                                                  \
-    succeeded = false;                                                  \
-  }
-
-#define DO_TEST(test)                    \
-  ANNOUNCE_TEST(test);                   \
-  RUN_TEST(test);                        \
-  if (!succeeded)                        \
-    failed_tests.push_back(#test);
+  do {                                                                  \
+    try {                                                               \
+      overflow = false;                                                 \
+      succeeded = test();                                               \
+    }                                                                   \
+    catch (const std::overflow_error& e) {                              \
+      nout << "arithmetic overflow (" << e.what() << ")"                \
+           << std::endl;                                                \
+      overflow = true;                                                  \
+      succeeded = false;                                                \
+    }                                                                   \
+    catch (const std::exception& e) {                                   \
+      nout << "std::exception caught: "                                 \
+           << e.what() << " (type == " << typeid(e).name() << ")"       \
+           << std::endl;                                                \
+      succeeded = false;                                                \
+    }                                                                   \
+    catch (...) {                                                       \
+      nout << "unknown exception caught"                                \
+           << std::endl;                                                \
+      succeeded = false;                                                \
+    }                                                                   \
+  } while (false)
+
+#define DO_TEST(test)                                   \
+  do {                                                  \
+    ANNOUNCE_TEST(test);                                \
+    RUN_TEST(test);                                     \
+    if (!succeeded) {                                   \
+      failed_tests.push_back(#test);                    \
+    }                                                   \
+  } while (false)
 
 #define DO_TEST_F(test)                                 \
-  ANNOUNCE_TEST(test);                                  \
-  RUN_TEST(test);                                       \
-  if (succeeded)                                        \
-    unexpectedly_succeeded_tests.push_back(#test);
+  do {                                                  \
+    ANNOUNCE_TEST(test);                                \
+    RUN_TEST(test);                                     \
+    if (succeeded) {                                    \
+      unexpectedly_succeeded_tests.push_back(#test);    \
+    }                                                   \
+  } while (false)
 
 #define DO_TEST_OVERFLOW(test)                          \
-  ANNOUNCE_TEST(test);                                  \
-  RUN_TEST(test);                                       \
-  if (succeeded)                                        \
-    unexpectedly_succeeded_tests.push_back(#test);      \
-  else if (!overflow)                                   \
-    failed_tests.push_back(#test);
+  do {                                                  \
+    ANNOUNCE_TEST(test);                                \
+    RUN_TEST(test);                                     \
+    if (succeeded) {                                    \
+      unexpectedly_succeeded_tests.push_back(#test);    \
+    }                                                   \
+    else if (!overflow) {                               \
+      failed_tests.push_back(#test);                    \
+    }                                                   \
+  } while (false)
 
 #define DO_TEST_MAY_OVERFLOW_IF_INEXACT(test, shape)                    \
-  ANNOUNCE_TEST(test);                                                  \
-  RUN_TEST(test);                                                       \
-  if (!succeeded)                                                       \
-    if (!overflow || has_exact_coefficient_type(shape(0, EMPTY)))       \
-      failed_tests.push_back(#test);
+  do {                                                                  \
+    ANNOUNCE_TEST(test);                                                \
+    RUN_TEST(test);                                                     \
+    if (!succeeded) {                                                   \
+      if (!overflow || has_exact_coefficient_type(shape(0, EMPTY))) {   \
+        failed_tests.push_back(#test);                                  \
+      }                                                                 \
+    }                                                                   \
+  } while (false)
 
 
 // Macros for arbitrary combination of preprocessor conditions.




More information about the PPL-devel mailing list