Bugfixes for compile errors in optimized tests (#1235)

* Fix optimized tests by suppressing warning from STL

* Fix uninitialized buffer in hash for month_weekday

* Fix overlapping memcpy with memmove

* Fix random out of bounds index in __builtin_memmove

Suppressing compiler warning

* Fix array bounds warnings from static casts in message_router

In compiled code, casting to wrong message types is generated,
even though the code paths are supposed to be never taken due to runtime
msg id checks. Therefore, the warnings can be suppressed.

* Fix syntax errors in base64 decoder tests

* Fix test failure in test_rounded_integral_division.cpp when optimized

When building tests optimized, test_round_to_half_even_signed_limits
fails due to the fact that

etl::absolute(std::numeric_limits<int32_t>::min()) < 0

include/etl/basic_string.h

@@ -2601,7 +2601,7 @@ namespace etl
         etl::mem_copy(s, insert_length, &p_buffer[remove_index]);
 
         // Move tail left.
-        etl::mem_copy(&p_buffer[tail_index], tail_length, &p_buffer[remove_index + insert_length]);
+        etl::mem_move(&p_buffer[tail_index], tail_length, &p_buffer[remove_index + insert_length]);
       }
 
       current_size = remove_index + insert_length + tail_length;

include/etl/generators/message_router_generator.h

@@ -465,7 +465,9 @@ namespace etl
         }
         else
         {
+#include "etl/private/diagnostic_array_bounds_push.h"
           static_cast<TDerived*>(this)->on_receive_unknown(msg);
+#include "etl/private/diagnostic_pop.h"
         }
       }
     }
@@ -473,6 +475,7 @@ namespace etl
     template <typename TMessage, typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value, int>::type = 0>
     void receive(const TMessage& msg)
     {
+#include "etl/private/diagnostic_array_bounds_push.h"
       if constexpr (etl::is_one_of<TMessage, TMessageTypes...>::value)
       {
         static_cast<TDerived*>(this)->on_receive(msg);
@@ -488,6 +491,7 @@ namespace etl
           static_cast<TDerived*>(this)->on_receive_unknown(msg);
         }
       }
+#include "etl/private/diagnostic_pop.h"
     }
 
     //**********************************************
@@ -524,7 +528,9 @@ namespace etl
     {
       if (TMessage::ID == msg.get_message_id())
       {
+#include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive(static_cast<const TMessage&>(msg));
+#include "etl/private/diagnostic_pop.h"
         return true;
       }
       else
@@ -618,6 +624,7 @@ namespace etl
       cog.outl("  {")
       cog.outl("    const etl::message_id_t id = msg.get_message_id();")
       cog.outl("")
+      cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
       cog.outl("    switch (id)")
       cog.outl("    {")
       for n in range(1, int(Handlers) + 1):
@@ -637,6 +644,7 @@ namespace etl
       cog.outl("         break;")
       cog.outl("      }")
       cog.outl("    }")
+      cog.outl("#include \"etl/private/diagnostic_pop.h\"")
       cog.outl("  }")
       cog.outl("")
       cog.outl("  template <typename TMessage>")
@@ -646,7 +654,9 @@ namespace etl
       cog.outl("T%s>::value, void>::type" % int(Handlers))
       cog.outl("    receive(const TMessage& msg)")
       cog.outl("  {")
+      cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
       cog.outl("    static_cast<TDerived*>(this)->on_receive(msg);")
+      cog.outl("#include \"etl/private/diagnostic_pop.h\"")
       cog.outl("  }")
       cog.outl("")
       cog.outl("  template <typename TMessage>")
@@ -662,7 +672,9 @@ namespace etl
       cog.outl("    }")
       cog.outl("    else")
       cog.outl("    {")
+      cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
       cog.outl("      static_cast<TDerived*>(this)->on_receive_unknown(msg);")
+      cog.outl("#include \"etl/private/diagnostic_pop.h\"")
       cog.outl("    }")
       cog.outl("  }")
       cog.outl("")
@@ -786,6 +798,7 @@ namespace etl
           cog.outl("  {")
           cog.outl("    const size_t id = msg.get_message_id();")
           cog.outl("")
+          cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
           cog.outl("    switch (id)")
           cog.outl("    {")
           for t in range(1, n + 1):
@@ -805,6 +818,7 @@ namespace etl
           cog.outl("         break;")
           cog.outl("      }")
           cog.outl("    }")
+          cog.outl("#include \"etl/private/diagnostic_pop.h\"")
           cog.outl("  }")
           cog.outl("")
           cog.outl("  template <typename TMessage>")
@@ -814,7 +828,9 @@ namespace etl
           cog.outl("T%s>::value, void>::type" % n)
           cog.outl("    receive(const TMessage& msg)")
           cog.outl("  {")
+          cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
           cog.outl("    static_cast<TDerived*>(this)->on_receive(msg);")
+          cog.outl("#include \"etl/private/diagnostic_pop.h\"")
           cog.outl("  }")
           cog.outl("")
           cog.outl("  template <typename TMessage>")
@@ -830,7 +846,9 @@ namespace etl
           cog.outl("    }")
           cog.outl("    else")
           cog.outl("    {")
+          cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
           cog.outl("      static_cast<TDerived*>(this)->on_receive_unknown(msg);")
+          cog.outl("#include \"etl/private/diagnostic_pop.h\"")
           cog.outl("    }")
           cog.outl("  }")
           cog.outl("")

include/etl/memory.h

@@ -2366,9 +2366,13 @@ namespace etl
     ETL_STATIC_ASSERT(etl::is_trivially_copyable<T>::value, "Cannot mem_move a non trivially copyable type");
 
 #if ETL_USING_BUILTIN_MEMMOVE
+#include "etl/private/diagnostic_array_bounds_push.h"
+#include "etl/private/diagnostic_stringop_overread_push.h"
     __builtin_memmove(reinterpret_cast<void*>(db),
                       reinterpret_cast<const void*>(sb),
                       sizeof(T) * n);
+#include "etl/private/diagnostic_pop.h"
+#include "etl/private/diagnostic_pop.h"
 #else
     ::memmove(reinterpret_cast<void*>(db),
               reinterpret_cast<const void*>(sb),

include/etl/message_router.h

@@ -453,7 +453,9 @@ namespace etl
         }
         else
         {
+#include "etl/private/diagnostic_array_bounds_push.h"
           static_cast<TDerived*>(this)->on_receive_unknown(msg);
+#include "etl/private/diagnostic_pop.h"
         }
       }
     }
