Merge pull request #243 from bitshares/update-error-msgs

abitmore · web-flow · commit 7db6fbaee44e · 2022-01-20T21:27:05.000+01:00
Update error messages
diff --git a/.github/workflows/build-and-test-ubuntu-debug.yml b/.github/workflows/build-and-test-ubuntu-debug.yml
@@ -8,7 +8,7 @@ jobs:
     name: Build and run tests in Debug mode
     strategy:
       matrix:
-        os: [ ubuntu-16.04, ubuntu-18.04, ubuntu-20.04 ]
+        os: [ ubuntu-18.04, ubuntu-20.04 ]
     runs-on: ${{ matrix.os }}
     steps:
     - name: Install dependencies
diff --git a/.github/workflows/build-and-test-ubuntu-release.yml b/.github/workflows/build-and-test-ubuntu-release.yml
@@ -8,7 +8,7 @@ jobs:
     name: Build and run tests in Release mode
     strategy:
       matrix:
-        os: [ ubuntu-16.04, ubuntu-18.04, ubuntu-20.04 ]
+        os: [ ubuntu-18.04, ubuntu-20.04 ]
     runs-on: ${{ matrix.os }}
     steps:
     - name: Install dependencies
diff --git a/.github/workflows/sonar-scan.yml b/.github/workflows/sonar-scan.yml
@@ -69,16 +69,19 @@ jobs:
               -D Boost_USE_STATIC_LIBS=OFF \
               ..
         popd
+    # Get OS version to be used in cache key - see https://github.com/actions/cache/issues/543
+    - run: |
+        echo "OS_VERSION=`lsb_release -sr`" >> $GITHUB_ENV
     - name: Load Cache
       uses: actions/cache@v2
       with:
         path: |
           ccache
           sonar_cache
-        key: sonar-${{ github.ref }}-${{ github.sha }}
+        key: sonar-${{ env.OS_VERSION }}-${{ github.ref }}-${{ github.sha }}
         restore-keys: |
-          sonar-${{ github.ref }}-
-          sonar-
+          sonar-${{ env.OS_VERSION }}-${{ github.ref }}-
+          sonar-${{ env.OS_VERSION }}-
     - name: Build
       run: |
         export CCACHE_DIR="$GITHUB_WORKSPACE/ccache"
diff --git a/include/fc/log/logger.hpp b/include/fc/log/logger.hpp
@@ -164,29 +164,29 @@ namespace fc
 //      as a quick-fix / workaround, we catch all exceptions here.
 //      However, to log as much info as possible, it's better to catch exceptions when processing each argument
 #define idump( SEQ ) \
-{ \
+do { \
    try { \
       ilog( FC_FORMAT(SEQ), FC_FORMAT_ARG_PARAMS(SEQ) ); \
    } catch( ... ) { \
       ilog ( "[ERROR: Got exception while trying to dump ( ${args} )]",("args",FC_DUMP_FORMAT_ARG_NAMES(SEQ)) ); \
    } \
-}
+} while( false )
 #define wdump( SEQ ) \
-{ \
+do { \
    try { \
       wlog( FC_FORMAT(SEQ), FC_FORMAT_ARG_PARAMS(SEQ) ); \
    } catch( ... ) { \
       wlog ( "[ERROR: Got exception while trying to dump ( ${args} )]",("args",FC_DUMP_FORMAT_ARG_NAMES(SEQ)) ); \
    } \
-}
+} while( false )
 #define edump( SEQ ) \
-{ \
+do { \
    try { \
       elog( FC_FORMAT(SEQ), FC_FORMAT_ARG_PARAMS(SEQ) ); \
    } catch( ... ) { \
       elog ( "[ERROR: Got exception while trying to dump ( ${args} )]",("args",FC_DUMP_FORMAT_ARG_NAMES(SEQ)) ); \
    } \
-}
+} while( false )
 
 // this disables all normal logging statements -- not something you'd normally want to do,
 // but it's useful if you're benchmarking something and suspect logging is causing
