diff --git a/include/etl/basic_string.h b/include/etl/basic_string.h
index d98adf1b..7232a6d0 100644
--- a/include/etl/basic_string.h
+++ b/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;
diff --git a/include/etl/generators/message_router_generator.h b/include/etl/generators/message_router_generator.h
index a1c38d78..868a51ab 100644
--- a/include/etl/generators/message_router_generator.h
+++ b/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("")
diff --git a/include/etl/memory.h b/include/etl/memory.h
index ffe7b7ef..57b89879 100644
--- a/include/etl/memory.h
+++ b/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),
diff --git a/include/etl/message_router.h b/include/etl/message_router.h
index d3c1053f..cc6ea40c 100644
--- a/include/etl/message_router.h
+++ b/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"
       }
     }
 
diff --git a/include/etl/private/chrono/month_weekday.h b/include/etl/private/chrono/month_weekday.h
index 9e05692d..89ac6566 100644
--- a/include/etl/private/chrono/month_weekday.h
+++ b/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 + sizeof(a), &b, sizeof(b));
-      memcpy(buffer + sizeof(b), &b, sizeof(c));
+      memcpy(buffer,                         &a, sizeof(a));
+      memcpy(buffer + sizeof(a),             &b, sizeof(b));
+      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));
     }
diff --git a/include/etl/private/diagnostic_stringop_overflow_push.h b/include/etl/private/diagnostic_stringop_overflow_push.h
new file mode 100644
index 00000000..ee258eef
--- /dev/null
+++ b/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
diff --git a/include/etl/rounded_integral_division.h b/include/etl/rounded_integral_division.h
index 417b3143..4547fc01 100644
--- a/include/etl/rounded_integral_division.h
+++ b/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;
-    }
-    else if ((abs_remainderainder * 2) > abs_denominator)
-    {
-      return quotient + direction;
+      // Even denominator: can be exactly half.
+      if (abs_remainder < half_denominator)
+      {
+        return quotient;
+      }
+      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
-      return (quotient & 1) == 0 ? quotient : quotient + direction;
+      // Odd denominator: no exact half case.
+      return (abs_remainder <= half_denominator) ? quotient : (quotient + direction);
     }
   }
 
diff --git a/test/test_base64_RFC2152_decoder.cpp b/test/test_base64_RFC2152_decoder.cpp
index 66642b83..af6e1a87 100644
--- a/test/test_base64_RFC2152_decoder.cpp
+++ b/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
     }
diff --git a/test/test_base64_RFC3501_decoder.cpp b/test/test_base64_RFC3501_decoder.cpp
index 1c5e14e6..0e750518 100644
--- a/test/test_base64_RFC3501_decoder.cpp
+++ b/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
     }
diff --git a/test/test_base64_RFC4648_URL_decoder_with_no_padding.cpp b/test/test_base64_RFC4648_URL_decoder_with_no_padding.cpp
index 216cde1b..b2d3c01b 100644
--- a/test/test_base64_RFC4648_URL_decoder_with_no_padding.cpp
+++ b/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
     }
diff --git a/test/test_base64_RFC4648_URL_decoder_with_padding.cpp b/test/test_base64_RFC4648_URL_decoder_with_padding.cpp
index 990b6613..77c990a3 100644
--- a/test/test_base64_RFC4648_URL_decoder_with_padding.cpp
+++ b/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
     }
diff --git a/test/test_base64_RFC4648_decoder_with_no_padding.cpp b/test/test_base64_RFC4648_decoder_with_no_padding.cpp
index dddfd0eb..a87852f3 100644
--- a/test/test_base64_RFC4648_decoder_with_no_padding.cpp
+++ b/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
     }
diff --git a/test/test_base64_RFC4648_decoder_with_padding.cpp b/test/test_base64_RFC4648_decoder_with_padding.cpp
index 0b05fb9d..41e0a2ff 100644
--- a/test/test_base64_RFC4648_decoder_with_padding.cpp
+++ b/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
     }
diff --git a/test/test_multi_span.cpp b/test/test_multi_span.cpp
index 2c150e35..0ae70810 100644
--- a/test/test_multi_span.cpp
+++ b/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)
         {
diff --git a/test/test_rounded_integral_division.cpp b/test/test_rounded_integral_division.cpp
index 608d39df..40b709fa 100644
--- a/test/test_rounded_integral_division.cpp
+++ b/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()));
     }
 
     //*************************************************************************
diff --git a/test/test_string_char.cpp b/test/test_string_char.cpp
index faa28d7e..1294bbb9 100644
--- a/test/test_string_char.cpp
+++ b/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"
     }
 
     //*************************************************************************
diff --git a/test/unit_test_framework.h b/test/unit_test_framework.h
index 798a6eae..f5d33b92 100644
--- a/test/unit_test_framework.h
+++ b/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