@@ -461,6 +463,7 @@ namespace etl
     template <typename TMessage, typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value, int>::type = 0>
     void receive(const TMessage& msg)
     {
+#include "etl/private/diagnostic_array_bounds_push.h"
       if constexpr (etl::is_one_of<TMessage, TMessageTypes...>::value)
       {
         static_cast<TDerived*>(this)->on_receive(msg);
@@ -476,6 +479,7 @@ namespace etl
           static_cast<TDerived*>(this)->on_receive_unknown(msg);
         }
       }
+#include "etl/private/diagnostic_pop.h"
     }
 
     //**********************************************
@@ -512,7 +516,9 @@ namespace etl
     {
       if (TMessage::ID == msg.get_message_id())
       {
+#include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive(static_cast<const TMessage&>(msg));
+#include "etl/private/diagnostic_pop.h"
         return true;
       }
       else
@@ -593,6 +599,7 @@ namespace etl
     {
       const etl::message_id_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -624,13 +631,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -643,7 +653,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -738,6 +750,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -768,13 +781,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -787,7 +803,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -883,6 +901,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -912,13 +931,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -931,7 +953,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -1027,6 +1051,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1055,13 +1080,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1074,7 +1102,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -1169,6 +1199,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1196,13 +1227,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1215,7 +1249,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -1310,6 +1346,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1336,13 +1373,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1355,7 +1395,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -1450,6 +1492,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1475,13 +1518,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1494,7 +1540,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -1589,6 +1637,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1613,13 +1662,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1632,7 +1684,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -1726,6 +1780,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1749,13 +1804,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1768,7 +1826,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -1862,6 +1922,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1884,13 +1945,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1903,7 +1967,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -1996,6 +2062,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2017,13 +2084,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2036,7 +2106,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -2129,6 +2201,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2149,13 +2222,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2168,7 +2244,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -2260,6 +2338,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2279,13 +2358,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2298,7 +2380,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -2390,6 +2474,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2408,13 +2493,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2427,7 +2515,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -2519,6 +2609,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2536,13 +2627,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2555,7 +2649,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -2647,6 +2743,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
+  #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2663,13 +2760,16 @@ namespace etl
            break;
         }
       }
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1>::value, void>::type
       receive(const TMessage& msg)
     {
+  #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
+  #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2682,7 +2782,9 @@ namespace etl
       }
       else
       {
+  #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
+  #include "etl/private/diagnostic_pop.h"
       }
     }
 

include/etl/private/chrono/month_weekday.h

@@ -186,9 +186,9 @@ namespace etl
 
       uint8_t buffer[sizeof(a) + sizeof(b) + sizeof(c)];
 