diff --git a/include/fc/static_variant.hpp b/include/fc/static_variant.hpp
@@ -74,8 +74,10 @@ class static_variant {
 
     void init_from_tag(tag_type tag)
     {
-        FC_ASSERT( tag >= 0 );
-        FC_ASSERT( static_cast<size_t>(tag) < count() );
+        FC_ASSERT( tag >= 0, "Unable to init with a negative tag '${tag}'", ("tag",tag) );
+        FC_ASSERT( static_cast<size_t>(tag) < count(),
+                   "Unable to init with tag '${tag}' when the number of supported tags is ${count}",
+                   ("tag",tag) ("count",count()) );
         _tag = tag;
         typelist::runtime::dispatch(list(), tag, [this](auto t) {
             using T = typename decltype(t)::type;
@@ -235,15 +237,19 @@ class static_variant {
         if(_tag == typelist::index_of<list, X>()) {
             return *reinterpret_cast<X*>(storage.data());
         } else {
-            FC_THROW_EXCEPTION( fc::assert_exception, "static_variant does not contain a value of type ${t}", ("t",fc::get_typename<X>::name()) );
+            FC_THROW_EXCEPTION( fc::assert_exception,
+                                "static_variant does not contain a value of type ${t}",
+                                ("t",fc::get_typename<X>::name()) );
         }
     }
     template<typename X, typename = type_in_typelist<X>>
     const X& get() const {
         if(_tag == typelist::index_of<list, X>()) {
             return *reinterpret_cast<const X*>(storage.data());
         } else {
-            FC_THROW_EXCEPTION( fc::assert_exception, "static_variant does not contain a value of type ${t}", ("t",fc::get_typename<X>::name()) );
+            FC_THROW_EXCEPTION( fc::assert_exception,
+                                "static_variant does not contain a value of type ${t}",
+                                ("t",fc::get_typename<X>::name()) );
         }
     }
     template<typename visitor>
@@ -269,7 +275,9 @@ class static_variant {
     template<typename visitor>
     static typename visitor::result_type visit( tag_type tag, visitor& v, void* data )
     {
-        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(), "Unsupported type ${tag}!", ("tag",tag) );
+        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(),
+                   "Unsupported type '${tag}', the number of supported types is ${count}! ",
+                   ("tag",tag) ("count",count()) );
         return typelist::runtime::dispatch(list(), tag, [&v, data](auto t) {
             return v(*reinterpret_cast<typename decltype(t)::type*>(data));
         });
@@ -278,7 +286,9 @@ class static_variant {
     template<typename visitor>
     static typename visitor::result_type visit( tag_type tag, const visitor& v, void* data )
     {
-        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(), "Unsupported type ${tag}!", ("tag",tag) );
+        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(),
+                   "Unsupported type '${tag}', the number of supported types is ${count}! ",
+                   ("tag",tag) ("count",count()) );
         return typelist::runtime::dispatch(list(), tag, [&v, data](auto t) {
             return v(*reinterpret_cast<typename decltype(t)::type*>(data));
         });
@@ -287,7 +297,9 @@ class static_variant {
     template<typename visitor>
     static typename visitor::result_type visit( tag_type tag, visitor& v, const void* data )
     {
-        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(), "Unsupported type ${tag}!", ("tag",tag) );
+        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(),
+                   "Unsupported type '${tag}', the number of supported types is ${count}! ",
+                   ("tag",tag) ("count",count()) );
         return typelist::runtime::dispatch(list(), tag, [&v, data](auto t) {
             return v(*reinterpret_cast<const typename decltype(t)::type*>(data));
         });
@@ -296,16 +308,20 @@ class static_variant {
     template<typename visitor>
     static typename visitor::result_type visit( tag_type tag, const visitor& v, const void* data )
     {
-        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(), "Unsupported type ${tag}!", ("tag",tag) );
+        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(),
+                   "Unsupported type '${tag}', the number of supported types is ${count}! ",
+                   ("tag",tag) ("count",count()) );
         return typelist::runtime::dispatch(list(), tag, [&v, data](auto t) {
             return v(*reinterpret_cast<const typename decltype(t)::type*>(data));
         });
     }
 
     static constexpr size_t count() { return typelist::length<list>(); }
     void set_which( tag_type tag ) {
-      FC_ASSERT( tag >= 0 );
-      FC_ASSERT( static_cast<size_t>(tag) < count() );
+      FC_ASSERT( tag >= 0, "Unable to set a negative tag '${tag}'", ("tag",tag) );
+      FC_ASSERT( static_cast<size_t>(tag) < count(),
+                 "Unable to set tag '${tag}' when the number of supported tags is ${count}",
+                 ("tag",tag) ("count",count()) );
       clean();
       init_from_tag(tag);
     }