-      memcpy(buffer,             &a, sizeof(a));
+      memcpy(buffer,                         &a, sizeof(a));
-      memcpy(buffer + sizeof(a), &b, sizeof(b));
+      memcpy(buffer + sizeof(a),             &b, sizeof(b));
-      memcpy(buffer + sizeof(b), &b, sizeof(c));
+      memcpy(buffer + sizeof(a) + sizeof(b), &c, sizeof(c));
 
       return etl::private_hash::generic_hash<size_t>(buffer, buffer + sizeof(a) + sizeof(b) + sizeof(c));
     }

include/etl/private/diagnostic_stringop_overflow_push.h

@@ -0,0 +1,43 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2023 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+/*
+ * The header include guard has been intentionally omitted.
+ * This file is intended to evaluated multiple times by design.
+ */
+
+#if defined(__GNUC__) && (__GNUC__ >= 11) && !defined(__clang__) && !defined(__llvm__)
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstringop-overflow"
+#endif
+
+#if defined(__clang__) || defined(__llvm__)
+  #pragma clang diagnostic push
+#endif

include/etl/rounded_integral_division.h

@@ -615,22 +615,36 @@ namespace etl
   {
     const T quotient            = numerator / denominator;
     const T remainder           = numerator % denominator;
-    const T abs_denominator     = etl::absolute(denominator);
-    const T abs_remainderainder = etl::absolute(remainder);
     const T direction           = ((numerator >= 0) == (denominator >= 0)) ? 1 : -1;
 
-    if ((abs_remainderainder * 2) < abs_denominator)
+    // Work with magnitudes in unsigned form (avoids abs() overflow for T::min()).
+    typedef typename std::make_unsigned<T>::type utype;
+    const utype abs_denominator = (denominator < 0) ? (utype(0) - utype(denominator)) : utype(denominator);
+    const utype abs_remainder   = (remainder   < 0) ? (utype(0) - utype(remainder))   : utype(remainder);
+    const utype half_denominator = abs_denominator / 2U;
+
+    // Compare without `* 2` to avoid unsigned overflow.
+    if ((abs_denominator & 1U) == 0U)
     {
-      return quotient;
+      // Even denominator: can be exactly half.
-    }
+      if (abs_remainder < half_denominator)
-    else if ((abs_remainderainder * 2) > abs_denominator)
+      {
-    {
+        return quotient;
-      return quotient + direction;
+      }
+      else if (abs_remainder > half_denominator)
+      {
+        return quotient + direction;
+      }
+      else
+      {
+        // Exactly halfway, round to even
+        return (quotient & 1) == 0 ? quotient : quotient + direction;
+      }
     }
     else
     {
-      // Exactly halfway, round to even
+      // Odd denominator: no exact half case.
-      return (quotient & 1) == 0 ? quotient : quotient + direction;
+      return (abs_remainder <= half_denominator) ? quotient : (quotient + direction);
     }
   }
 

test/test_base64_RFC2152_decoder.cpp

@@ -386,8 +386,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -408,8 +410,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -447,8 +451,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -486,8 +492,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -508,8 +516,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -530,8 +540,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -569,8 +581,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -608,8 +622,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -640,8 +656,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -672,8 +690,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -708,8 +728,10 @@ namespace
 
         b64.flush();
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(b64.begin(), b64.end());
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_EQUAL(expected.size(), actual.size());
         CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
@@ -739,8 +761,10 @@ namespace
 
       constexpr auto output{ GetConstexprBase64(input) };
 
+#include "etl/private/diagnostic_null_dereference_push.h"
       std::vector<unsigned char> expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       std::vector<unsigned char> actual(output.begin(), output.end());
+#include "etl/private/diagnostic_pop.h"
 
       CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
       CHECK_TRUE(codec::safe_output_buffer_size(14) >= output.size());
@@ -755,7 +779,7 @@ namespace
 #if ETL_USING_EXCEPTIONS
       CHECK_THROW((b64.decode(encoded[10].data(), encoded[10].size())), etl::base64_overflow);
 #else
-      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size());
+      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size()));
       CHECK_TRUE(b64.error());
 #endif
     }

test/test_base64_RFC3501_decoder.cpp

@@ -383,8 +383,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -405,8 +407,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -444,8 +448,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -483,8 +489,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -505,8 +513,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -527,8 +537,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -566,8 +578,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -605,8 +619,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -637,8 +653,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -669,8 +687,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -705,8 +725,10 @@ namespace
 
         b64.flush();
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(b64.begin(), b64.end());
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_EQUAL(expected.size(), actual.size());
         CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
@@ -736,8 +758,10 @@ namespace
 
       constexpr auto output{ GetConstexprBase64(input) };
 
+#include "etl/private/diagnostic_null_dereference_push.h"
       std::vector<unsigned char> expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       std::vector<unsigned char> actual(output.begin(), output.end());
+#include "etl/private/diagnostic_pop.h"
 
       CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
       CHECK_TRUE(codec::safe_output_buffer_size(14) >= output.size());
@@ -752,7 +776,7 @@ namespace
 #if ETL_USING_EXCEPTIONS
       CHECK_THROW((b64.decode(encoded[10].data(), encoded[10].size())), etl::base64_overflow);
 #else
-      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size());
+      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size()));
       CHECK_TRUE(b64.error());
 #endif
     }

test/test_base64_RFC4648_URL_decoder_with_no_padding.cpp

@@ -383,8 +383,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -405,8 +407,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -444,8 +448,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -483,8 +489,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -505,8 +513,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -527,8 +537,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -566,8 +578,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -605,8 +619,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -637,8 +653,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -669,8 +687,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -705,8 +725,10 @@ namespace
 
         b64.flush();
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(b64.begin(), b64.end());
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_EQUAL(expected.size(), actual.size());
         CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
@@ -736,8 +758,10 @@ namespace
 
       constexpr auto output{ GetConstexprBase64(input) };
 
+#include "etl/private/diagnostic_null_dereference_push.h"
       std::vector<unsigned char> expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       std::vector<unsigned char> actual(output.begin(), output.end());
+#include "etl/private/diagnostic_pop.h"
 
       CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
       CHECK_TRUE(codec::safe_output_buffer_size(14) >= output.size());
@@ -752,7 +776,7 @@ namespace
 #if ETL_USING_EXCEPTIONS
       CHECK_THROW((b64.decode(encoded[10].data(), encoded[10].size())), etl::base64_overflow);
 #else
-      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size());
+      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size()));
       CHECK_TRUE(b64.error());
 #endif
     }

test/test_base64_RFC4648_URL_decoder_with_padding.cpp

@@ -383,8 +383,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -405,8 +407,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -444,8 +448,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -483,8 +489,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -505,8 +513,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -527,8 +537,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -566,8 +578,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -605,8 +619,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -637,8 +653,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -669,8 +687,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -705,8 +725,10 @@ namespace
 
         b64.flush();
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(b64.begin(), b64.end());
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_EQUAL(expected.size(), actual.size());
         CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
@@ -736,8 +758,10 @@ namespace
 
       constexpr auto output{ GetConstexprBase64(input) };
 
+#include "etl/private/diagnostic_null_dereference_push.h"
       std::vector<unsigned char> expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       std::vector<unsigned char> actual(output.begin(), output.end());
+#include "etl/private/diagnostic_pop.h"
 
       CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
       CHECK_TRUE(codec::safe_output_buffer_size(14) >= output.size());
@@ -752,7 +776,7 @@ namespace
 #if ETL_USING_EXCEPTIONS
       CHECK_THROW((b64.decode(encoded[10].data(), encoded[10].size())), etl::base64_overflow);
 #else
-      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size());
+      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size()));
       CHECK_TRUE(b64.error());
 #endif
     }

test/test_base64_RFC4648_decoder_with_no_padding.cpp

@@ -383,8 +383,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -405,8 +407,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -444,8 +448,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -483,8 +489,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -505,8 +513,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -527,8 +537,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -566,8 +578,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -605,8 +619,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -637,8 +653,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -669,8 +687,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -705,8 +725,10 @@ namespace
 
         b64.flush();
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(b64.begin(), b64.end());
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_EQUAL(expected.size(), actual.size());
         CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
@@ -736,8 +758,10 @@ namespace
 
       constexpr auto output{ GetConstexprBase64(input) };
 
+#include "etl/private/diagnostic_null_dereference_push.h"
       std::vector<unsigned char> expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       std::vector<unsigned char> actual(output.begin(), output.end());
+#include "etl/private/diagnostic_pop.h"
 
       CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
       CHECK_TRUE(codec::safe_output_buffer_size(14) >= output.size());
@@ -752,7 +776,7 @@ namespace
 #if ETL_USING_EXCEPTIONS
       CHECK_THROW((b64.decode(encoded[10].data(), encoded[10].size())), etl::base64_overflow);
 #else
-      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size());
+      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size()));
       CHECK_TRUE(b64.error());
 #endif
     }

test/test_base64_RFC4648_decoder_with_padding.cpp

@@ -383,8 +383,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
         
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -405,8 +407,10 @@ namespace
 
         b64.decode_final(encoded[i].data(), encoded[i].size());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -444,8 +448,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -483,8 +489,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -505,8 +513,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -527,8 +537,10 @@ namespace
 
         b64.decode_final(encoded[i].begin(), encoded[i].end());
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -566,8 +578,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -605,8 +619,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -637,8 +653,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -669,8 +687,10 @@ namespace
         b64.flush();
         CHECK_TRUE(received_final_block);
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(decoded_output);
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_TRUE(received_final_block);
         CHECK_EQUAL(expected.size(), actual.size());
@@ -705,8 +725,10 @@ namespace
 
         b64.flush();
 
+#include "etl/private/diagnostic_null_dereference_push.h"
         std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
         std::vector<unsigned char> actual(b64.begin(), b64.end());
+#include "etl/private/diagnostic_pop.h"
 
         CHECK_EQUAL(expected.size(), actual.size());
         CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
@@ -736,8 +758,10 @@ namespace
 
       constexpr auto output{ GetConstexprBase64(input) };
 
+#include "etl/private/diagnostic_null_dereference_push.h"
       std::vector<unsigned char> expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       std::vector<unsigned char> actual(output.begin(), output.end());
+#include "etl/private/diagnostic_pop.h"
 
       CHECK_TRUE(std::equal(expected.begin(), expected.end(), actual.begin()));
       CHECK_TRUE(codec::safe_output_buffer_size(14) >= output.size());
@@ -752,7 +776,7 @@ namespace
 #if ETL_USING_EXCEPTIONS
       CHECK_THROW((b64.decode(encoded[10].data(), encoded[10].size())), etl::base64_overflow);
 #else
-      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size());
+      CHECK_FALSE(b64.decode(encoded[10].data(), encoded[10].size()));
       CHECK_TRUE(b64.error());
 #endif
     }

test/test_multi_span.cpp

@@ -557,7 +557,9 @@ namespace
       while (ms_itr != ms_end_itr)
       {
         //  Fill the multi span
+#include "etl/private/diagnostic_null_dereference_push.h"
         *ms_itr++ = *exp_itr++;
+#include "etl/private/diagnostic_pop.h"
       }
 
       while (ms_itr != ms_end_itr)
@@ -625,7 +627,9 @@ namespace
 
       for (size_t i = 0; i < expected.size(); ++i)
       {
+#include "etl/private/diagnostic_null_dereference_push.h"
         *ms_itr = *exp_itr;
+#include "etl/private/diagnostic_pop.h"
 
         if (i < expected.size() - 1)
         {

test/test_rounded_integral_division.cpp

@@ -732,7 +732,8 @@ namespace
       CHECK_EQUAL(std::numeric_limits<int32_t>::max(), etl::divide_round_half_even(std::numeric_limits<int32_t>::max(), int32_t(1)));
       CHECK_EQUAL(int32_t(0),                          etl::divide_round_half_even(int32_t(1),                          std::numeric_limits<int32_t>::max()));
       CHECK_EQUAL(std::numeric_limits<int32_t>::min(), etl::divide_round_half_even(std::numeric_limits<int32_t>::min(), int32_t(1)));
-      CHECK_EQUAL(int32_t(-1),                         etl::divide_round_half_even(int32_t(1),                          std::numeric_limits<int32_t>::min()));
+      CHECK_EQUAL(int32_t(0),                          etl::divide_round_half_even(int32_t(1),                          std::numeric_limits<int32_t>::min()));
+      CHECK_EQUAL(int32_t(1),                          etl::divide_round_half_even(std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::min()));
     }
 
     //*************************************************************************

test/test_string_char.cpp

@@ -1556,7 +1556,9 @@ namespace
 
       Text text2;
 
+#include "etl/private/diagnostic_stringop_overflow_push.h"
       CHECK_THROW(text.insert(text2.cbegin(), insert_text.cbegin(), insert_text.cend()), etl::string_out_of_bounds);
+#include "etl/private/diagnostic_pop.h"
     }
 
     //*************************************************************************

test/unit_test_framework.h

@@ -29,6 +29,8 @@ SOFTWARE.
 #ifndef ETL_UNIT_TEST_FRAMEWORK_INCLUDED
 #define ETL_UNIT_TEST_FRAMEWORK_INCLUDED
 
+#include "etl/private/diagnostic_null_dereference_push.h"
 #include "UnitTest++/UnitTest++.h"
+#include "etl/private/diagnostic_pop.h"
 
 #endif