diff --git a/.gitignore b/.gitignore
index 5c8a2e4c..4f2b0c76 100644
--- a/.gitignore
+++ b/.gitignore
@@ -379,3 +379,7 @@ test/vs2022/Debug MSVC - No STL - Force Built-ins
 test/temp
 test/vs2022/Debug MSVC C++14
 test/vs2022/Debug MSVC C++20 - No STL
+build-test-Desktop_x86_windows_msvc2019_pe_64bit-Debug
+test/vs2022/Debug MSVC C++14 - No STL
+test/log.txt
+test/etl_error_handler/log.txt
diff --git a/include/etl/array.h b/include/etl/array.h
index 1435ddbb..1f1195db 100644
--- a/include/etl/array.h
+++ b/include/etl/array.h
@@ -236,7 +236,7 @@ namespace etl
     //*************************************************************************
     iterator end() ETL_NOEXCEPT
     {
-      return &_buffer[SIZE];
+      return _buffer + SIZE;
     }
 
     //*************************************************************************
@@ -244,7 +244,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR const_iterator end() const ETL_NOEXCEPT
     {
-      return &_buffer[SIZE];
+      return _buffer + SIZE;
     }
 
     //*************************************************************************
@@ -252,7 +252,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR const_iterator cend() const ETL_NOEXCEPT
     {
-      return &_buffer[SIZE];
+      return _buffer + SIZE;
     }
 
     //*************************************************************************
diff --git a/include/etl/array_view.h b/include/etl/array_view.h
index 84ceeeab..44fbd5a1 100644
--- a/include/etl/array_view.h
+++ b/include/etl/array_view.h
@@ -636,8 +636,8 @@ namespace etl
   {
     size_t operator()(const etl::array_view<T>& view) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&view[0]),
-                                                     reinterpret_cast<const uint8_t*>(&view[view.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(view.data()),
+                                                     reinterpret_cast<const uint8_t*>(view.data() + view.size()));
     }
   };
 #endif
diff --git a/include/etl/array_wrapper.h b/include/etl/array_wrapper.h
index ddb4a5fe..45d45f1b 100644
--- a/include/etl/array_wrapper.h
+++ b/include/etl/array_wrapper.h
@@ -394,8 +394,10 @@ namespace etl
   {
     size_t operator()(const etl::array_wrapper<T, SIZE, ARRAY>& aw) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&aw[0]),
-                                                         reinterpret_cast<const uint8_t*>(&aw[aw.size()]));
+      const uint8_t* pb = reinterpret_cast<const uint8_t*>(aw.data());
+      const uint8_t* pe = pb + (SIZE * sizeof(T));
+
+      return etl::private_hash::generic_hash<size_t>(pb, pe);
     }
   };
 #endif
diff --git a/include/etl/basic_string.h b/include/etl/basic_string.h
index 66489078..f2a1a1c3 100644
--- a/include/etl/basic_string.h
+++ b/include/etl/basic_string.h
@@ -136,21 +136,39 @@ namespace etl
   ///\ingroup string
   /// The base class for all templated string types.
   //***************************************************************************
-  class string_base
+  namespace private_basic_string
+  {
+    //*************************************************************************
+    template <typename T = void>
+    class string_base_statics
+    {
+    public:
+
+      typedef size_t size_type;
+
+      static ETL_CONSTANT uint_least8_t IS_TRUNCATED    = etl::bit<0>::value;
+      static ETL_CONSTANT uint_least8_t CLEAR_AFTER_USE = etl::bit<1>::value;
+      
+      static ETL_CONSTANT size_type npos = etl::integral_limits<size_type>::max;
+    };
+
+    template <typename T>
+    ETL_CONSTANT uint_least8_t string_base_statics<T>::IS_TRUNCATED;
+
+    template <typename T>
+    ETL_CONSTANT uint_least8_t string_base_statics<T>::CLEAR_AFTER_USE;
+
+    template <typename T>
+    ETL_CONSTANT typename string_base_statics<T>::size_type string_base_statics<T>::npos;
+  }
+
+  //***************************************************************************
+  class string_base : public private_basic_string::string_base_statics<>
   {
   public:
 
     typedef size_t size_type;
 
-#if ETL_USING_CPP11
-    static constexpr size_type npos = etl::integral_limits<size_type>::max;
-#else
-    enum
-    {
-      npos = etl::integral_limits<size_type>::max
-    };
-#endif
-
     //*************************************************************************
     /// Gets the current size of the string.
     ///\return The current size of the string.
@@ -290,9 +308,6 @@ namespace etl
     {
     }
 
-    static ETL_CONSTANT uint_least8_t IS_TRUNCATED    = etl::bit<0>::value;
-    static ETL_CONSTANT uint_least8_t CLEAR_AFTER_USE = etl::bit<1>::value;
-
     size_type       current_size;   ///< The current number of elements in the string.
     const size_type CAPACITY;       ///< The maximum number of elements in the string.
 
diff --git a/include/etl/binary.h b/include/etl/binary.h
index 5d5a6128..ad478015 100644
--- a/include/etl/binary.h
+++ b/include/etl/binary.h
@@ -96,8 +96,8 @@ namespace etl
   template <>
   struct max_value_for_nbits<0>
   {
-      typedef etl::smallest_uint_for_bits<0>::type value_type;
-      static ETL_CONSTANT value_type value = 0;
+    typedef etl::smallest_uint_for_bits<0>::type value_type;
+    static ETL_CONSTANT value_type value = 0;
   };
 
   template <const size_t NBITS>
@@ -544,6 +544,9 @@ namespace etl
     static ETL_CONSTANT uint8_t value = uint8_t((value2 >> 4U) | ((value2 & 0x0FU) << 4U));
   };
 
+  template <uint8_t Value>
+  ETL_CONSTANT uint8_t reverse_bits_const<uint8_t, Value>::value;
+
   //***********************************
   template <int8_t Value>
   struct reverse_bits_const<int8_t, Value>
@@ -557,6 +560,9 @@ namespace etl
 
     static ETL_CONSTANT int8_t value = int8_t((value2 >> 4U) | ((value2 & 0x0FU) << 4U));
   };
+
+  template <int8_t Value>
+  ETL_CONSTANT int8_t reverse_bits_const<int8_t, Value>::value;
 #endif
 
   //***************************************************************************
@@ -591,6 +597,9 @@ namespace etl
     static ETL_CONSTANT uint16_t value = uint16_t((value3 >> 8U) | ((value3 & 0xFFU) << 8U));
   };
 
+  template <uint16_t Value>
+  ETL_CONSTANT uint16_t reverse_bits_const<uint16_t, Value>::value;
+
   //***********************************
   template <int16_t Value>
   struct reverse_bits_const<int16_t, Value>
@@ -606,6 +615,9 @@ namespace etl
     static ETL_CONSTANT int16_t value = int16_t((value3 >> 8U) | ((value3 & 0xFFU) << 8U));
   };
 
+  template <int16_t Value>
+  ETL_CONSTANT int16_t reverse_bits_const<int16_t, Value>::value;
+
   //***************************************************************************
   /// Reverse 32 bits.
   ///\ingroup binary
@@ -640,6 +652,9 @@ namespace etl
     static ETL_CONSTANT uint32_t value = uint32_t((value4 >> 16U) | ((value4 & 0xFFFFU) << 16U));
   };
 
+  template <uint32_t Value>
+  ETL_CONSTANT uint32_t reverse_bits_const<uint32_t, Value>::value;
+
   //***********************************
   template <int32_t Value>
   struct reverse_bits_const<int32_t, Value>
@@ -656,6 +671,9 @@ namespace etl
     static ETL_CONSTANT int32_t value = int32_t((value4 >> 16U) | ((value4 & 0xFFFFUL) << 16U));
   };
 
+  template <int32_t Value>
+  ETL_CONSTANT int32_t reverse_bits_const<int32_t, Value>::value;
+
 #if ETL_USING_64BIT_TYPES
   //***************************************************************************
   /// Reverse 64 bits.
@@ -693,6 +711,9 @@ namespace etl
     static ETL_CONSTANT uint64_t value = uint64_t((value5 >> 32U) | ((value5 & 0xFFFFFFFFULL) << 32U));
   };
 
+  template <uint64_t Value>
+  ETL_CONSTANT uint64_t reverse_bits_const<uint64_t, Value>::value;
+
   //***********************************
   template <int64_t Value>
   struct reverse_bits_const<int64_t, Value>
@@ -709,6 +730,9 @@ namespace etl
 
     static ETL_CONSTANT int64_t value = int64_t((value5 >> 32U) | ((value5 & 0xFFFFFFFFULL) << 32U));
   };
+
+  template <int64_t Value>
+  ETL_CONSTANT int64_t reverse_bits_const<int64_t, Value>::value;
 #endif
 
   //***************************************************************************
@@ -2190,6 +2214,9 @@ namespace etl
     static ETL_CONSTANT T value = static_cast<T>(etl::max_value_for_nbits<NBits>::value);
   };
 
+  template <typename T, size_t NBits>
+  ETL_CONSTANT T lsb_mask<T, NBits>::value;
+
   //***********************************
   template <typename T>
   ETL_CONSTEXPR14 T make_lsb_mask(size_t nbits)
@@ -2209,6 +2236,9 @@ namespace etl
     static ETL_CONSTANT T value = static_cast<T>(etl::reverse_bits_const<T, lsb_mask<T, NBits>::value>::value);
   };
 
+  template <typename T, size_t NBits>
+  ETL_CONSTANT T msb_mask<T, NBits>::value;
+
   //***********************************
   template <typename T>
   ETL_CONSTEXPR T make_msb_mask(size_t nbits)
diff --git a/include/etl/bip_buffer_spsc_atomic.h b/include/etl/bip_buffer_spsc_atomic.h
index 6b67ae4b..51d54612 100644
--- a/include/etl/bip_buffer_spsc_atomic.h
+++ b/include/etl/bip_buffer_spsc_atomic.h
@@ -526,11 +526,14 @@ namespace etl
       base_t::clear();
     }
 
-  private:
+  private: 
 
     /// The uninitialised buffer of T used in the bip_buffer_spsc.
     etl::uninitialized_buffer_of<T, RESERVED_SIZE> buffer;
   };
+
+  template <typename T, const size_t SIZE, const size_t MEMORY_MODEL> 
+  ETL_CONSTANT typename bip_buffer_spsc_atomic<T, SIZE, MEMORY_MODEL>::size_type bip_buffer_spsc_atomic<T, SIZE, MEMORY_MODEL>::RESERVED_SIZE;
 }
 
 #endif /* ETL_HAS_ATOMIC && ETL_USING_CPP11 */
diff --git a/include/etl/buffer_descriptors.h b/include/etl/buffer_descriptors.h
index 1bd98443..b34e223b 100644
--- a/include/etl/buffer_descriptors.h
+++ b/include/etl/buffer_descriptors.h
@@ -290,6 +290,15 @@ namespace etl
     etl::array<descriptor_item, N_BUFFERS> descriptor_items;
     etl::cyclic_value<uint_least8_t, 0U, N_BUFFERS - 1> next;
   };
+
+  template <typename TBuffer, size_t BUFFER_SIZE_, size_t N_BUFFERS_, typename TFlag>
+  ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::N_BUFFERS;
+
+  template <typename TBuffer, size_t BUFFER_SIZE_, size_t N_BUFFERS_, typename TFlag>
+  ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::BUFFER_SIZE;
+  
+  template <typename TBuffer, size_t BUFFER_SIZE_, size_t N_BUFFERS_, typename TFlag>
+  ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::descriptor::MAX_SIZE;
 }
 #endif
 #endif
diff --git a/include/etl/circular_buffer.h b/include/etl/circular_buffer.h
index 84126f1b..aa7eff18 100644
--- a/include/etl/circular_buffer.h
+++ b/include/etl/circular_buffer.h
@@ -1226,6 +1226,9 @@ namespace etl
     etl::uninitialized_buffer_of<T, MAX_SIZE + 1> buffer;
   };
 
+  template <typename T, size_t MAX_SIZE_>
+  ETL_CONSTANT typename icircular_buffer<T>::size_type circular_buffer<T, MAX_SIZE_>::MAX_SIZE;
+
   //***************************************************************************
   /// A fixed capacity circular buffer.
   /// External buffer.
diff --git a/include/etl/combinations.h b/include/etl/combinations.h
index 9fbb8654..dbb5c224 100644
--- a/include/etl/combinations.h
+++ b/include/etl/combinations.h
@@ -51,6 +51,9 @@ namespace etl
     static ETL_CONSTANT size_t value = etl::permutations<NV, KV>::value / etl::factorial<KV>::value;
   };
 
+  template <const size_t NV, const size_t KV>
+  ETL_CONSTANT size_t combinations<NV, KV>::value;
+
 #if ETL_USING_CPP17
   template <size_t NV, size_t KV>
   inline constexpr size_t combinations_v = combinations<NV, KV>::value;
diff --git a/include/etl/correlation.h b/include/etl/correlation.h
index a1408424..47bfec41 100644
--- a/include/etl/correlation.h
+++ b/include/etl/correlation.h
@@ -73,10 +73,24 @@ namespace etl
   //***************************************************************************
   /// Correlation Type.
   //***************************************************************************
-  struct correlation_type
+  namespace private_correlation
+  {
+    template<typename T = void>
+    struct correlation_type_statics
+    {
+      static ETL_CONSTANT bool Sample     = false;
+      static ETL_CONSTANT bool Population = true;
+    };
+
+    template<typename T>
+    ETL_CONSTANT bool correlation_type_statics<T>::Sample;
+
+    template<typename T>
+    ETL_CONSTANT bool correlation_type_statics<T>::Population;
+  }
+
+  struct correlation_type : public private_correlation::correlation_type_statics<>
   {
-    static ETL_CONSTANT bool Sample     = false;
-    static ETL_CONSTANT bool Population = true;
   };
 
   //***************************************************************************
@@ -270,6 +284,9 @@ namespace etl
     mutable double correlation_value;
     mutable bool   recalculate;
   };
+
+  template <bool Correlation_Type, typename TInput, typename TCalc>
+  ETL_CONSTANT int correlation<Correlation_Type, TInput, TCalc>::Adjustment;
 }
 
 #endif
diff --git a/include/etl/covariance.h b/include/etl/covariance.h
index e0ba59ee..8ecd8027 100644
--- a/include/etl/covariance.h
+++ b/include/etl/covariance.h
@@ -73,10 +73,24 @@ namespace etl
   //***************************************************************************
   /// Covariance Type.
   //***************************************************************************
-  struct covariance_type
+  namespace private_covariance
+  {
+    template<typename T = void>
+    struct covariance_type_statics
+    {
+      static ETL_CONSTANT bool Sample = false;
+      static ETL_CONSTANT bool Population = true;
+    };
+
+    template<typename T>
+    ETL_CONSTANT bool covariance_type_statics<T>::Sample;
+    
+    template<typename T>
+    ETL_CONSTANT bool covariance_type_statics<T>::Population;
+  }
+
+  struct covariance_type : public private_covariance::covariance_type_statics<>
   {
-    static ETL_CONSTANT bool Sample     = false;
-    static ETL_CONSTANT bool Population = true;
   };
 
   //***************************************************************************
@@ -219,6 +233,9 @@ namespace etl
     mutable double covariance_value;
     mutable bool   recalculate;
   };
+
+  template <bool Covariance_Type, typename TInput, typename TCalc>
+  ETL_CONSTANT int covariance<Covariance_Type, TInput, TCalc>::Adjustment;
 }
 
 #endif
diff --git a/include/etl/deque.h b/include/etl/deque.h
index aa075ac7..3406ae00 100644
--- a/include/etl/deque.h
+++ b/include/etl/deque.h
@@ -2469,6 +2469,9 @@ namespace etl
     etl::uninitialized_buffer_of<T, BUFFER_SIZE> buffer;
   };
 
+  template <typename T, const size_t MAX_SIZE_>
+  ETL_CONSTANT size_t deque<T, MAX_SIZE_>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/factorial.h b/include/etl/factorial.h
index 43446aa1..cfe421fb 100644
--- a/include/etl/factorial.h
+++ b/include/etl/factorial.h
@@ -61,6 +61,9 @@ namespace etl
     static ETL_CONSTANT size_t value = 1;
   };
 
+  template <size_t N>
+  ETL_CONSTANT size_t factorial<N>::value;
+
 #if ETL_USING_CPP17
   template <size_t N>
   inline constexpr size_t factorial_v = factorial<N>::value;
diff --git a/include/etl/fibonacci.h b/include/etl/fibonacci.h
index 9105f8ad..fb4a0d62 100644
--- a/include/etl/fibonacci.h
+++ b/include/etl/fibonacci.h
@@ -70,6 +70,9 @@ namespace etl
     static ETL_CONSTANT size_t value = 0UL;
   };
 
+  template <size_t N>
+  ETL_CONSTANT size_t fibonacci<N>::value;
+
 #if ETL_USING_CPP17
   template <size_t N>
   inline constexpr size_t fibonacci_v = fibonacci<N>::value;
diff --git a/include/etl/fixed_sized_memory_block_allocator.h b/include/etl/fixed_sized_memory_block_allocator.h
index e48a278a..ad4fac30 100644
--- a/include/etl/fixed_sized_memory_block_allocator.h
+++ b/include/etl/fixed_sized_memory_block_allocator.h
@@ -112,6 +112,15 @@ namespace etl
     /// The generic pool from which allocate memory blocks.
     etl::generic_pool<Block_Size, Alignment, Size> pool;
   };
+
+  template <size_t VBlock_Size, size_t VAlignment, size_t VSize>
+  ETL_CONSTANT size_t fixed_sized_memory_block_allocator<VBlock_Size, VAlignment, VSize>::Block_Size;
+
+  template <size_t VBlock_Size, size_t VAlignment, size_t VSize>
+  ETL_CONSTANT size_t fixed_sized_memory_block_allocator<VBlock_Size, VAlignment, VSize>::Alignment;
+
+  template <size_t VBlock_Size, size_t VAlignment, size_t VSize>
+  ETL_CONSTANT size_t fixed_sized_memory_block_allocator<VBlock_Size, VAlignment, VSize>::Size;
 }
 
 #endif
diff --git a/include/etl/flags.h b/include/etl/flags.h
index 5bdf2aaa..3b49dc6c 100644
--- a/include/etl/flags.h
+++ b/include/etl/flags.h
@@ -349,6 +349,15 @@ namespace etl
     value_type data;
   };
 
+  template <typename T, T MASK>
+  ETL_CONSTANT typename flags<T, MASK>::value_type flags<T, MASK>::ALL_SET;
+
+  template <typename T, T MASK>
+  ETL_CONSTANT typename flags<T, MASK>::value_type flags<T, MASK>::ALL_CLEAR;
+
+  template <typename T, T MASK>
+  ETL_CONSTANT size_t flags<T, MASK>::NBITS;
+
   //***************************************************************************
   /// operator ==
   //***************************************************************************
diff --git a/include/etl/flat_map.h b/include/etl/flat_map.h
index 29bd2cd4..0f8ad3d5 100644
--- a/include/etl/flat_map.h
+++ b/include/etl/flat_map.h
@@ -1158,6 +1158,9 @@ namespace etl
     etl::vector<node_t*, MAX_SIZE> lookup;
   };
 
+  template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t flat_map<TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/flat_multimap.h b/include/etl/flat_multimap.h
index cd3686fb..01c55720 100644
--- a/include/etl/flat_multimap.h
+++ b/include/etl/flat_multimap.h
@@ -206,7 +206,7 @@ namespace etl
     //*********************************************************************
     const_reverse_iterator rend() const
     {
-      refmap_t::rend();
+      return refmap_t::rend();
     }
 
     //*********************************************************************
@@ -1041,6 +1041,9 @@ namespace etl
     etl::vector<node_t*, MAX_SIZE> lookup;
   };
 
+  template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t flat_multimap<TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/flat_multiset.h b/include/etl/flat_multiset.h
index 7d3fdce2..2f35babe 100644
--- a/include/etl/flat_multiset.h
+++ b/include/etl/flat_multiset.h
@@ -995,6 +995,9 @@ namespace etl
     etl::vector<node_t*, MAX_SIZE> lookup;
   };
 
+  template <typename T,const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t flat_multiset<T, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/flat_set.h b/include/etl/flat_set.h
index 05505df9..1a71cbb3 100644
--- a/include/etl/flat_set.h
+++ b/include/etl/flat_set.h
@@ -1082,6 +1082,9 @@ namespace etl
     etl::vector<node_t*, MAX_SIZE> lookup;
   };
 
+  template <typename T, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t flat_set<T, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/forward_list.h b/include/etl/forward_list.h
index 8d1ac9d5..98da9b7e 100644
--- a/include/etl/forward_list.h
+++ b/include/etl/forward_list.h
@@ -1748,6 +1748,9 @@ namespace etl
     etl::pool<typename etl::iforward_list<T>::data_node_t, MAX_SIZE> node_pool;
   };
 
+  template <typename T, const size_t MAX_SIZE_>
+  ETL_CONSTANT size_t forward_list<T, MAX_SIZE_>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/fsm.h b/include/etl/fsm.h
index 5c71795d..0f2eb368 100644
--- a/include/etl/fsm.h
+++ b/include/etl/fsm.h
@@ -169,19 +169,34 @@ namespace etl
     }
   };
 
+  namespace private_fsm
+  {
+    template <typename T = void>
+    class ifsm_state_helper
+    {
+    public:
+
+      // Pass this whenever no state change is desired.
+      // The highest unsigned value of fsm_state_id_t.
+      static ETL_CONSTANT fsm_state_id_t No_State_Change = etl::integral_limits<fsm_state_id_t>::max;
+      // Pass this when this event also needs to be passed to the parent.
+      static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U;
+    };
+
+    template <typename T>
+    ETL_CONSTANT fsm_state_id_t ifsm_state_helper<T>::No_State_Change;
+
+    template <typename T>
+    ETL_CONSTANT fsm_state_id_t ifsm_state_helper<T>::Pass_To_Parent;
+  }
+
   //***************************************************************************
   /// Interface class for FSM states.
   //***************************************************************************
-  class ifsm_state
+  class ifsm_state : public private_fsm::ifsm_state_helper<>
   {
   public:
 
-    // Pass this whenever no state change is desired.
-    // The highest unsigned value of fsm_state_id_t.
-    static ETL_CONSTANT fsm_state_id_t No_State_Change = etl::integral_limits<fsm_state_id_t>::max;
-    // Pass this when this event also needs to be passed to the parent.
-    static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U;
-
     /// Allows ifsm_state functions to be private.
     friend class etl::fsm;
     friend class etl::hfsm;
diff --git a/include/etl/functional.h b/include/etl/functional.h
index 0a4bde46..e6a72ad8 100644
--- a/include/etl/functional.h
+++ b/include/etl/functional.h
@@ -57,6 +57,11 @@ namespace etl
     {
     }
 
+    ETL_CONSTEXPR20 reference_wrapper(const reference_wrapper& rhs) ETL_NOEXCEPT
+      : t(rhs.t)
+    {
+    }
+
     ETL_CONSTEXPR20 reference_wrapper<T>& operator = (const reference_wrapper& rhs) ETL_NOEXCEPT
     {
       t = rhs.t;
diff --git a/include/etl/generators/fsm_generator.h b/include/etl/generators/fsm_generator.h
index c30c8b9c..6d5e945a 100644
--- a/include/etl/generators/fsm_generator.h
+++ b/include/etl/generators/fsm_generator.h
@@ -188,19 +188,35 @@ namespace etl
     }
   };
 
+  namespace private_fsm
+  {
+    template <typename T = void>
+    class ifsm_state_helper
+    {
+    public:
+
+      // Pass this whenever no state change is desired.
+      // The highest unsigned value of fsm_state_id_t.
+      static ETL_CONSTANT fsm_state_id_t No_State_Change = etl::integral_limits<fsm_state_id_t>::max;
+      
+      // Pass this when this event also needs to be passed to the parent.
+      static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U;
+    };
+
+    template <typename T>
+    ETL_CONSTANT fsm_state_id_t ifsm_state_helper<T>::No_State_Change;
+
+    template <typename T>
+    ETL_CONSTANT fsm_state_id_t ifsm_state_helper<T>::Pass_To_Parent;
+  }
+
   //***************************************************************************
   /// Interface class for FSM states.
   //***************************************************************************
-  class ifsm_state
+  class ifsm_state : public private_fsm::ifsm_state_helper<>
   {
   public:
 
-    // Pass this whenever no state change is desired.
-    // The highest unsigned value of fsm_state_id_t.
-    static ETL_CONSTANT fsm_state_id_t No_State_Change = etl::integral_limits<fsm_state_id_t>::max;
-    // Pass this when this event also needs to be passed to the parent.
-    static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U;
-
     /// Allows ifsm_state functions to be private.
     friend class etl::fsm;
     friend class etl::hfsm;
@@ -325,6 +341,9 @@ namespace etl
     ifsm_state& operator =(const ifsm_state&);
   };
 
+  ETL_CONSTANT fsm_state_id_t ifsm_state::No_State_Change;
+  ETL_CONSTANT fsm_state_id_t ifsm_state::Pass_To_Parent;
+
   //***************************************************************************
   /// The FSM class.
   //***************************************************************************
diff --git a/include/etl/generators/message_packet_generator.h b/include/etl/generators/message_packet_generator.h
index 6ada9acd..8a9bf0e0 100644
--- a/include/etl/generators/message_packet_generator.h
+++ b/include/etl/generators/message_packet_generator.h
@@ -483,7 +483,7 @@ namespace etl
     for n in range(1, int(Handlers)):
         cog.out("T%s, " % n)
     cog.outl("T%s>::value, int>::type>" % int(Handlers))
-    cog.outl("  explicit message_packet(TMessage&& msg)")
+    cog.outl("  explicit message_packet(TMessage&& /*msg*/)")
     cog.outl("    : valid(true)")
     cog.outl("  {")
     generate_static_assert_cpp11(int(Handlers))
@@ -767,7 +767,7 @@ namespace etl
         for t in range(1, n):
             cog.out("T%s, " % t)
         cog.outl("T%s>::value, int>::type>" % n)
-        cog.outl("  explicit message_packet(TMessage&& msg)")
+        cog.outl("  explicit message_packet(TMessage&& /*msg*/)")
         cog.outl("    : valid(true)")
         cog.outl("  {")
         generate_static_assert_cpp11(n)
diff --git a/include/etl/generators/smallest_generator.h b/include/etl/generators/smallest_generator.h
index 10f599e3..771d4111 100644
--- a/include/etl/generators/smallest_generator.h
+++ b/include/etl/generators/smallest_generator.h
@@ -333,6 +333,9 @@ namespace etl
     typedef typename private_smallest::best_fit_uint_type<TYPE_INDEX>::type type;
   };
 
+  template <size_t NBITS>
+  ETL_CONSTANT int smallest_uint_for_bits<NBITS>::TYPE_INDEX;
+
 #if ETL_USING_CPP11
   template <size_t NBITS>
   using smallest_uint_for_bits_t = typename smallest_uint_for_bits<NBITS>::type;
@@ -359,6 +362,9 @@ namespace etl
     typedef typename private_smallest::best_fit_int_type<TYPE_INDEX>::type type;
   };
 
+  template <size_t NBITS>
+  ETL_CONSTANT int smallest_int_for_bits<NBITS>::TYPE_INDEX;
+
 #if ETL_USING_CPP11
   template <size_t NBITS>
   using smallest_int_for_bits_t = typename smallest_int_for_bits<NBITS>::type;
@@ -385,6 +391,9 @@ namespace etl
     typedef typename private_smallest::best_fit_uint_type<TYPE_INDEX>::type type;
   };
 
+  template <size_t NBITS>
+  ETL_CONSTANT int smallest_uint_for_value<NBITS>::TYPE_INDEX;
+
 #if ETL_USING_CPP11
   template <uintmax_t VALUE>
   using smallest_uint_for_value_t = typename smallest_uint_for_value<VALUE>::type;
@@ -411,6 +420,9 @@ namespace etl
     typedef typename private_smallest::best_fit_int_type<TYPE_INDEX>::type type;
   };
 
+  template <size_t NBITS>
+  ETL_CONSTANT int smallest_int_for_value<NBITS>::TYPE_INDEX;
+
 #if ETL_USING_CPP11
   template <intmax_t VALUE>
   using smallest_int_for_value_t = typename smallest_int_for_value<VALUE>::type;
diff --git a/include/etl/generators/type_lookup_generator.h b/include/etl/generators/type_lookup_generator.h
index 2563729a..bcc10e2d 100644
--- a/include/etl/generators/type_lookup_generator.h
+++ b/include/etl/generators/type_lookup_generator.h
@@ -137,14 +137,14 @@ namespace etl
     template <typename T, typename T1, typename... TRest>
     struct id_from_type_helper
     {
-      static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? T1::ID : id_from_type_helper<T, TRest...>::value;
+      static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? size_t(T1::ID) : id_from_type_helper<T, TRest...>::value;
     };
 
     // Specialisation for 1 type pair.
     template <typename T, typename T1>
     struct id_from_type_helper<T, T1>
     {
-      static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? T1::ID : UNKNOWN;
+      static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? size_t(T1::ID) : UNKNOWN;
     };
 
   public:
diff --git a/include/etl/generators/type_traits_generator.h b/include/etl/generators/type_traits_generator.h
index c692add8..bcaa8e54 100644
--- a/include/etl/generators/type_traits_generator.h
+++ b/include/etl/generators/type_traits_generator.h
@@ -96,7 +96,7 @@ namespace etl
 
   //***************************************************************************
   /// integral_constant
-  template <typename T, const T VALUE>
+  template <typename T, T VALUE>
   struct integral_constant
   {
     static const T value = VALUE;
@@ -119,7 +119,7 @@ namespace etl
 
 #if ETL_USING_CPP17
   template <typename T, T VALUE>
-  inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
+  inline constexpr T integral_constant_v = etl::integral_constant<T, VALUE>::value;
 #endif
 
 #if ETL_USING_CPP11
@@ -132,7 +132,7 @@ namespace etl
 
 #if ETL_USING_CPP17
   template <bool B>
-  inline constexpr bool bool_constant_v = std::bool_constant<B>::value;
+  inline constexpr bool bool_constant_v = bool_constant<B>::value;
 #endif
 
   //***************************************************************************
@@ -825,11 +825,11 @@ namespace etl
 // Traits are derived from the STL
 //*****************************************************************************
 
-//***************************************************************************
-/// integral_constant
-///\ingroup type_traits
-template <typename T, T VALUE>
-struct integral_constant : std::integral_constant<T, VALUE> {};
+  //***************************************************************************
+  /// integral_constant
+  ///\ingroup type_traits
+  template <typename T, T VALUE>
+  struct integral_constant : std::integral_constant<T, VALUE> {};
 
 /// integral_constant specialisations
 ///\ingroup type_traits
@@ -841,6 +841,11 @@ typedef integral_constant<bool, true>  true_type;
   inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
 #endif
 
+#if ETL_USING_CPP17
+  template <typename T, T VALUE>
+  inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
+#endif
+
 #if ETL_USING_CPP17
   template <bool B>
   using bool_constant = std::bool_constant<B>;
@@ -851,7 +856,7 @@ typedef integral_constant<bool, true>  true_type;
 
 #if ETL_USING_CPP17
   template <bool B>
-  inline constexpr bool bool_constant_v = std::bool_constant<B>::value;
+  inline constexpr bool bool_constant_v = bool_constant<B>::value;
 #endif
 
   //***************************************************************************
@@ -1637,99 +1642,71 @@ typedef integral_constant<bool, true>  true_type;
   //*********************************************
   // is_assignable
   template<typename T1, typename T2>
-  struct is_assignable : public std::is_assignable<T1, T2>
-  {
-  };
+  using is_assignable = std::is_assignable<T1, T2>;
 
   //*********************************************
   // is_constructible
   template<typename T, typename... TArgs>
-  struct is_constructible : public std::is_constructible<T, TArgs...>
-  {
-  };
+  using is_constructible = std::is_constructible<T, TArgs...>;
 
   //*********************************************
   // is_copy_constructible
   template <typename T>
-  struct is_copy_constructible : public std::is_copy_constructible<T>
-  {
-  };
+  using is_copy_constructible = std::is_copy_constructible<T>;
 
   //*********************************************
   // is_move_constructible
   template <typename T>
-  struct is_move_constructible : public std::is_move_constructible<T>
-  {
-  };
+  using is_move_constructible = std::is_move_constructible<T>;
 
   //*********************************************
   // is_trivially_constructible
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
-  struct is_trivially_constructible : public std::is_trivially_constructible<T>
-  {
-  };
+  using is_trivially_constructible = std::is_trivially_constructible<T>;
 #else
   template <typename T>
-  struct is_trivially_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
-  {
-  };
+  using is_trivially_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
 #endif
 
   //*********************************************
   // is_trivially_copy_constructible
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
-  struct is_trivially_copy_constructible : public std::is_trivially_copy_constructible<T>
-  {
-  };
+  using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
 #else
   template <typename T>
-  struct is_trivially_copy_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
-  {
-  };
+  using is_trivially_copy_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
 #endif
 
   //*********************************************
   // is_trivially_destructible
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
-  struct is_trivially_destructible : public std::is_trivially_destructible<T>
-  {
-  };
+  using is_trivially_destructible = std::is_trivially_destructible<T>;
 #else
   template <typename T>
-  struct is_trivially_destructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
-  {
-  };
+  using is_trivially_destructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
 #endif
 
   //*********************************************
   // is_trivially_copy_assignable
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
-  struct is_trivially_copy_assignable : public std::is_trivially_copy_assignable<T>
-  {
-  };
+  using is_trivially_copy_assignable = std::is_trivially_copy_assignable<T>;
 #else
   template <typename T>
-  struct is_trivially_copy_assignable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
-  {
-  };
+  using is_trivially_copy_assignable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
 #endif
 
   //*********************************************
   // is_trivially_copyable
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
-  struct is_trivially_copyable : public std::is_trivially_copyable<T>
-  {
-  };
+  using is_trivially_copyable = std::is_trivially_copyable<T>;
 #else
   template <typename T>
-  struct is_trivially_copyable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
-  {
-  };
+  using is_trivially_copyable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
 #endif
 
 #elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)
diff --git a/include/etl/generic_pool.h b/include/etl/generic_pool.h
index 5ef0635d..f464b7b2 100644
--- a/include/etl/generic_pool.h
+++ b/include/etl/generic_pool.h
@@ -194,6 +194,15 @@ namespace etl
     generic_pool& operator =(const generic_pool&) ETL_DELETE;
   };
 
+  template <const size_t VTypeSize, const size_t VAlignment, const size_t VSize>
+  ETL_CONSTANT size_t generic_pool<VTypeSize, VAlignment, VSize>::SIZE;
+  
+  template <const size_t VTypeSize, const size_t VAlignment, const size_t VSize>
+  ETL_CONSTANT size_t generic_pool<VTypeSize, VAlignment, VSize>::ALIGNMENT;
+  
+  template <const size_t VTypeSize, const size_t VAlignment, const size_t VSize>
+  ETL_CONSTANT size_t generic_pool<VTypeSize, VAlignment, VSize>::TYPE_SIZE;
+
   //*************************************************************************
   /// A templated abstract pool implementation that uses a fixed size pool.
   /// The storage for the pool is supplied externally.
@@ -338,6 +347,12 @@ namespace etl
     generic_pool_ext(const generic_pool_ext&) ETL_DELETE;
     generic_pool_ext& operator=(const generic_pool_ext&) ETL_DELETE;
   };
+
+  template <const size_t VTypeSize, const size_t VAlignment>
+  ETL_CONSTANT size_t generic_pool_ext<VTypeSize, VAlignment>::ALIGNMENT;
+
+  template <const size_t VTypeSize, const size_t VAlignment>
+  ETL_CONSTANT size_t generic_pool_ext<VTypeSize, VAlignment>::TYPE_SIZE;
 }
 
 #endif
diff --git a/include/etl/hfsm.h b/include/etl/hfsm.h
index 73eee88b..b49eaa19 100644
--- a/include/etl/hfsm.h
+++ b/include/etl/hfsm.h
@@ -67,6 +67,14 @@ namespace etl
         if (call_on_enter_state)
         {
             do_enters(ETL_NULLPTR, p_state, true);
+
+
+            //etl::fsm_state_id_t next_state = do_enters(ETL_NULLPTR, p_state, true);
+
+            //if (ifsm_state::No_State_Change != next_state)
+            //{
+            //  p_state = state_list[next_state];
+            //}
         }
       }
     }
diff --git a/include/etl/histogram.h b/include/etl/histogram.h
index 4cb03175..15d54222 100644
--- a/include/etl/histogram.h
+++ b/include/etl/histogram.h
@@ -126,6 +126,9 @@ namespace etl
 
       etl::array<TCount, Max_Size> accumulator;
     };
+
+    template <typename TCount, size_t Max_Size_>   
+    ETL_CONSTANT size_t histogram_common<TCount, Max_Size_>::Max_Size;
   }
 
   //***************************************************************************
@@ -592,6 +595,9 @@ namespace etl
 
     etl::flat_map<key_type, count_type, Max_Size> accumulator;
   };
+
+  template <typename TKey, typename TCount, size_t Max_Size_>
+  ETL_CONSTANT size_t sparse_histogram<TKey, TCount, Max_Size_>::Max_Size;
 }
 
 #endif
diff --git a/include/etl/indirect_vector.h b/include/etl/indirect_vector.h
index 78e592bf..7158a4a0 100644
--- a/include/etl/indirect_vector.h
+++ b/include/etl/indirect_vector.h
@@ -1424,6 +1424,9 @@ namespace etl
     etl::pool<T, MAX_SIZE>    storage_pool;
   };
 
+  template <typename T, const size_t MAX_SIZE_>
+  ETL_CONSTANT size_t indirect_vector<T, MAX_SIZE_>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/integral_limits.h b/include/etl/integral_limits.h
index a93f6c88..f7b7c68c 100644
--- a/include/etl/integral_limits.h
+++ b/include/etl/integral_limits.h
@@ -45,8 +45,422 @@ SOFTWARE.
 ///\ingroup utilities
 //*****************************************************************************
 
+#ifndef LLONG_MAX
+  #define LLONG_MAX	9223372036854775807LL
+#endif
+
+#ifndef LLONG_MIN
+  #define LLONG_MIN	(-LLONG_MAX - 1LL)
+#endif
+
+#ifndef ULLONG_MAX
+  #define ULLONG_MAX 18446744073709551615ULL
+#endif
+
 namespace etl
 {
+  namespace private_integral_limits
+  {
+    //*****************************************************************************
+    /// The technique of using templated base classes to declare and define the statics
+    /// is to get around the limits of the One Definition Rule (ODR) that occurs when
+    /// the top level integral_limits classes are specialised. This issue currently seems
+    /// to only be apparent for GCC/C++14.
+    /// In C++17 and above this is not necessary, as the inline keyword may be used.
+    /// At the time of writing, the ETL is generally aimed to be compatible with C++98 and above.
+    //*****************************************************************************
+    
+    //*********************************
+    // signed char
+    template <typename T = void>
+    struct statics_signed_char
+    {
+      typedef signed char value_type;
+
+      static ETL_CONSTANT signed char min       = SCHAR_MIN;
+      static ETL_CONSTANT signed char max       = SCHAR_MAX;
+      static ETL_CONSTANT int         bits      = CHAR_BIT;
+      static ETL_CONSTANT bool        is_signed = etl::is_signed<signed char>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT signed char statics_signed_char<T>::min;
+    
+    template <typename T>
+    ETL_CONSTANT signed char statics_signed_char<T>::max;
+    
+    template <typename T>
+    ETL_CONSTANT int statics_signed_char<T>::bits;
+    
+    template <typename T>
+    ETL_CONSTANT bool statics_signed_char<T>::is_signed;
+
+    //***********************************
+    // unsigned char
+    template <typename T = void>
+    struct statics_unsigned_char
+    {
+      typedef unsigned char value_type;
+
+      static ETL_CONSTANT unsigned char min       = 0;
+      static ETL_CONSTANT unsigned char max       = UCHAR_MAX;
+      static ETL_CONSTANT int           bits      = CHAR_BIT;
+      static ETL_CONSTANT bool          is_signed = etl::is_signed<unsigned char>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT unsigned char statics_unsigned_char<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT unsigned char statics_unsigned_char<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_unsigned_char<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_unsigned_char<T>::is_signed;
+
+    //***********************************
+    // char
+    template <typename T = void>
+    struct statics_char
+    {
+      typedef char value_type;
+
+      static ETL_CONSTANT char min       = (etl::is_signed<char>::value) ? SCHAR_MIN : 0;
+      static ETL_CONSTANT char max       = (etl::is_signed<char>::value) ? SCHAR_MAX : static_cast<char>(UCHAR_MAX);
+      static ETL_CONSTANT int  bits      = CHAR_BIT;
+      static ETL_CONSTANT bool is_signed = etl::is_signed<char>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT char statics_char<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT char statics_char<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_char<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_char<T>::is_signed;
+
+    //***********************************
+    // wchar_t
+    template <typename T = void>
+    struct statics_wchar_t
+    {
+      typedef wchar_t value_type;
+
+      static ETL_CONSTANT wchar_t min       = WCHAR_MIN;
+      static ETL_CONSTANT wchar_t max       = WCHAR_MAX;
+      static ETL_CONSTANT int     bits      = CHAR_BIT * sizeof(wchar_t);
+      static ETL_CONSTANT bool    is_signed = etl::is_signed<wchar_t>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT wchar_t statics_wchar_t<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT wchar_t statics_wchar_t<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_wchar_t<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_wchar_t<T>::is_signed;
+
+    //***********************************
+    // short
+#if defined(ETL_COMPILER_MICROSOFT)
+  #pragma warning(push)
+  #pragma warning(disable : 4309)
+#endif
+
+    template <typename T = void>
+    struct statics_short
+    {
+      typedef short value_type;
+
+      static ETL_CONSTANT short min       = SHRT_MIN;
+      static ETL_CONSTANT short max       = SHRT_MAX;
+      static ETL_CONSTANT int   bits      = CHAR_BIT * (sizeof(short) / sizeof(char));
+      static ETL_CONSTANT bool  is_signed = etl::is_signed<short>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT short statics_short<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT short statics_short<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_short<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_short<T>::is_signed;
+
+#if defined(ETL_COMPILER_MICROSOFT)
+  #pragma warning(pop)
+#endif
+
+    //***********************************
+    // unsigned short
+    template <typename T = void>
+    struct statics_unsigned_short
+    {
+      typedef unsigned short value_type;
+
+      static ETL_CONSTANT unsigned short min       = 0;
+      static ETL_CONSTANT unsigned short max       = USHRT_MAX;
+      static ETL_CONSTANT int            bits      = CHAR_BIT * (sizeof(unsigned short) / sizeof(char));
+      static ETL_CONSTANT bool           is_signed = etl::is_signed<unsigned short>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT unsigned short statics_unsigned_short<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT unsigned short statics_unsigned_short<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_unsigned_short<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_unsigned_short<T>::is_signed;
+
+    //***********************************
+    // int
+    template <typename T = void>
+    struct statics_int
+    {
+      typedef int value_type;
+
+      static ETL_CONSTANT int  min       = INT_MIN;
+      static ETL_CONSTANT int  max       = INT_MAX;
+      static ETL_CONSTANT int  bits      = CHAR_BIT * (sizeof(int) / sizeof(char));
+      static ETL_CONSTANT bool is_signed = etl::is_signed<int>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int statics_int<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT int statics_int<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_int<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_int<T>::is_signed;
+
+    //***********************************
+    // unsigned int
+    template <typename T = void>
+    struct statics_unsigned_int
+    {
+      typedef unsigned int value_type;
+
+      static ETL_CONSTANT unsigned int min       = 0;
+      static ETL_CONSTANT unsigned int max       = UINT_MAX;
+      static ETL_CONSTANT int          bits      = CHAR_BIT * (sizeof(unsigned int) / sizeof(char));
+      static ETL_CONSTANT bool         is_signed = etl::is_signed<unsigned int>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT unsigned int statics_unsigned_int<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT unsigned int statics_unsigned_int<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_unsigned_int<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_unsigned_int<T>::is_signed;
+
+    //***********************************
+    // long
+    template <typename T = void>
+    struct statics_long
+    {
+      typedef long value_type;
+
+      static ETL_CONSTANT long min       = LONG_MIN;
+      static ETL_CONSTANT long max       = LONG_MAX;
+      static ETL_CONSTANT int  bits      = CHAR_BIT * (sizeof(long) / sizeof(char));
+      static ETL_CONSTANT bool is_signed = etl::is_signed<long>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT long statics_long<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT long statics_long<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_long<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_long<T>::is_signed;
+
+    //***********************************
+    // unsigned long
+    template <typename T = void>
+    struct statics_unsigned_long
+    {
+      typedef unsigned long value_type;
+
+      static ETL_CONSTANT unsigned long min       = 0;
+      static ETL_CONSTANT unsigned long max       = ULONG_MAX;
+      static ETL_CONSTANT int           bits      = CHAR_BIT * (sizeof(unsigned long) / sizeof(char));
+      static ETL_CONSTANT bool          is_signed = etl::is_signed<unsigned long>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT unsigned long statics_unsigned_long<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT unsigned long statics_unsigned_long<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_unsigned_long<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_unsigned_long<T>::is_signed;
+
+    //***********************************
+    // long long
+    template <typename T = void>
+    struct statics_long_long
+    {
+      typedef long long value_type;
+
+      static ETL_CONSTANT long long min       = LLONG_MIN;
+      static ETL_CONSTANT long long max       = LLONG_MAX;
+      static ETL_CONSTANT int       bits      = CHAR_BIT * (sizeof(long long) / sizeof(char));
+      static ETL_CONSTANT bool      is_signed = etl::is_signed<long long>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT long long statics_long_long<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT long long statics_long_long<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_long_long<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_long_long<T>::is_signed;
+
+    //***********************************
+    // unsigned long long
+    template <typename T = void>
+    struct statics_unsigned_long_long
+    {
+      typedef unsigned long value_type;
+
+      static ETL_CONSTANT unsigned long long min       = 0;
+      static ETL_CONSTANT unsigned long long max       = ULLONG_MAX;
+      static ETL_CONSTANT int                bits      = CHAR_BIT * (sizeof(unsigned long long) / sizeof(char));
+      static ETL_CONSTANT bool               is_signed = etl::is_signed<unsigned long long>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT unsigned long long statics_unsigned_long_long<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT unsigned long long statics_unsigned_long_long<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_unsigned_long_long<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_unsigned_long_long<T>::is_signed;
+
+#if ETL_HAS_NATIVE_CHAR8_T
+    //***********************************
+    // char8_t
+    template <typename T = void>
+    struct statics_char8_t
+    {
+      typedef char8_t value_type;
+
+      static ETL_CONSTANT char8_t min       = (etl::is_signed<char8_t>::value) ? SCHAR_MIN : 0;
+      static ETL_CONSTANT char8_t max       = (etl::is_signed<char8_t>::value) ? SCHAR_MAX : static_cast<char8_t>(UCHAR_MAX);
+      static ETL_CONSTANT int     bits      = CHAR_BIT;
+      static ETL_CONSTANT bool    is_signed = etl::is_signed<char8_t>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT char8_t statics_char8_t<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT char8_t statics_char8_t<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_char8_t<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_char8_t<T>::is_signed;
+#endif
+
+#if ETL_HAS_NATIVE_CHAR16_T
+    //***********************************
+    // char16_t
+    template <typename T = void>
+    struct statics_char16_t
+    {
+      typedef char16_t value_type;
+
+      static ETL_CONSTANT char16_t min       = 0;
+      static ETL_CONSTANT char16_t max       = 0xFFFFU;
+      static ETL_CONSTANT int      bits      = 16;
+      static ETL_CONSTANT bool     is_signed = false;
+    };
+
+    template <typename T>
+    ETL_CONSTANT char16_t statics_char16_t<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT char16_t statics_char16_t<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_char16_t<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_char16_t<T>::is_signed;
+#endif
+
+#if ETL_HAS_NATIVE_CHAR32_T
+    //***********************************
+    // char32_t
+    template <typename T = void>
+    struct statics_char32_t
+    {
+      typedef char32_t value_type;
+
+      static ETL_CONSTANT char32_t min       = 0;
+      static ETL_CONSTANT char32_t max       = 0xFFFFFFFFU;
+      static ETL_CONSTANT int      bits      = 32;
+      static ETL_CONSTANT bool     is_signed = false;
+    };
+     
+    template <typename T>
+    ETL_CONSTANT char32_t statics_char32_t<T>::min;
+
+    template <typename T>
+    ETL_CONSTANT char32_t statics_char32_t<T>::max;
+
+    template <typename T>
+    ETL_CONSTANT int statics_char32_t<T>::bits;
+
+    template <typename T>
+    ETL_CONSTANT bool statics_char32_t<T>::is_signed;
+#endif
+  }
+
   //***************************************************************************
   ///\ingroup integral_limits
   //***************************************************************************
@@ -57,166 +471,91 @@ namespace etl
   ///\ingroup integral_limits
   //***************************************************************************
   template <>
-  struct integral_limits<void>
+  struct integral_limits<signed char> : public private_integral_limits::statics_signed_char<>
   {
-    static ETL_CONSTANT int min        = 0;
-    static ETL_CONSTANT int max        = 0;
-    static ETL_CONSTANT int bits       = 0;
-    static ETL_CONSTANT bool is_signed = false;
   };
 
   //***************************************************************************
   ///\ingroup integral_limits
   //***************************************************************************
   template <>
-  struct integral_limits<signed char>
+  struct integral_limits<unsigned char> : public private_integral_limits::statics_unsigned_char<>
   {
-    static ETL_CONSTANT signed char min = SCHAR_MIN;
-    static ETL_CONSTANT signed char max = SCHAR_MAX;
-    static ETL_CONSTANT int bits        = CHAR_BIT;
-    static ETL_CONSTANT bool is_signed  = etl::is_signed<signed char>::value;
+  };
+
+  //***************************************************************************
+  ///\ingroup integral_limits
+  //***************************************************************************
+
+  template <>
+  struct integral_limits<char> : public private_integral_limits::statics_char<>
+  {
+    typedef char value_type;
   };
 
   //***************************************************************************
   ///\ingroup integral_limits
   //***************************************************************************
   template <>
-  struct integral_limits<unsigned char>
+  struct integral_limits<short> : public private_integral_limits::statics_short<>
   {
-    static ETL_CONSTANT unsigned char min = 0;
-    static ETL_CONSTANT unsigned char max = UCHAR_MAX;
-    static ETL_CONSTANT int bits          = CHAR_BIT;
-    static ETL_CONSTANT bool is_signed    = etl::is_signed<unsigned char>::value;
-  };
-
-  //***************************************************************************
-  ///\ingroup integral_limits
-  //***************************************************************************
-#if defined(ETL_COMPILER_MICROSOFT)
-  #pragma warning(push)
-  #pragma warning(disable : 4309)
-#endif
-  template <>
-  struct integral_limits<char>
-  {
-    static ETL_CONSTANT char min       = (etl::is_signed<char>::value) ? SCHAR_MIN : 0;
-    static ETL_CONSTANT char max       = (etl::is_signed<char>::value) ? SCHAR_MAX : static_cast<char>(UCHAR_MAX);
-    static ETL_CONSTANT int bits       = CHAR_BIT;
-    static ETL_CONSTANT bool is_signed = etl::is_signed<char>::value;
-  };
-#if defined(ETL_COMPILER_MICROSOFT)
-  #pragma warning(pop)
-#endif
-
-  //***************************************************************************
-  ///\ingroup integral_limits
-  //***************************************************************************
-  template <>
-  struct integral_limits<short>
-  {
-    static ETL_CONSTANT short min      = SHRT_MIN;
-    static ETL_CONSTANT short max      = SHRT_MAX;
-    static ETL_CONSTANT int bits       = CHAR_BIT * (sizeof(short) / sizeof(char));
-    static ETL_CONSTANT bool is_signed = etl::is_signed<short>::value;
   };
 
   //***************************************************************************
   ///\ingroup integral_limits
   //***************************************************************************
   template <>
-  struct integral_limits<unsigned short>
+  struct integral_limits<unsigned short> : public private_integral_limits::statics_unsigned_short<>
   {
-    static ETL_CONSTANT unsigned short min = 0;
-    static ETL_CONSTANT unsigned short max = USHRT_MAX;
-    static ETL_CONSTANT int bits           = CHAR_BIT * (sizeof(unsigned short) / sizeof(char));
-    static ETL_CONSTANT bool is_signed     = etl::is_signed<unsigned short>::value;
   };
 
   //***************************************************************************
   ///\ingroup integral_limits
   //***************************************************************************
   template <>
-  struct integral_limits<int>
+  struct integral_limits<int> : public private_integral_limits::statics_int<>
   {
-    static ETL_CONSTANT int min        = INT_MIN;
-    static ETL_CONSTANT int max        = INT_MAX;
-    static ETL_CONSTANT int bits       = CHAR_BIT * (sizeof(int) / sizeof(char));
-    static ETL_CONSTANT bool is_signed = etl::is_signed<int>::value;
   };
 
   //***************************************************************************
   ///\ingroup integral_limits
   //***************************************************************************
   template <>
-  struct integral_limits<unsigned int>
+  struct integral_limits<unsigned int> : public private_integral_limits::statics_unsigned_int<>
   {
-    static ETL_CONSTANT unsigned int min = 0;
-    static ETL_CONSTANT unsigned int max = UINT_MAX;
-    static ETL_CONSTANT int bits         = CHAR_BIT * (sizeof(unsigned int) / sizeof(char));
-    static ETL_CONSTANT bool is_signed   = etl::is_signed<unsigned int>::value;
   };
 
   //***************************************************************************
   ///\ingroup integral_limits
   //***************************************************************************
   template <>
-  struct integral_limits<long>
+  struct integral_limits<long> : public private_integral_limits::statics_long<>
   {
-    static ETL_CONSTANT long min       = LONG_MIN;
-    static ETL_CONSTANT long max       = LONG_MAX;
-    static ETL_CONSTANT int bits       = CHAR_BIT * (sizeof(long) / sizeof(char));
-    static ETL_CONSTANT bool is_signed = etl::is_signed<long>::value;
   };
 
   //***************************************************************************
   ///\ingroup integral_limits
   //***************************************************************************
   template <>
-  struct integral_limits<unsigned long>
+  struct integral_limits<unsigned long> : public private_integral_limits::statics_unsigned_long<>
   {
-    static ETL_CONSTANT unsigned long min = 0;
-    static ETL_CONSTANT unsigned long max = ULONG_MAX;
-    static ETL_CONSTANT int bits          = CHAR_BIT * (sizeof(unsigned long) / sizeof(char));
-    static ETL_CONSTANT bool is_signed    = etl::is_signed<unsigned long>::value;
-  };
-
-#ifndef LLONG_MAX
-#define LLONG_MAX	9223372036854775807LL
-#endif
-
-#ifndef LLONG_MIN
-#define LLONG_MIN	(-LLONG_MAX - 1LL)
-#endif
-
-#ifndef ULLONG_MAX
-#define ULLONG_MAX 18446744073709551615ULL
-#endif
-
-  //***************************************************************************
-  ///\ingroup integral_limits
-  //***************************************************************************
-  template <>
-  struct integral_limits<long long>
-  {
-    static ETL_CONSTANT long long min  = LLONG_MIN;
-    static ETL_CONSTANT long long max  = LLONG_MAX;
-    static ETL_CONSTANT int bits       = CHAR_BIT * (sizeof(long long) / sizeof(char));
-    static ETL_CONSTANT bool is_signed = etl::is_signed<long long>::value;
   };
 
   //***************************************************************************
   ///\ingroup integral_limits
   //***************************************************************************
   template <>
-  struct integral_limits<unsigned long long>
-  {
-    static ETL_CONSTANT unsigned long long min = 0;
-    static ETL_CONSTANT unsigned long long max = ULLONG_MAX;
-    static ETL_CONSTANT int bits               = CHAR_BIT * (sizeof(unsigned long long) / sizeof(char));
-    static ETL_CONSTANT bool is_signed         = etl::is_signed<unsigned long long>::value;
+  struct integral_limits<long long> : public private_integral_limits::statics_long_long<>
+  {    
   };
 
-  static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
+  //***************************************************************************
+  ///\ingroup integral_limits
+  //***************************************************************************
+  template <>
+  struct integral_limits<unsigned long long> : public private_integral_limits::statics_unsigned_long_long<>
+  {
+  };
 }
 
 #include "private/minmax_pop.h"
diff --git a/include/etl/iterator.h b/include/etl/iterator.h
index 016eec10..83251179 100644
--- a/include/etl/iterator.h
+++ b/include/etl/iterator.h
@@ -806,24 +806,36 @@ namespace etl
     static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::input_iterator_tag>::value;
   };
 
+  template <typename T>
+  ETL_CONSTANT bool is_input_iterator<T>::value;
+
   template <typename T>
   struct is_output_iterator
   {
     static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::output_iterator_tag>::value;
   };
 
+  template <typename T>
+  ETL_CONSTANT bool is_output_iterator<T>::value;
+
   template <typename T>
   struct is_forward_iterator
   {
     static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::forward_iterator_tag>::value;
   };
 
+  template <typename T>
+  ETL_CONSTANT bool is_forward_iterator<T>::value;
+
   template <typename T>
   struct is_bidirectional_iterator
   {
     static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::bidirectional_iterator_tag>::value;
   };
 
+  template <typename T>
+  ETL_CONSTANT bool is_bidirectional_iterator<T>::value;
+
   // Deprecated
   template <typename T>
   struct is_random_iterator
@@ -831,12 +843,18 @@ namespace etl
     static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value;
   };
 
+  template <typename T>
+  ETL_CONSTANT bool is_random_iterator<T>::value;
+
   template <typename T>
   struct is_random_access_iterator
   {
     static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value;
   };
 
+  template <typename T>
+  ETL_CONSTANT bool is_random_access_iterator<T>::value;
+
   template <typename T>
   struct is_input_iterator_concept
   {
@@ -846,6 +864,9 @@ namespace etl
                                                etl::is_random_iterator<T>::value;
   };
 
+  template <typename T>
+  ETL_CONSTANT bool is_input_iterator_concept<T>::value;
+
   template <typename T>
   struct is_output_iterator_concept
   {
@@ -855,6 +876,9 @@ namespace etl
                                                etl::is_random_iterator<T>::value;
   };
 
+  template <typename T>
+  ETL_CONSTANT bool is_output_iterator_concept<T>::value;
+
   template <typename T>
   struct is_forward_iterator_concept
   {
@@ -863,6 +887,9 @@ namespace etl
                                                etl::is_random_iterator<T>::value;
   };
 
+  template <typename T>
+  ETL_CONSTANT bool is_forward_iterator_concept<T>::value;
+
   template <typename T>
   struct is_bidirectional_iterator_concept
   {
@@ -870,6 +897,9 @@ namespace etl
                                                etl::is_random_iterator<T>::value;
   };
 
+  template <typename T>
+  ETL_CONSTANT bool is_bidirectional_iterator_concept<T>::value;
+
   // Deprecated
   template <typename T>
   struct is_random_iterator_concept
@@ -877,12 +907,21 @@ namespace etl
     static ETL_CONSTANT bool value = etl::is_random_iterator<T>::value;
   };
 
+  // Deprecated
+  template <typename T>
+  ETL_CONSTANT bool is_random_iterator_concept<T>::value;
+
+  // Deprecated
   template <typename T>
   struct is_random_access_iterator_concept
   {
     static ETL_CONSTANT bool value = etl::is_random_access_iterator<T>::value;
   };
 
+  // Deprecated
+  template <typename T>
+  ETL_CONSTANT bool is_random_access_iterator_concept<T>::value;
+
 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
   //*****************************************************************************
   /// Get the 'begin' iterator.
diff --git a/include/etl/limits.h b/include/etl/limits.h
index eae016b0..ae54da04 100644
--- a/include/etl/limits.h
+++ b/include/etl/limits.h
@@ -101,69 +101,658 @@ namespace etl
 {
   enum float_round_style
   {
-    round_indeterminate       = -1,
-    round_toward_zero         = 0,
-    round_to_nearest          = 1,
-    round_toward_infinity     = 2,
+    round_indeterminate = -1,
+    round_toward_zero = 0,
+    round_to_nearest = 1,
+    round_toward_infinity = 2,
     round_toward_neg_infinity = 3,
   };
 
   enum float_denorm_style
   {
     denorm_indeterminate = -1,
-    denorm_absent        = 0,
-    denorm_present       = 1
+    denorm_absent = 0,
+    denorm_present = 1
   };
 
-
-  class etl_integral_limits
+  namespace private_limits
   {
-  public:
+    //*********************************
+    // Integral limits common
+    template <typename T = void>
+    class integral_limits_common
+    {
+    public:
 
-    static ETL_CONSTANT bool is_specialized    = true;
-    static ETL_CONSTANT bool is_integer        = true;
-    static ETL_CONSTANT bool is_exact          = true;
-    static ETL_CONSTANT int  max_digits10      = 0;
-    static ETL_CONSTANT int  radix             = 2;
-    static ETL_CONSTANT int  min_exponent      = 0;
-    static ETL_CONSTANT int  min_exponent10    = 0;
-    static ETL_CONSTANT int  max_exponent      = 0;
-    static ETL_CONSTANT int  max_exponent10    = 0;
-    static ETL_CONSTANT bool has_infinity      = false;
-    static ETL_CONSTANT bool has_quiet_NaN     = false;
-    static ETL_CONSTANT bool has_signaling_NaN = false;
-    static ETL_CONSTANT bool has_denorm_loss   = false;
-    static ETL_CONSTANT bool is_iec559         = false;
-    static ETL_CONSTANT bool is_bounded        = true;
-    static ETL_CONSTANT bool traps             = false;
-    static ETL_CONSTANT bool tinyness_before   = false;
-    static ETL_CONSTANT float_denorm_style has_denorm = denorm_absent;
-    static ETL_CONSTANT float_round_style round_style = round_toward_zero;
-  };
+      static ETL_CONSTANT bool is_specialized    = true;
+      static ETL_CONSTANT bool is_integer        = true;
+      static ETL_CONSTANT bool is_exact          = true;
+      static ETL_CONSTANT int  max_digits10      = 0;
+      static ETL_CONSTANT int  radix             = 2;
+      static ETL_CONSTANT int  min_exponent      = 0;
+      static ETL_CONSTANT int  min_exponent10    = 0;
+      static ETL_CONSTANT int  max_exponent      = 0;
+      static ETL_CONSTANT int  max_exponent10    = 0;
+      static ETL_CONSTANT bool has_infinity      = false;
+      static ETL_CONSTANT bool has_quiet_NaN     = false;
+      static ETL_CONSTANT bool has_signaling_NaN = false;
+      static ETL_CONSTANT bool has_denorm_loss   = false;
+      static ETL_CONSTANT bool is_iec559         = false;
+      static ETL_CONSTANT bool is_bounded        = true;
+      static ETL_CONSTANT bool traps             = false;
+      static ETL_CONSTANT bool tinyness_before   = false;
+      static ETL_CONSTANT float_denorm_style has_denorm  = denorm_absent;
+      static ETL_CONSTANT float_round_style  round_style = round_toward_zero;
+    };
 
-  class etl_floating_point_limits
-  {
-  public:
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::is_specialized;
 
-    static ETL_CONSTANT bool is_specialized    = true;
-    static ETL_CONSTANT bool is_signed         = true;
-    static ETL_CONSTANT bool is_integer        = false;
-    static ETL_CONSTANT bool is_exact          = false;
-    static ETL_CONSTANT int radix              = 2;
-    static ETL_CONSTANT bool has_infinity      = true;
-    static ETL_CONSTANT bool has_quiet_NaN     = ETL_HAS_NAN;
-    static ETL_CONSTANT bool has_signaling_NaN = ETL_HAS_NAN;
-    static ETL_CONSTANT bool has_denorm_loss   = false;
-    static ETL_CONSTANT bool is_iec559         = false;
-    static ETL_CONSTANT bool is_bounded        = true;
-    static ETL_CONSTANT bool is_modulo         = false;
-    static ETL_CONSTANT bool traps             = false;
-    static ETL_CONSTANT bool tinyness_before   = false;
-    static ETL_CONSTANT float_denorm_style has_denorm = denorm_indeterminate;
-    static ETL_CONSTANT float_round_style round_style = round_indeterminate;
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::is_integer;
 
-    static float round_error() { return float(0.5); }
-  };
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::is_exact;
+
+    template <typename T>
+    ETL_CONSTANT int  integral_limits_common<T>::max_digits10;
+
+    template <typename T>
+    ETL_CONSTANT int  integral_limits_common<T>::radix;
+
+    template <typename T>
+    ETL_CONSTANT int  integral_limits_common<T>::min_exponent;
+
+    template <typename T>
+    ETL_CONSTANT int  integral_limits_common<T>::min_exponent10;
+
+    template <typename T>
+    ETL_CONSTANT int  integral_limits_common<T>::max_exponent;
+
+    template <typename T>
+    ETL_CONSTANT int  integral_limits_common<T>::max_exponent10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::has_infinity;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::has_quiet_NaN;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::has_signaling_NaN;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::has_denorm_loss;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::is_iec559;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::is_bounded;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::traps;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_common<T>::tinyness_before;
+
+    template <typename T>
+    ETL_CONSTANT float_denorm_style integral_limits_common<T>::has_denorm;
+
+    template <typename T>
+    ETL_CONSTANT float_round_style integral_limits_common<T>::round_style;
+
+    //*********************************
+    // bool
+    template <typename T = void>
+    struct integral_limits_bool
+    {
+      static ETL_CONSTANT int  digits    = 1;
+      static ETL_CONSTANT int  digits10  = 0;
+      static ETL_CONSTANT bool is_signed = false;
+      static ETL_CONSTANT bool is_modulo = false;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_bool<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_bool<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_bool<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_bool<T>::is_modulo;
+
+    //*********************************
+    // char
+    template <typename T = void>
+    struct integral_limits_char
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(char)) - (etl::is_signed<char>::value ? 1 : 0);
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = etl::is_signed<char>::value;
+      static ETL_CONSTANT bool is_modulo = etl::is_unsigned<char>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_char<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_char<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_char<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_char<T>::is_modulo;
+
+    //*********************************
+    // unsigned char
+    template <typename T = void>
+    struct integral_limits_unsigned_char
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(unsigned char));
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = false;
+      static ETL_CONSTANT bool is_modulo = true;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_unsigned_char<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_unsigned_char<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_unsigned_char<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_unsigned_char<T>::is_modulo;
+
+    //*********************************
+    // signed char
+    template <typename T = void>
+    struct integral_limits_signed_char
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(char)) - 1;
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = true;
+      static ETL_CONSTANT bool is_modulo = false;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_signed_char<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_signed_char<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_signed_char<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_signed_char<T>::is_modulo;
+
+#if ETL_HAS_NATIVE_CHAR8_T
+    //*********************************
+    // char8_t
+    template <typename T = void>
+    struct integral_limits_char8_t
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(char8_t)) - (etl::is_signed<char8_t>::value ? 1 : 0);
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = etl::is_signed<char8_t>::value;
+      static ETL_CONSTANT bool is_modulo = false;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_char8_t<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_char8_t<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_char8_t<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_char8_t<T>::is_modulo;
+#endif
+
+#if ETL_HAS_NATIVE_CHAR16_T
+    //*********************************
+    // char16_t
+    template <typename T = void>
+    struct integral_limits_char16_t
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(char16_t));
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = false;
+      static ETL_CONSTANT bool is_modulo = true;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_char16_t<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_char16_t<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_char16_t<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_char16_t<T>::is_modulo;
+#endif
+
+#if ETL_HAS_NATIVE_CHAR32_T
+    //*********************************
+    // char32_t
+    template <typename T = void>
+    struct integral_limits_char32_t
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(char32_t));
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = false;
+      static ETL_CONSTANT bool is_modulo = true;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_char32_t<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_char32_t<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_char32_t<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_char32_t<T>::is_modulo;
+#endif
+
+    //*********************************
+    // wchar_t
+    template <typename T = void>
+    struct integral_limits_wchar_t
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(wchar_t)) - (etl::is_signed<wchar_t>::value ? 1 : 0);
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = etl::is_signed<wchar_t>::value;
+      static ETL_CONSTANT bool is_modulo = etl::is_unsigned<wchar_t>::value;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_wchar_t<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_wchar_t<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_wchar_t<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_wchar_t<T>::is_modulo;
+
+    //*********************************
+    // short
+    template <typename T = void>
+    struct integral_limits_short
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(short)) - 1;
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = true;
+      static ETL_CONSTANT bool is_modulo = false;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_short<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_short<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_short<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_short<T>::is_modulo;
+
+    //*********************************
+    // unsigned short
+    template <typename T = void>
+    struct integral_limits_unsigned_short
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(unsigned short));
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = false;
+      static ETL_CONSTANT bool is_modulo = true;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_unsigned_short<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_unsigned_short<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_unsigned_short<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_unsigned_short<T>::is_modulo;
+
+    //*********************************
+    // int
+    template <typename T = void>
+    struct integral_limits_int
+    {
+      static ETL_CONSTANT int digits     = (CHAR_BIT * sizeof(int)) - 1;
+      static ETL_CONSTANT int digits10   = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = true;
+      static ETL_CONSTANT bool is_modulo = false;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_int<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_int<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_int<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_int<T>::is_modulo;
+
+    //*********************************
+    // unsigned int
+    template <typename T = void>
+    struct integral_limits_unsigned_int
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(unsigned int));
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = false;
+      static ETL_CONSTANT bool is_modulo = true;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_unsigned_int<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_unsigned_int<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_unsigned_int<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_unsigned_int<T>::is_modulo;
+
+    //*********************************
+    // long
+    template <typename T = void>
+    struct integral_limits_long
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(long)) - 1;
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = true;
+      static ETL_CONSTANT bool is_modulo = false;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_long<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_long<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_long<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_long<T>::is_modulo;
+
+    //*********************************
+    // unsigned long
+    template <typename T = void>
+    struct integral_limits_unsigned_long
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(unsigned long));
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = false;
+      static ETL_CONSTANT bool is_modulo = true;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_unsigned_long<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_unsigned_long<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_unsigned_long<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_unsigned_long<T>::is_modulo;
+
+    //*********************************
+    // long long
+    template <typename T = void>
+    struct integral_limits_long_long
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(long long)) - 1;
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = true;
+      static ETL_CONSTANT bool is_modulo = false;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_long_long<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_long_long<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_long_long<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_long_long<T>::is_modulo;
+
+    //*********************************
+    // unsigned long long
+    template <typename T = void>
+    struct integral_limits_unsigned_long_long
+    {
+      static ETL_CONSTANT int  digits    = (CHAR_BIT * sizeof(unsigned long long));
+      static ETL_CONSTANT int  digits10  = ETL_LOG10_OF_2(digits);
+      static ETL_CONSTANT bool is_signed = false;
+      static ETL_CONSTANT bool is_modulo = true;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_unsigned_long_long<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int integral_limits_unsigned_long_long<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_unsigned_long_long<T>::is_signed;
+
+    template <typename T>
+    ETL_CONSTANT bool integral_limits_unsigned_long_long<T>::is_modulo;
+
+    //*********************************
+    // Floating point limits common
+    template <typename T = void>
+    class floating_point_limits_common
+    {
+    public:
+
+      static ETL_CONSTANT bool is_specialized    = true;
+      static ETL_CONSTANT bool is_signed         = true;
+      static ETL_CONSTANT bool is_integer        = false;
+      static ETL_CONSTANT bool is_exact          = false;
+      static ETL_CONSTANT int  radix             = 2;
+      static ETL_CONSTANT bool has_infinity      = true;
+      static ETL_CONSTANT bool has_quiet_NaN     = ETL_HAS_NAN;
+      static ETL_CONSTANT bool has_signaling_NaN = ETL_HAS_NAN;
+      static ETL_CONSTANT bool has_denorm_loss   = false;
+      static ETL_CONSTANT bool is_iec559         = false;
+      static ETL_CONSTANT bool is_bounded        = true;
+      static ETL_CONSTANT bool is_modulo         = false;
+      static ETL_CONSTANT bool traps             = false;
+      static ETL_CONSTANT bool tinyness_before   = false;
+      static ETL_CONSTANT float_denorm_style has_denorm  = denorm_indeterminate;
+      static ETL_CONSTANT float_round_style  round_style = round_indeterminate;
+
+      static float round_error() { return float(0.5); }
+    };
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::is_specialized;
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::is_integer;
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::is_exact;
+
+    template <typename T>
+    ETL_CONSTANT int  floating_point_limits_common<T>::radix;
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::has_infinity;
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::has_quiet_NaN;
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::has_signaling_NaN;
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::has_denorm_loss;
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::is_iec559;
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::is_bounded;
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::traps;
+
+    template <typename T>
+    ETL_CONSTANT bool floating_point_limits_common<T>::tinyness_before;
+
+    template <typename T>
+    ETL_CONSTANT float_denorm_style floating_point_limits_common<T>::has_denorm;
+
+    template <typename T>
+    ETL_CONSTANT float_round_style floating_point_limits_common<T>::round_style;
+
+    //*********************************
+    // float
+    template <typename T = void>
+    struct floating_point_limits_float
+    {
+      static ETL_CONSTANT int digits         = FLT_MANT_DIG;
+      static ETL_CONSTANT int digits10       = FLT_DIG;
+      static ETL_CONSTANT int max_digits10   = ETL_LOG10_OF_2(FLT_MANT_DIG) + 2;
+
+      static ETL_CONSTANT int min_exponent   = FLT_MIN_EXP;
+      static ETL_CONSTANT int min_exponent10 = FLT_MIN_10_EXP;
+      static ETL_CONSTANT int max_exponent   = FLT_MAX_EXP;
+      static ETL_CONSTANT int max_exponent10 = FLT_MAX_10_EXP;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_float<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_float<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_float<T>::max_digits10;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_float<T>::min_exponent;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_float<T>::min_exponent10;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_float<T>::max_exponent;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_float<T>::max_exponent10;
+
+    //*********************************
+    // double
+    template <typename T = void>
+    struct floating_point_limits_double
+    {
+      static ETL_CONSTANT int digits         = DBL_MANT_DIG;
+      static ETL_CONSTANT int digits10       = DBL_DIG;
+      static ETL_CONSTANT int max_digits10   = ETL_LOG10_OF_2(DBL_MANT_DIG) + 2;
+
+      static ETL_CONSTANT int min_exponent   = DBL_MIN_EXP;
+      static ETL_CONSTANT int min_exponent10 = DBL_MIN_10_EXP;
+      static ETL_CONSTANT int max_exponent   = DBL_MAX_EXP;
+      static ETL_CONSTANT int max_exponent10 = DBL_MAX_10_EXP;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_double<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_double<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_double<T>::max_digits10;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_double<T>::min_exponent;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_double<T>::min_exponent10;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_double<T>::max_exponent;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_double<T>::max_exponent10;
+
+    //*********************************
+    // long double
+    template <typename T = void>
+    struct floating_point_limits_long_double
+    {
+      static ETL_CONSTANT int digits         = LDBL_MANT_DIG;
+      static ETL_CONSTANT int digits10       = LDBL_DIG;
+      static ETL_CONSTANT int max_digits10   = ETL_LOG10_OF_2(LDBL_MANT_DIG) + 2;
+
+      static ETL_CONSTANT int min_exponent   = LDBL_MIN_EXP;
+      static ETL_CONSTANT int min_exponent10 = LDBL_MIN_10_EXP;
+      static ETL_CONSTANT int max_exponent   = LDBL_MAX_EXP;
+      static ETL_CONSTANT int max_exponent10 = LDBL_MAX_10_EXP;
+    };
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_long_double<T>::digits;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_long_double<T>::digits10;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_long_double<T>::max_digits10;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_long_double<T>::min_exponent;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_long_double<T>::min_exponent10;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_long_double<T>::max_exponent;
+
+    template <typename T>
+    ETL_CONSTANT int floating_point_limits_long_double<T>::max_exponent10;
+  }
 
   //***************************************************************************
   // Default
@@ -179,18 +768,14 @@ namespace etl
   template <typename T>
   class numeric_limits<const volatile T> : public numeric_limits<T> { };
 
-  //***************************************************************************
+  //***********************************
   // bool
   template<>
-  class numeric_limits<bool> : public etl_integral_limits
+  class numeric_limits<bool> : public private_limits::integral_limits_common<>, 
+                               public private_limits::integral_limits_bool<>
   {
   public:
 
-    static ETL_CONSTANT int  digits    = 1;
-    static ETL_CONSTANT int  digits10  = 0;
-    static ETL_CONSTANT bool is_signed = false;
-    static ETL_CONSTANT bool is_modulo = false;
-
     static ETL_CONSTEXPR bool min() { return false; }
     static ETL_CONSTEXPR bool max() { return true; }
     static ETL_CONSTEXPR bool lowest() { return false; }
@@ -205,15 +790,11 @@ namespace etl
   //***************************************************************************
   // char
   template<>
-  class numeric_limits<char> : public etl_integral_limits
+  class numeric_limits<char> : public private_limits::integral_limits_common<>,
+                               public private_limits::integral_limits_char<>
   {
   public:
 
-    static ETL_CONSTANT int digits     = (CHAR_BIT * sizeof(char)) - (etl::is_signed<char>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10   = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = etl::is_signed<char>::value;
-    static ETL_CONSTANT bool is_modulo = false;
-
     static ETL_CONSTEXPR char min() { return char(CHAR_MIN); }
     static ETL_CONSTEXPR char max() { return char(CHAR_MAX); }
     static ETL_CONSTEXPR char lowest() { return char(CHAR_MIN); }
@@ -228,15 +809,11 @@ namespace etl
   //***************************************************************************
   // unsigned char
   template<>
-  class numeric_limits<unsigned char> : public etl_integral_limits
+  class numeric_limits<unsigned char> : public private_limits::integral_limits_common<>,
+                                        public private_limits::integral_limits_unsigned_char<>
   {
   public:
 
-    static ETL_CONSTANT int digits     = (CHAR_BIT * sizeof(unsigned char)) - (etl::is_signed<unsigned char>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10   = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = false;
-    static ETL_CONSTANT bool is_modulo = true;
-
     static ETL_CONSTEXPR unsigned char min() { return 0U; }
     static ETL_CONSTEXPR unsigned char max() { return UCHAR_MAX; }
     static ETL_CONSTEXPR unsigned char lowest() { return 0U; }
@@ -251,15 +828,11 @@ namespace etl
   //***************************************************************************
   // signed char
   template<>
-  class numeric_limits<signed char> : public etl_integral_limits
+  class numeric_limits<signed char> : public private_limits::integral_limits_common<>,
+                                      public private_limits::integral_limits_signed_char<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(char)) - (etl::is_signed<char>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = true;
-    static ETL_CONSTANT bool is_modulo = false;
-
     static ETL_CONSTEXPR signed char min() { return SCHAR_MIN; }
     static ETL_CONSTEXPR signed char max() { return SCHAR_MAX; }
     static ETL_CONSTEXPR signed char lowest() { return SCHAR_MIN; }
@@ -275,15 +848,11 @@ namespace etl
   //***************************************************************************
   // char8_t
   template<>
-  class numeric_limits<char8_t> : public etl_integral_limits
+  class numeric_limits<char8_t> : public private_limits::integral_limits_common<>,
+                                  public private_limits::integral_limits_char8_t<>
   {
   public:
-
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(char8_t)) - (etl::is_signed<char8_t>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = etl::is_signed<char8_t>::value;
-    static ETL_CONSTANT bool is_modulo = false;
-
+    
     static ETL_CONSTEXPR char8_t min() { return char8_t(CHAR_MIN); }
     static ETL_CONSTEXPR char8_t max() { return char8_t(CHAR_MAX); }
     static ETL_CONSTEXPR char8_t lowest() { return char8_t(CHAR_MIN); }
@@ -300,15 +869,11 @@ namespace etl
   //***************************************************************************
   // char16_t
   template<>
-  class numeric_limits<char16_t> : public etl_integral_limits
+  class numeric_limits<char16_t> : public private_limits::integral_limits_common<>,
+                                   public private_limits::integral_limits_char16_t<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(char16_t)) - (etl::is_signed<char16_t>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = false;
-    static ETL_CONSTANT bool is_modulo = true;
-
     static ETL_CONSTEXPR char16_t min() { return 0U; }
     static ETL_CONSTEXPR char16_t max() { return UINT_LEAST16_MAX; }
     static ETL_CONSTEXPR char16_t lowest() { return 0U; }
@@ -325,15 +890,11 @@ namespace etl
   //***************************************************************************
   // char32_t
   template<>
-  class numeric_limits<char32_t> : public etl_integral_limits
+  class numeric_limits<char32_t> : public private_limits::integral_limits_common<>,
+                                   public private_limits::integral_limits_char32_t<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(char32_t)) - (etl::is_signed<char32_t>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = false;
-    static ETL_CONSTANT bool is_modulo = true;
-
     static ETL_CONSTEXPR char32_t min() { return 0U; }
     static ETL_CONSTEXPR char32_t max() { return UINT_LEAST32_MAX; }
     static ETL_CONSTEXPR char32_t lowest() { return 0U; }
@@ -349,14 +910,11 @@ namespace etl
   //***************************************************************************
   // wchar_t
   template<>
-  class numeric_limits<wchar_t> : public etl_integral_limits
+  class numeric_limits<wchar_t> : public private_limits::integral_limits_common<>,
+                                  public private_limits::integral_limits_wchar_t<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(wchar_t)) - (etl::is_signed<wchar_t>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = etl::is_signed<wchar_t>::value;
-    static ETL_CONSTANT bool is_modulo = etl::is_unsigned<wchar_t>::value;
     static ETL_CONSTEXPR wchar_t min() { return WCHAR_MIN; }
     static ETL_CONSTEXPR wchar_t max() { return WCHAR_MAX; }
     static ETL_CONSTEXPR wchar_t lowest() { return WCHAR_MIN; }
@@ -371,15 +929,11 @@ namespace etl
   //***************************************************************************
   // short
   template<>
-  class numeric_limits<short> : public etl_integral_limits
+  class numeric_limits<short> : public private_limits::integral_limits_common<>,
+                                public private_limits::integral_limits_short<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(short)) - (etl::is_signed<short>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = true;
-    static ETL_CONSTANT bool is_modulo = false;
-
     static ETL_CONSTEXPR short min() { return SHRT_MIN; }
     static ETL_CONSTEXPR short max() { return SHRT_MAX; }
     static ETL_CONSTEXPR short lowest() { return SHRT_MIN; }
@@ -394,15 +948,11 @@ namespace etl
   //***************************************************************************
   // unsigned short
   template<>
-  class numeric_limits<unsigned short> : public etl_integral_limits
+  class numeric_limits<unsigned short> : public private_limits::integral_limits_common<>,
+                                         public private_limits::integral_limits_unsigned_short<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(unsigned short)) - (etl::is_signed<unsigned short>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = false;
-    static ETL_CONSTANT bool is_modulo = true;
-
     static ETL_CONSTEXPR unsigned short min() { return 0U; }
     static ETL_CONSTEXPR unsigned short max() { return USHRT_MAX; }
     static ETL_CONSTEXPR unsigned short lowest() { return 0U; }
@@ -412,21 +962,16 @@ namespace etl
     static ETL_CONSTEXPR unsigned short infinity() { return 0U; }
     static ETL_CONSTEXPR unsigned short quiet_NaN() { return 0U; }
     static ETL_CONSTEXPR unsigned short signaling_NaN() { return 0U; }
-
   };
 
   //***************************************************************************
   // int
   template<>
-  class numeric_limits<int> : public etl_integral_limits
+  class numeric_limits<int> : public private_limits::integral_limits_common<>,
+                              public private_limits::integral_limits_int<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(int)) - (etl::is_signed<int>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = true;
-    static ETL_CONSTANT bool is_modulo = false;
-
     static ETL_CONSTEXPR int min() { return INT_MIN; }
     static ETL_CONSTEXPR int max() { return INT_MAX; }
     static ETL_CONSTEXPR int lowest() { return INT_MIN; }
@@ -441,15 +986,11 @@ namespace etl
   //***************************************************************************
   // unsigned int
   template<>
-  class numeric_limits<unsigned int> : public etl_integral_limits
+  class numeric_limits<unsigned int> : public private_limits::integral_limits_common<>,
+                                       public private_limits::integral_limits_unsigned_int<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(unsigned int)) - (etl::is_signed<unsigned int>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = false;
-    static ETL_CONSTANT bool is_modulo = true;
-
     static ETL_CONSTEXPR unsigned int min() { return 0U; }
     static ETL_CONSTEXPR unsigned int max() { return UINT_MAX; }
     static ETL_CONSTEXPR unsigned int lowest() { return 0U; }
@@ -464,15 +1005,11 @@ namespace etl
   //***************************************************************************
   // long
   template<>
-  class numeric_limits<long> : public etl_integral_limits
+  class numeric_limits<long> : public private_limits::integral_limits_common<>,
+                               public private_limits::integral_limits_long<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(long)) - (etl::is_signed<long>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = true;
-    static ETL_CONSTANT bool is_modulo = false;
-
     static ETL_CONSTEXPR long min() { return LONG_MIN; }
     static ETL_CONSTEXPR long max() { return LONG_MAX; }
     static ETL_CONSTEXPR long lowest() { return LONG_MIN; }
@@ -487,15 +1024,11 @@ namespace etl
   //***************************************************************************
   // unsigned long
   template<>
-  class numeric_limits<unsigned long> : public etl_integral_limits
+  class numeric_limits<unsigned long> : public private_limits::integral_limits_common<>,
+                                        public private_limits::integral_limits_unsigned_long<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(unsigned long)) - (etl::is_signed<unsigned long>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = false;
-    static ETL_CONSTANT bool is_modulo = true;
-
     static ETL_CONSTEXPR unsigned long min() { return 0U; }
     static ETL_CONSTEXPR unsigned long max() { return ULONG_MAX; }
     static ETL_CONSTEXPR unsigned long lowest() { return 0U; }
@@ -510,15 +1043,11 @@ namespace etl
   //***************************************************************************
   // long long
   template<>
-  class numeric_limits<long long> : public etl_integral_limits
+  class numeric_limits<long long> : public private_limits::integral_limits_common<>,
+                                    public private_limits::integral_limits_long_long<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(long long)) - (etl::is_signed<long long>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = true;
-    static ETL_CONSTANT bool is_modulo = false;
-
     static ETL_CONSTEXPR long long min() { return LLONG_MIN; }
     static ETL_CONSTEXPR long long max() { return LLONG_MAX; }
     static ETL_CONSTEXPR long long lowest() { return LLONG_MIN; }
@@ -533,15 +1062,11 @@ namespace etl
   //***************************************************************************
   // unsigned long long
   template<>
-  class numeric_limits<unsigned long long> : public etl_integral_limits
+  class numeric_limits<unsigned long long> : public private_limits::integral_limits_common<>,
+                                             public private_limits::integral_limits_unsigned_long_long<>
   {
   public:
 
-    static ETL_CONSTANT int digits = (CHAR_BIT * sizeof(unsigned long long)) - (etl::is_signed<unsigned long long>::value ? 1 : 0);
-    static ETL_CONSTANT int digits10 = ETL_LOG10_OF_2(digits);
-    static ETL_CONSTANT bool is_signed = false;
-    static ETL_CONSTANT bool is_modulo = true;
-
     static ETL_CONSTEXPR unsigned long long min() { return 0U; }
     static ETL_CONSTEXPR unsigned long long max() { return ULLONG_MAX; }
     static ETL_CONSTEXPR unsigned long long lowest() { return 0U; }
@@ -556,7 +1081,8 @@ namespace etl
   //***************************************************************************
   // float
   template<>
-  class numeric_limits<float> : public etl_floating_point_limits
+  class numeric_limits<float> : public private_limits::floating_point_limits_common<>,
+                                public private_limits::floating_point_limits_float<>
   {
   public:
 
@@ -568,21 +1094,13 @@ namespace etl
     static ETL_CONSTEXPR float infinity() { return HUGE_VALF; }
     static float quiet_NaN() { return ETL_NANF; }
     static float signaling_NaN() { return ETL_NANF; }
-
-    static ETL_CONSTANT int digits       = FLT_MANT_DIG;
-    static ETL_CONSTANT int digits10     = FLT_DIG;
-    static ETL_CONSTANT int max_digits10 = ETL_LOG10_OF_2(FLT_MANT_DIG) + 2;
-
-    static ETL_CONSTANT int min_exponent   = FLT_MIN_EXP;
-    static ETL_CONSTANT int min_exponent10 = FLT_MIN_10_EXP;
-    static ETL_CONSTANT int max_exponent   = FLT_MAX_EXP;
-    static ETL_CONSTANT int max_exponent10 = FLT_MAX_10_EXP;
   };
 
   //***************************************************************************
   // double
   template<>
-  class numeric_limits<double> : public etl_floating_point_limits
+  class numeric_limits<double> : public private_limits::floating_point_limits_common<>,
+                                 public private_limits::floating_point_limits_double<>
   {
   public:
 
@@ -594,21 +1112,13 @@ namespace etl
     static ETL_CONSTEXPR double infinity() { return HUGE_VAL; }
     static double quiet_NaN() { return ETL_NAN; }
     static double signaling_NaN() { return ETL_NAN; }
-
-    static ETL_CONSTANT int digits       = DBL_MANT_DIG;
-    static ETL_CONSTANT int digits10     = DBL_DIG;
-    static ETL_CONSTANT int max_digits10 = ETL_LOG10_OF_2(DBL_MANT_DIG) + 2;
-
-    static ETL_CONSTANT int min_exponent   = DBL_MIN_EXP;
-    static ETL_CONSTANT int min_exponent10 = DBL_MIN_10_EXP;
-    static ETL_CONSTANT int max_exponent   = DBL_MAX_EXP;
-    static ETL_CONSTANT int max_exponent10 = DBL_MAX_10_EXP;
   };
 
   //***************************************************************************
   // long double
   template<>
-  class numeric_limits<long double> : public etl_floating_point_limits
+  class numeric_limits<long double> : public private_limits::floating_point_limits_common<>,
+                                      public private_limits::floating_point_limits_long_double<>
   {
   public:
 
@@ -620,15 +1130,6 @@ namespace etl
     static ETL_CONSTEXPR long double infinity() { return HUGE_VALL; }
     static long double quiet_NaN() { return ETL_NANL; }
     static long double signaling_NaN() { return ETL_NANL; }
-
-    static ETL_CONSTANT int digits       = LDBL_MANT_DIG;
-    static ETL_CONSTANT int digits10     = LDBL_DIG;
-    static ETL_CONSTANT int max_digits10 = ETL_LOG10_OF_2(LDBL_MANT_DIG) + 2;
-
-    static ETL_CONSTANT int min_exponent   = LDBL_MIN_EXP;
-    static ETL_CONSTANT int min_exponent10 = LDBL_MIN_10_EXP;
-    static ETL_CONSTANT int max_exponent   = LDBL_MAX_EXP;
-    static ETL_CONSTANT int max_exponent10 = LDBL_MAX_10_EXP;
   };
 }
 
@@ -654,10 +1155,15 @@ namespace etl
     denorm_present       = std::denorm_present
   };
 
+#if ETL_USING_CPP11
+  template <typename T>
+  using numeric_limits = std::numeric_limits<T>;
+#else
   template <typename T>
   class numeric_limits : public std::numeric_limits<T>
   {
   };
+#endif
 }
 #endif
 
diff --git a/include/etl/list.h b/include/etl/list.h
index c5e78631..43497059 100644
--- a/include/etl/list.h
+++ b/include/etl/list.h
@@ -689,7 +689,7 @@ namespace etl
     //*************************************************************************
     const_iterator end() const
     {
-      return const_iterator(static_cast<const data_node_t&>(terminal_node));
+      return const_iterator(terminal_node);
     }
 
     //*************************************************************************
@@ -705,7 +705,7 @@ namespace etl
     //*************************************************************************
     const_iterator cend() const
     {
-      return const_iterator(static_cast<const data_node_t&>(terminal_node));
+      return const_iterator(terminal_node);
     }
 
     //*************************************************************************
@@ -721,7 +721,7 @@ namespace etl
     //*************************************************************************
     const_reverse_iterator rbegin() const
     {
-      return const_reverse_iterator(static_cast<const data_node_t&>(terminal_node));
+      return const_reverse_iterator(terminal_node);
     }
 
     //*************************************************************************
@@ -745,7 +745,7 @@ namespace etl
     //*************************************************************************
     const_reverse_iterator crbegin() const
     {
-      return const_reverse_iterator(static_cast<const data_node_t&>(terminal_node));
+      return const_reverse_iterator(terminal_node);
     }
 
     //*************************************************************************
@@ -2167,6 +2167,9 @@ namespace etl
     etl::pool<typename etl::ilist<T>::data_node_t, MAX_SIZE> node_pool;
   };
 
+  template <typename T, const size_t MAX_SIZE_>
+  ETL_CONSTANT size_t list<T, MAX_SIZE_>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/map.h b/include/etl/map.h
index 3c0ba2b5..30773032 100644
--- a/include/etl/map.h
+++ b/include/etl/map.h
@@ -2718,6 +2718,9 @@ namespace etl
     etl::pool<typename etl::imap<TKey, TValue, TCompare>::Data_Node, MAX_SIZE> node_pool;
   };
 
+  template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t map<TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/math_constants.h b/include/etl/math_constants.h
index 7dd33247..dd99f147 100644
--- a/include/etl/math_constants.h
+++ b/include/etl/math_constants.h
@@ -33,19 +33,57 @@ SOFTWARE.
 
 namespace etl
 {
-  namespace math
+  namespace private_math_constants
   {
-    ETL_CONSTANT double pi               = 3.14159265358979;
-    ETL_CONSTANT double pi_reciprocal    = 0.31830988618379;
-    ETL_CONSTANT double pi_squared       = 9.86960440108936;
-    ETL_CONSTANT double e                = 2.71828182845905;
-    ETL_CONSTANT double e_reciprocal     = 0.36787944117144;
-    ETL_CONSTANT double e_squared        = 7.38905609893065;
-    ETL_CONSTANT double root2            = 1.41421356237310;
-    ETL_CONSTANT double root2_reciprocal = 0.70710678118655;
-    ETL_CONSTANT double euler            = 0.57721566490153;
-    ETL_CONSTANT double golden_ratio     = 1.61803398874989;
+    template <typename T = void>
+    struct math_helper
+    {
+      static ETL_CONSTANT double pi               = 3.14159265358979;
+      static ETL_CONSTANT double pi_reciprocal    = 0.31830988618379;
+      static ETL_CONSTANT double pi_squared       = 9.86960440108936;
+      static ETL_CONSTANT double e                = 2.71828182845905;
+      static ETL_CONSTANT double e_reciprocal     = 0.36787944117144;
+      static ETL_CONSTANT double e_squared        = 7.38905609893065;
+      static ETL_CONSTANT double root2            = 1.41421356237310;
+      static ETL_CONSTANT double root2_reciprocal = 0.70710678118655;
+      static ETL_CONSTANT double euler            = 0.57721566490153;
+      static ETL_CONSTANT double golden_ratio     = 1.61803398874989;
+    };
+
+    template <typename T>
+    ETL_CONSTANT double math_helper<T>::pi;
+
+    template <typename T>
+    ETL_CONSTANT double math_helper<T>::pi_reciprocal;
+
+    template <typename T>
+    ETL_CONSTANT double math_helper<T>::pi_squared;
+
+    template <typename T>
+    ETL_CONSTANT double math_helper<T>::e;
+
+    template <typename T>
+    ETL_CONSTANT double math_helper<T>::e_reciprocal;
+    
+    template <typename T>
+    ETL_CONSTANT double math_helper<T>::e_squared;
+    
+    template <typename T>
+    ETL_CONSTANT double math_helper<T>::root2;
+    
+    template <typename T>
+    ETL_CONSTANT double math_helper<T>::root2_reciprocal;
+    
+    template <typename T>
+    ETL_CONSTANT double math_helper<T>::euler;
+    
+    template <typename T>
+    ETL_CONSTANT double math_helper<T>::golden_ratio;
   }
+
+  struct math : public private_math_constants::math_helper<>
+  {
+  };
 }
 
 #endif
diff --git a/include/etl/mem_cast.h b/include/etl/mem_cast.h
index d611dab2..33b79021 100644
--- a/include/etl/mem_cast.h
+++ b/include/etl/mem_cast.h
@@ -315,6 +315,12 @@ namespace etl
     etl::uninitialized_buffer<Size, 1U, Alignment> buffer;
   };
 
+  template <size_t Size_, size_t Alignment_>
+  ETL_CONSTANT size_t mem_cast<Size_, Alignment_>::Size;
+
+  template <size_t Size_, size_t Alignment_>
+  ETL_CONSTANT size_t mem_cast<Size_, Alignment_>::Alignment;
+
   //*****************************************************************************
   /// mem_cast_ptr
   //*****************************************************************************
diff --git a/include/etl/memory.h b/include/etl/memory.h
index 4e39ca3a..38e9889c 100644
--- a/include/etl/memory.h
+++ b/include/etl/memory.h
@@ -2146,6 +2146,15 @@ namespace etl
 #endif
   };
 
+  template <size_t VObject_Size, size_t VN_Objects, size_t VAlignment>
+  ETL_CONSTANT size_t uninitialized_buffer<VObject_Size, VN_Objects, VAlignment>::Object_Size;
+
+  template <size_t VObject_Size, size_t VN_Objects, size_t VAlignment>
+  ETL_CONSTANT size_t uninitialized_buffer<VObject_Size, VN_Objects, VAlignment>::N_Objects;
+
+  template <size_t VObject_Size, size_t VN_Objects, size_t VAlignment>
+  ETL_CONSTANT size_t uninitialized_buffer<VObject_Size, VN_Objects, VAlignment>::Alignment;
+
   //***************************************************************************
   /// Declares an aligned buffer of VN_Objects as if they were type T.
   ///\ingroup alignment
@@ -2235,6 +2244,15 @@ namespace etl
 #endif
   };
 
+  template <typename T, size_t VN_Objects>
+  ETL_CONSTANT size_t uninitialized_buffer_of<T, VN_Objects>::Object_Size;
+
+  template <typename T, size_t VN_Objects>
+  ETL_CONSTANT size_t uninitialized_buffer_of<T, VN_Objects>::N_Objects;
+
+  template <typename T, size_t VN_Objects>
+  ETL_CONSTANT size_t uninitialized_buffer_of<T, VN_Objects>::Alignment;
+
 #if ETL_USING_CPP11
   template <typename T, size_t N_Objects>
   using uninitialized_buffer_of_t = typename uninitialized_buffer_of<T, N_Objects>::buffer;
diff --git a/include/etl/message_packet.h b/include/etl/message_packet.h
index cf5e4442..d5130974 100644
--- a/include/etl/message_packet.h
+++ b/include/etl/message_packet.h
@@ -387,7 +387,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -680,7 +680,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -971,7 +971,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -1260,7 +1260,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -1546,7 +1546,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -1827,7 +1827,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -2106,7 +2106,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -2383,7 +2383,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -2657,7 +2657,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -2926,7 +2926,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -3193,7 +3193,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -3458,7 +3458,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -3720,7 +3720,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -3977,7 +3977,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -4232,7 +4232,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
@@ -4485,7 +4485,7 @@ namespace etl
     template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value &&
                                                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
                                                                     !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1>::value, int>::type>
-    explicit message_packet(TMessage&& msg)
+    explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
diff --git a/include/etl/multimap.h b/include/etl/multimap.h
index cf4639a7..fb14bba1 100644
--- a/include/etl/multimap.h
+++ b/include/etl/multimap.h
@@ -2438,6 +2438,9 @@ namespace etl
     etl::pool<typename etl::imultimap<TKey, TValue, TCompare>::Data_Node, MAX_SIZE> node_pool;
   };
 
+  template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t multimap<TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/multiset.h b/include/etl/multiset.h
index 92d33796..5494792c 100644
--- a/include/etl/multiset.h
+++ b/include/etl/multiset.h
@@ -2420,6 +2420,9 @@ namespace etl
     etl::pool<typename etl::imultiset<TKey, TCompare>::Data_Node, MAX_SIZE> node_pool;
   };
 
+  template <typename TKey, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t multiset<TKey, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/parameter_pack.h b/include/etl/parameter_pack.h
index e5760453..7f30a82c 100644
--- a/include/etl/parameter_pack.h
+++ b/include/etl/parameter_pack.h
@@ -121,9 +121,19 @@ namespace etl
     using type_from_index_t = typename type_from_index<I>::type;
   };
 
+  //***********************************
   template <size_t Index, typename... TTypes>
   using parameter_pack_t = typename etl::parameter_pack<TTypes...>::template type_from_index_t<Index>;
 
+  //***********************************
+  template <typename... TTypes>
+  constexpr size_t parameter_pack<TTypes...>::size;
+
+  //***********************************
+  template <typename... TTypes>
+  template <typename T>
+  constexpr size_t parameter_pack<TTypes...>::template index_of_type<T>::value;
+
 #if ETL_USING_CPP17
   template <typename T, typename... TTypes>
   inline constexpr size_t parameter_pack_v = etl::parameter_pack<TTypes...>::template index_of_type<T>::value;
diff --git a/include/etl/permutations.h b/include/etl/permutations.h
index 3b5b69c0..12fcbec7 100644
--- a/include/etl/permutations.h
+++ b/include/etl/permutations.h
@@ -49,6 +49,9 @@ namespace etl
     static ETL_CONSTANT size_t value = NV * permutations<NV - 1, KV - 1>::value;
   };
 
+  template <const size_t NV, const size_t KV>
+  ETL_CONSTANT size_t permutations<NV, KV>::value;
+
   //***************************************************************************
   /// Calculates permutations.
   /// Specialisation for KV == 0.
@@ -59,6 +62,9 @@ namespace etl
     static ETL_CONSTANT size_t value = 1UL;
   };
 
+  template <const size_t NV>
+  ETL_CONSTANT size_t permutations<NV, 0>::value;
+
 #if ETL_USING_CPP17
   template <size_t NV, size_t KV>
   inline constexpr size_t permutations_v = permutations<NV, KV>::value;
diff --git a/include/etl/poly_span.h b/include/etl/poly_span.h
index 79d3f32d..1d654529 100644
--- a/include/etl/poly_span.h
+++ b/include/etl/poly_span.h
@@ -611,6 +611,9 @@ namespace etl
     size_t  element_size;
   };
 
+  template <typename TBase, size_t Extent>
+  ETL_CONSTANT size_t poly_span<TBase, Extent>::extent;
+
   //***************************************************************************
   /// Poly Span - Dynamic Extent
   //***************************************************************************
@@ -984,6 +987,9 @@ protected:
     size_t  span_extent;
   };
 
+  template <typename TBase>
+  ETL_CONSTANT size_t poly_span<TBase, etl::dynamic_extent>::extent;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
@@ -1028,8 +1034,8 @@ protected:
   {
     size_t operator()(const etl::poly_span<TBase, Extent>& view) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&view[0]),
-                                                     reinterpret_cast<const uint8_t*>(&view[view.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(view.data()),
+                                                     reinterpret_cast<const uint8_t*>(view.data() + view.size()));
     }
   };
 #endif
diff --git a/include/etl/power.h b/include/etl/power.h
index 7816dd88..9ca4f0f0 100644
--- a/include/etl/power.h
+++ b/include/etl/power.h
@@ -63,6 +63,9 @@ namespace etl
     static ETL_CONSTANT private_power::type value = NV * power<NV, POWER - 1>::value;
   };
 
+  template <const size_t NV, const size_t POWER>
+  ETL_CONSTANT private_power::type power<NV, POWER>::value;
+
   //***************************************************************************
   /// Calculates powers.
   ///\note Only supports positive N.
@@ -74,6 +77,9 @@ namespace etl
     static ETL_CONSTANT private_power::type value = 1;
   };
 
+  template <const size_t NV>
+  ETL_CONSTANT private_power::type power<NV, 0>::value;
+
 #if ETL_USING_CPP17
   template <size_t NV, size_t POWER>
   inline constexpr size_t power_v = power<NV, POWER>::value;
@@ -203,6 +209,9 @@ namespace etl
     static ETL_CONSTANT bool value = false;
   };
 
+  template <const size_t NV>
+  ETL_CONSTANT bool is_power_of_2<NV>::value;
+
 #if ETL_USING_CPP17
   template <size_t NV>
   inline constexpr size_t is_power_of_2_v = is_power_of_2<NV>::value;
diff --git a/include/etl/priority_queue.h b/include/etl/priority_queue.h
index 46be2901..d4222090 100644
--- a/include/etl/priority_queue.h
+++ b/include/etl/priority_queue.h
@@ -526,6 +526,9 @@ namespace etl
     }
 #endif
   };
+
+  template <typename T, const size_t SIZE, typename TContainer, typename TCompare>
+  ETL_CONSTANT typename priority_queue<T, SIZE, TContainer, TCompare>::size_type priority_queue<T, SIZE, TContainer, TCompare>::MAX_SIZE;
 }
 
 #endif
diff --git a/include/etl/private/bitset_legacy.h b/include/etl/private/bitset_legacy.h
index 775012b7..e03135ce 100644
--- a/include/etl/private/bitset_legacy.h
+++ b/include/etl/private/bitset_legacy.h
@@ -183,6 +183,15 @@ namespace etl
         return p_bitset->test(position);
       }
 
+      //*******************************
+      /// Copy constructor.
+      //*******************************
+      bit_reference(const bit_reference& other)
+        : p_bitset(other.p_bitset)
+        , position(other.position)
+      {
+      }
+
       //*******************************
       /// Assignment operator.
       //*******************************
@@ -1064,6 +1073,12 @@ namespace etl
 #endif
   };
 
+  ETL_CONSTANT ibitset::element_type ibitset::ALL_SET;
+
+  ETL_CONSTANT ibitset::element_type ibitset::ALL_CLEAR;
+
+  ETL_CONSTANT size_t ibitset::Bits_Per_Element;
+
   //*************************************************************************
   /// The class emulates an array of bool elements, but optimized for space allocation.
   /// Will accommodate any number of bits.
@@ -1429,6 +1444,12 @@ namespace etl
     element_type data[Array_Size > 0U ? Array_Size : 1U];
   };
 
+  template <const size_t MaxN>
+  ETL_CONSTANT size_t bitset<MaxN>::ALLOCATED_BITS;
+  
+  template <const size_t MaxN>
+  ETL_CONSTANT size_t bitset<MaxN>::Allocated_Bits;
+
   //***************************************************************************
   /// operator &
   ///\ingroup bitset
diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index d636ce60..2b01ecc3 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -76,11 +76,15 @@ SOFTWARE.
 
 namespace etl
 {
+  template <typename T = void>
   struct bitset_constants
   {
     static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
   };
 
+  template <typename T>
+  ETL_CONSTANT size_t bitset_constants<T>::npos;
+
   //***************************************************************************
   /// Exception base for bitset
   ///\ingroup bitset
@@ -114,7 +118,7 @@ namespace etl
   ///\ingroup bitset
   //*************************************************************************
   template <typename TElement>
-  class bitset_impl : public bitset_constants
+  class bitset_impl : public bitset_constants<>
   {
   public:
 
@@ -795,9 +799,18 @@ namespace etl
     }
   };
  
+  template <typename TElement>
+  ETL_CONSTANT size_t bitset_impl<TElement>::Bits_Per_Element;
+
+  template <typename TElement>
+  ETL_CONSTANT typename bitset_impl<TElement>::element_type bitset_impl<TElement>::All_Set_Element;
+
+  template <typename TElement>
+  ETL_CONSTANT typename bitset_impl<TElement>::element_type bitset_impl<TElement>::All_Clear_Element;
+
   //***************************************************************************
   template <size_t Active_Bits = 0U,
-            typename TElement = void,
+            typename TElement = char,
             bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
   class bitset;
 
@@ -806,7 +819,7 @@ namespace etl
   /// Just defines 'npos'.
   //***************************************************************************
   template <>
-  class bitset<0U, void, true> : public bitset_constants
+  class bitset<0U, char, true> : public bitset_constants<>
   {
   };
 
@@ -814,7 +827,7 @@ namespace etl
   /// Specialisation for zero bits.
   //***************************************************************************
   template <>
-  class bitset<0U, void, false> : public bitset_constants
+  class bitset<0U, char, false> : public bitset_constants<>
   {
   };
 
@@ -823,7 +836,7 @@ namespace etl
   /// same size as the number of active bits.
   //***************************************************************************
   template <size_t   Active_Bits, typename TElement>
-  class bitset<Active_Bits, TElement, true> : public bitset_constants
+  class bitset<Active_Bits, TElement, true> : public bitset_constants<>
   {
   public:
 
@@ -853,6 +866,15 @@ namespace etl
 
       friend class bitset;
 
+      //*******************************
+      /// Copy constructor.
+      //*******************************
+      ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
+        : p_bitset(other.p_bitset)
+        , position(other.position)
+      {
+      }
+
       //*******************************
       /// Conversion operator.
       //*******************************
@@ -1663,11 +1685,32 @@ namespace etl
     element_type buffer;
   };
 
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Bits_Per_Element;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Number_Of_Elements;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Allocated_Bits;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::All_Set_Element;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::All_Clear_Element;
+  
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Top_Mask_Shift;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::Top_Mask;
+
   //*************************************************************************
   /// The specialisation that uses an array of the default element type.
   //*************************************************************************
   template <size_t Active_Bits, typename TElement>
-  class bitset<Active_Bits, TElement, false> : public bitset_constants
+  class bitset<Active_Bits, TElement, false> : public bitset_constants<>
   {
   private:
 
@@ -1708,6 +1751,15 @@ namespace etl
 
       friend class bitset;
 
+      //*******************************
+      /// Copy constructor.
+      //*******************************
+      ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
+        : p_bitset(other.p_bitset)
+        , position(other.position)
+      {
+      }
+
       //*******************************
       /// Conversion operator.
       //*******************************
@@ -2312,6 +2364,27 @@ namespace etl
     element_type buffer[Number_Of_Elements > 0U ? Number_Of_Elements : 1U];
   };
 
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Bits_Per_Element;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Number_Of_Elements;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Allocated_Bits;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::All_Set_Element;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::All_Clear_Element;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Top_Mask_Shift;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::Top_Mask;
+
   //***************************************************************************
   /// operator &
   ///\ingroup bitset
@@ -2375,8 +2448,8 @@ namespace etl
 {
   //***************************************************************************
   template <size_t Active_Bits = 0U,
-    typename TElement = void,
-    bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
+            typename TElement = char,
+            bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
     class bitset_ext;
 
   //***************************************************************************
@@ -2384,7 +2457,7 @@ namespace etl
   /// Just defines 'npos'.
   //***************************************************************************
   template <>
-  class bitset_ext<0U, void, true> : public bitset_constants
+  class bitset_ext<0U, char, true> : public bitset_constants<>
   {
   };
 
@@ -2392,7 +2465,7 @@ namespace etl
   /// Specialisation for zero bits.
   //***************************************************************************
   template <>
-  class bitset_ext<0U, void, false> : public bitset_constants
+  class bitset_ext<0U, char, false> : public bitset_constants<>
   {
   };
 
@@ -2401,7 +2474,7 @@ namespace etl
   /// same size as the number of active bits.
   //***************************************************************************
   template <size_t   Active_Bits, typename TElement>
-  class bitset_ext<Active_Bits, TElement, true> : public bitset_constants
+  class bitset_ext<Active_Bits, TElement, true> : public bitset_constants<>
   {
   public:
 
@@ -2433,6 +2506,15 @@ namespace etl
 
       friend class bitset_ext;
 
+      //*******************************
+      /// Copy constructor.
+      //*******************************
+      ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
+        : p_bitset(other.p_bitset)
+        , position(other.position)
+      {
+      }
+
       //*******************************
       /// Conversion operator.
       //*******************************
@@ -3240,11 +3322,32 @@ namespace etl
     element_type* pbuffer;
   };
 
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Bits_Per_Element;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Number_Of_Elements;
+  
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Allocated_Bits;
+  
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::All_Set_Element;
+    
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::All_Clear_Element;
+    
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Top_Mask_Shift;
+  
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::Top_Mask;
+
   //*************************************************************************
   /// The specialisation that uses an array of the default element type.
   //*************************************************************************
   template <size_t Active_Bits, typename TElement>
-  class bitset_ext<Active_Bits, TElement, false> : public bitset_constants
+  class bitset_ext<Active_Bits, TElement, false> : public bitset_constants<>
   {
   private:
 
@@ -3287,6 +3390,15 @@ namespace etl
 
       friend class bitset_ext;
 
+      //*******************************
+      /// Copy constructor
+      //*******************************
+      ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
+        : p_bitset(other.p_bitset)
+        , position(other.position)
+      {
+      }
+
       //*******************************
       /// Conversion operator.
       //*******************************
@@ -3891,6 +4003,27 @@ namespace etl
     element_type* pbuffer;
   };
 
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Bits_Per_Element;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Number_Of_Elements;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Allocated_Bits;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::All_Set_Element;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::All_Clear_Element;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Top_Mask_Shift;
+
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::Top_Mask;
+
   //***************************************************************************
   /// operator !=
   ///\ingroup bitset
diff --git a/include/etl/private/choose_namespace.h b/include/etl/private/choose_namespace.h
index 44b0c440..494d030f 100644
--- a/include/etl/private/choose_namespace.h
+++ b/include/etl/private/choose_namespace.h
@@ -33,6 +33,7 @@ SOFTWARE.
 
 #undef ETL_OR_STD
 #undef ETL_OR_STD11
+#undef ETL_OR_STD14
 
 #if ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST)
   // If we're not using the STL and we are not unit testing, then use the ETL's definitions under the etl namespace
@@ -58,4 +59,28 @@ SOFTWARE.
   #define ETL_USING_ETL11_NAMESPACE 0
 #endif
 
+#if (ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST)) || ETL_CPP14_NOT_SUPPORTED
+  // If we're not using the STL and we are not unit testing or C++14 is not supported, then use the ETL's definitions under the etl namespace
+  #define ETL_OR_STD14 etl
+  #define ETL_USING_STD14_NAMESPACE 0
+  #define ETL_USING_ETL14_NAMESPACE 1
+#else
+  // We will use the STL's definitions under the std namespace
+  #define ETL_OR_STD14 std
+  #define ETL_USING_STD14_NAMESPACE 1
+  #define ETL_USING_ETL14_NAMESPACE 0
+#endif
+
+#if (ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST)) || ETL_CPP17_NOT_SUPPORTED
+  // If we're not using the STL and we are not unit testing or C++17 is not supported, then use the ETL's definitions under the etl namespace
+  #define ETL_OR_STD17 etl
+  #define ETL_USING_STD17_NAMESPACE 0
+  #define ETL_USING_ETL17_NAMESPACE 1
+#else
+  // We will use the STL's definitions under the std namespace
+  #define ETL_OR_STD17 std
+  #define ETL_USING_STD17_NAMESPACE 1
+  #define ETL_USING_ETL17_NAMESPACE 0
+#endif
+
 #endif
diff --git a/include/etl/private/crc_implementation.h b/include/etl/private/crc_implementation.h
index 8e450544..d94f0f18 100644
--- a/include/etl/private/crc_implementation.h
+++ b/include/etl/private/crc_implementation.h
@@ -66,6 +66,9 @@ namespace etl
                                                        : TAccumulator(Do_Poly ? (Entry << 1U) ^ Polynomial : (Entry << 1U));
     };
 
+    template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, TAccumulator Entry>
+    ETL_CONSTANT TAccumulator crc_partial_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Entry>::value;
+
     //*****************************************************************************
     /// CRC Table Entry
     //*****************************************************************************
@@ -89,6 +92,15 @@ namespace etl
                                                crc_partial_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Entry>::value>::value;
     };
 
+    template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
+    ETL_CONSTANT size_t crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 2U>::Shift_Bits;
+
+    template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
+    ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 2U>::Entry;
+
+    template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
+    ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 2U>::value;
+
     //*********************************
     // Chunk bit size of 4.
     template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
@@ -105,6 +117,15 @@ namespace etl
                                                crc_partial_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Entry>::value>::value>::value>::value;
     };
 
+    template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
+    ETL_CONSTANT size_t crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 4U>::Shift_Bits;
+
+    template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
+    ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 4U>::Entry;
+
+    template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
+    ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 4U>::value;
+
     //*********************************
     // Chunk bit size of 8.
     template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
@@ -125,6 +146,15 @@ namespace etl
                                                crc_partial_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Entry>::value>::value>::value>::value>::value>::value>::value>::value;
     };
 
+    template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
+    ETL_CONSTANT size_t crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 8U>::Shift_Bits;
+
+    template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
+    ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 8U>::Entry;
+
+    template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
+    ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 8U>::value;
+
     //*****************************************************************************
     /// CRC Update Chunk
     //*****************************************************************************
diff --git a/include/etl/private/crc_parameters.h b/include/etl/private/crc_parameters.h
index 8ffb9242..72cd1ef5 100644
--- a/include/etl/private/crc_parameters.h
+++ b/include/etl/private/crc_parameters.h
@@ -53,6 +53,21 @@ namespace etl
       static ETL_CONSTANT size_t       Accumulator_Bits = etl::integral_limits<accumulator_type>::bits; 
     };
 
+    template <typename TAccumulator, TAccumulator Polynomial_, TAccumulator Initial_, TAccumulator Xor_Out_, bool Reflect_>
+    ETL_CONSTANT TAccumulator crc_parameters<TAccumulator, Polynomial_, Initial_, Xor_Out_, Reflect_>::Polynomial;
+
+    template <typename TAccumulator, TAccumulator Polynomial_, TAccumulator Initial_, TAccumulator Xor_Out_, bool Reflect_>
+    ETL_CONSTANT TAccumulator crc_parameters<TAccumulator, Polynomial_, Initial_, Xor_Out_, Reflect_>::Initial;
+
+    template <typename TAccumulator, TAccumulator Polynomial_, TAccumulator Initial_, TAccumulator Xor_Out_, bool Reflect_>
+    ETL_CONSTANT TAccumulator crc_parameters<TAccumulator, Polynomial_, Initial_, Xor_Out_, Reflect_>::Xor_Out;
+
+    template <typename TAccumulator, TAccumulator Polynomial_, TAccumulator Initial_, TAccumulator Xor_Out_, bool Reflect_>
+    ETL_CONSTANT bool crc_parameters<TAccumulator, Polynomial_, Initial_, Xor_Out_, Reflect_>::Reflect;
+
+    template <typename TAccumulator, TAccumulator Polynomial_, TAccumulator Initial_, TAccumulator Xor_Out_, bool Reflect_>
+    ETL_CONSTANT size_t crc_parameters<TAccumulator, Polynomial_, Initial_, Xor_Out_, Reflect_>::Accumulator_Bits;
+
     // 8 bit.
     typedef crc_parameters<uint8_t, 0x07U, 0x00U, 0x00U, false> crc8_ccitt_parameters;
     typedef crc_parameters<uint8_t, 0x07U, 0xFFU, 0x00U, true>  crc8_rohc_parameters;
diff --git a/include/etl/private/variant_variadic.h b/include/etl/private/variant_variadic.h
index 5d344b5c..76a90c62 100644
--- a/include/etl/private/variant_variadic.h
+++ b/include/etl/private/variant_variadic.h
@@ -1352,10 +1352,10 @@ namespace etl
     /// in which every recursive instantiation of `visit_result_helper` appends
     /// more elements and give it a pass through `common_type_t`.
     //***************************************************************************
-    template <template <typename...> typename, typename...>
+    template <template <typename...> class, typename...>
     struct visit_result_helper;
 
-    template <template <typename...> typename TToInject, size_t... tAltIndices, typename TCur>
+    template <template <typename...> class TToInject, size_t... tAltIndices, typename TCur>
     struct visit_result_helper<TToInject, index_sequence<tAltIndices...>, TCur>
     {
       template <size_t tIndex>
@@ -1365,7 +1365,7 @@ namespace etl
       using type = common_type_t<TToInject<var_type<tAltIndices> >...>;
     };
 
-    template <template <typename...> typename TToInject, size_t... tAltIndices, typename TCur, typename TNext, typename... TVs>
+    template <template <typename...> class TToInject, size_t... tAltIndices, typename TCur, typename TNext, typename... TVs>
     struct visit_result_helper<TToInject, index_sequence<tAltIndices...>, TCur, TNext, TVs...>
     {
       template <size_t tIndex>
diff --git a/include/etl/pseudo_moving_average.h b/include/etl/pseudo_moving_average.h
index 73c3d7c5..62a84643 100644
--- a/include/etl/pseudo_moving_average.h
+++ b/include/etl/pseudo_moving_average.h
@@ -48,8 +48,8 @@ namespace etl
     public:
 
       //***********************************
-      explicit add_insert_iterator(TCMA& cma) ETL_NOEXCEPT
-        : p_cma(&cma)
+      explicit add_insert_iterator(TCMA& pma) ETL_NOEXCEPT
+        : p_pma(&pma)
       {
       }
 
@@ -74,18 +74,18 @@ namespace etl
       //***********************************
       add_insert_iterator& operator =(typename TCMA::value_type value)
       {
-        p_cma->add(value);
+        p_pma->add(value);
         return *this;
       }
 
     private:
 
-      TCMA* p_cma;
+      TCMA* p_pma;
     };
   }
 
   //***************************************************************************
-  /// Cumulative Moving Average
+  /// Pseudo Moving Average
   /// \tparam T           The sample value type.
   /// \tparam SAMPLE_SIZE The number of samples to average over.
   /// \tparam SCALING     The scaling factor applied to samples. Default = 1.
@@ -98,7 +98,7 @@ namespace etl
   class pseudo_moving_average;
 
   //***************************************************************************
-  /// Cumulative Moving Average
+  /// Pseudo Moving Average
   /// For integral types.
   /// \tparam T           The sample value type.
   /// \tparam SAMPLE_SIZE The number of samples to average over.
@@ -177,8 +177,14 @@ namespace etl
     T average; ///< The current pseudo moving average.
   };
 
+  template <typename T, const size_t SAMPLE_SIZE_, const size_t SCALING_>
+  ETL_CONSTANT size_t pseudo_moving_average<T, SAMPLE_SIZE_, SCALING_, true, false>::SAMPLE_SIZE;
+  
+  template <typename T, const size_t SAMPLE_SIZE_, const size_t SCALING_>
+  ETL_CONSTANT size_t pseudo_moving_average<T, SAMPLE_SIZE_, SCALING_, true, false>::SCALING;
+
   //***************************************************************************
-/// Cumulative Moving Average
+/// Pseudo Moving Average
 /// For integral types.
 /// \tparam T           The sample value type.
 /// \tparam SCALING     The scaling factor applied to samples. Default = 1.
@@ -263,8 +269,11 @@ namespace etl
     sample_t samples; ///< The number of samples to average over.
   };
 
+  template <typename T, const size_t SCALING_>
+  ETL_CONSTANT size_t pseudo_moving_average<T, 0, SCALING_, true, false>::SCALING;
+
   //***************************************************************************
-  /// Cumulative Moving Average
+  /// Pseudo Moving Average
   /// For floating point types.
   /// \tparam T           The sample value type.
   /// \tparam SAMPLE_SIZE The number of samples to average over.
@@ -333,11 +342,13 @@ namespace etl
     T       average;                   ///< The current pseudo moving average.
   };
 
+  template <typename T, const size_t SAMPLE_SIZE_>
+  ETL_CONSTANT size_t pseudo_moving_average<T, SAMPLE_SIZE_, 1U, false, true>::SAMPLE_SIZE;
+
   //***************************************************************************
-  /// Cumulative Moving Average
+  /// Pseudo Moving Average
   /// For floating point types.
-  /// \tparam T           The sample value type.
-  /// \tparam SAMPLE_SIZE The number of samples to average over.
+  /// \tparam T The sample value type.
   //***************************************************************************
   template <typename T>
   class pseudo_moving_average<T, 0U, 1U, false, true>
diff --git a/include/etl/queue.h b/include/etl/queue.h
index 1dcd7685..72b3a83e 100644
--- a/include/etl/queue.h
+++ b/include/etl/queue.h
@@ -660,6 +660,9 @@ namespace etl
     /// The uninitialised buffer of T used in the queue.
     container_type buffer[SIZE];
   };
+
+  template <typename T, const size_t SIZE, const size_t MEMORY_MODEL>
+  ETL_CONSTANT typename queue<T, SIZE, MEMORY_MODEL>::size_type queue<T, SIZE, MEMORY_MODEL>::MAX_SIZE;
 }
 
 #endif
diff --git a/include/etl/queue_lockable.h b/include/etl/queue_lockable.h
index f3e525c5..f8a325b4 100644
--- a/include/etl/queue_lockable.h
+++ b/include/etl/queue_lockable.h
@@ -837,6 +837,12 @@ namespace etl
     /// The uninitialised buffer of T used in the queue_lockable.
     etl::uninitialized_buffer_of<T, Max_Size> buffer;
   };
+
+  template <typename T, size_t VSize, size_t VMemory_Model>
+  ETL_CONSTANT typename queue_lockable<T, VSize, VMemory_Model>::size_type queue_lockable<T, VSize, VMemory_Model>::Max_Size;
+  
+  template <typename T, size_t VSize, size_t VMemory_Model>
+  ETL_CONSTANT typename queue_lockable<T, VSize, VMemory_Model>::size_type queue_lockable<T, VSize, VMemory_Model>::Memory_Model;
 }
 
 #endif
diff --git a/include/etl/queue_mpmc_mutex.h b/include/etl/queue_mpmc_mutex.h
index 318506ed..794c7f01 100644
--- a/include/etl/queue_mpmc_mutex.h
+++ b/include/etl/queue_mpmc_mutex.h
@@ -676,6 +676,9 @@ namespace etl
     /// The uninitialised buffer of T used in the queue_mpmc_mutex.
     typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[MAX_SIZE];
   };
+
+  template <typename T, size_t SIZE, const size_t MEMORY_MODEL>  
+  ETL_CONSTANT typename queue_mpmc_mutex<T, SIZE, MEMORY_MODEL>::size_type queue_mpmc_mutex<T, SIZE, MEMORY_MODEL>::MAX_SIZE;
 }
 
 #endif
diff --git a/include/etl/queue_spsc_atomic.h b/include/etl/queue_spsc_atomic.h
index 84febb7b..e27bf41c 100644
--- a/include/etl/queue_spsc_atomic.h
+++ b/include/etl/queue_spsc_atomic.h
@@ -541,6 +541,9 @@ namespace etl
     /// The uninitialised buffer of T used in the queue_spsc.
     typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[RESERVED_SIZE];
   };
+
+  template <typename T, size_t SIZE, const size_t MEMORY_MODEL>
+  ETL_CONSTANT typename queue_spsc_atomic<T, SIZE, MEMORY_MODEL>::size_type queue_spsc_atomic<T, SIZE, MEMORY_MODEL>::MAX_SIZE;
 }
 
 #endif
diff --git a/include/etl/queue_spsc_isr.h b/include/etl/queue_spsc_isr.h
index 5a2b04aa..eeb7d155 100644
--- a/include/etl/queue_spsc_isr.h
+++ b/include/etl/queue_spsc_isr.h
@@ -797,6 +797,9 @@ namespace etl
     /// The uninitialised buffer of T used in the queue_spsc_isr.
     typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[MAX_SIZE];
   };
+
+  template <typename T, size_t SIZE, typename TAccess, const size_t MEMORY_MODEL>
+  ETL_CONSTANT typename queue_spsc_isr<T, SIZE, TAccess, MEMORY_MODEL>::size_type queue_spsc_isr<T, SIZE, TAccess, MEMORY_MODEL>::MAX_SIZE;
 }
 
 #endif
diff --git a/include/etl/queue_spsc_locked.h b/include/etl/queue_spsc_locked.h
index ad3e1a72..3495b2f4 100644
--- a/include/etl/queue_spsc_locked.h
+++ b/include/etl/queue_spsc_locked.h
@@ -860,6 +860,9 @@ namespace etl
     /// The uninitialised buffer of T used in the queue_lockable.
     etl::uninitialized_buffer_of<T, MAX_SIZE> buffer;
   };
+
+  template <typename T, size_t SIZE, const size_t MEMORY_MODEL>
+  ETL_CONSTANT typename queue_spsc_locked<T, SIZE, MEMORY_MODEL>::size_type queue_spsc_locked<T, SIZE, MEMORY_MODEL>::MAX_SIZE;
 }
 
 #endif
diff --git a/include/etl/ratio.h b/include/etl/ratio.h
index b5483606..aa11939c 100644
--- a/include/etl/ratio.h
+++ b/include/etl/ratio.h
@@ -48,6 +48,12 @@ namespace etl
     static ETL_CONSTANT intmax_t den = DEN;
   };
 
+  template <const size_t NUM, const size_t DEN>
+  ETL_CONSTANT intmax_t ratio<NUM, DEN>::num;
+
+  template <const size_t NUM, const size_t DEN>
+  ETL_CONSTANT intmax_t ratio<NUM, DEN>::den;
+
   #if INT_MAX > INT32_MAX
     typedef ratio<1, 1000000000000000000000000> yocto;
     typedef ratio<1, 1000000000000000000000>    zepto;
diff --git a/include/etl/reference_counted_message_pool.h b/include/etl/reference_counted_message_pool.h
index ff773e5f..d678f9fe 100644
--- a/include/etl/reference_counted_message_pool.h
+++ b/include/etl/reference_counted_message_pool.h
@@ -214,6 +214,7 @@ namespace etl
       // The maximum alignment.
       static constexpr size_t max_alignment = etl::alignment_of<etl::reference_counted_message<TMessage1, TCounter>>::value;
     };
+
 #else
     template <typename TMessage1,              typename TMessage2  = TMessage1, typename TMessage3  = TMessage1, typename TMessage4  = TMessage1,
               typename TMessage5  = TMessage1, typename TMessage6  = TMessage1, typename TMessage7  = TMessage1, typename TMessage8  = TMessage1>
@@ -247,6 +248,7 @@ namespace etl
                                                        etl::reference_counted_message<TMessage7, TCounter>,
                                                        etl::reference_counted_message<TMessage8, TCounter> >::alignment;
     };
+
 #endif
 
   private:
@@ -259,6 +261,30 @@ namespace etl
     reference_counted_message_pool& operator =(const reference_counted_message_pool&) ETL_DELETE;
   };
 
+#if ETL_USING_CPP11
+
+  template <typename TCounter>
+  template <typename TMessage1, typename... TMessages>
+  constexpr size_t reference_counted_message_pool<TCounter>::pool_message_parameters<TMessage1, TMessages...>::max_size;
+
+  template <typename TCounter>
+  template <typename TMessage1, typename... TMessages>
+  constexpr size_t reference_counted_message_pool<TCounter>::pool_message_parameters<TMessage1, TMessages...>::max_alignment;
+
+#else
+
+  template <typename TCounter>
+  template <typename TMessage1, typename TMessage2, typename TMessage3, typename TMessage4,
+            typename TMessage5, typename TMessage6, typename TMessage7, typename TMessage8>
+  const size_t reference_counted_message_pool<TCounter>::pool_message_parameters<TMessage1, TMessage2, TMessage3, TMessage4, TMessage5, TMessage6, TMessage7, TMessage8>::max_size;
+
+  template <typename TCounter>
+  template <typename TMessage1, typename TMessage2, typename TMessage3, typename TMessage4,
+            typename TMessage5, typename TMessage6, typename TMessage7, typename TMessage8>
+  const size_t reference_counted_message_pool<TCounter>::pool_message_parameters<TMessage1, TMessage2, TMessage3, TMessage4, TMessage5, TMessage6, TMessage7, TMessage8>::max_alignment;
+
+#endif
+
 #if ETL_USING_CPP11 && ETL_HAS_ATOMIC
   using  atomic_counted_message_pool = reference_counted_message_pool<etl::atomic_int>;
 #endif
diff --git a/include/etl/reference_flat_map.h b/include/etl/reference_flat_map.h
index 0b0d070a..fe162a2e 100644
--- a/include/etl/reference_flat_map.h
+++ b/include/etl/reference_flat_map.h
@@ -1175,6 +1175,9 @@ namespace etl
     etl::vector<node_t*, MAX_SIZE> lookup;
   };
 
+  template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t reference_flat_map< TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/reference_flat_multimap.h b/include/etl/reference_flat_multimap.h
index b12b4a07..605a9b3a 100644
--- a/include/etl/reference_flat_multimap.h
+++ b/include/etl/reference_flat_multimap.h
@@ -1041,6 +1041,9 @@ namespace etl
     etl::vector<node_t*, MAX_SIZE> lookup;
   };
 
+  template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t reference_flat_multimap< TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/reference_flat_multiset.h b/include/etl/reference_flat_multiset.h
index e1501d53..5d1931ad 100644
--- a/include/etl/reference_flat_multiset.h
+++ b/include/etl/reference_flat_multiset.h
@@ -991,6 +991,9 @@ namespace etl
     etl::vector<value_type*, MAX_SIZE> lookup;
   };
 
+  template <typename TKey, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t reference_flat_multiset<TKey, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/reference_flat_set.h b/include/etl/reference_flat_set.h
index 69a2ced7..3f30ae26 100644
--- a/include/etl/reference_flat_set.h
+++ b/include/etl/reference_flat_set.h
@@ -981,6 +981,9 @@ namespace etl
     etl::vector<value_type*, MAX_SIZE> lookup;
   };
 
+  template <typename TKey, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t reference_flat_set<TKey, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/set.h b/include/etl/set.h
index d21c14b8..9e2b5c4c 100644
--- a/include/etl/set.h
+++ b/include/etl/set.h
@@ -2625,6 +2625,9 @@ namespace etl
     etl::pool<typename etl::iset<TKey, TCompare>::Data_Node, MAX_SIZE> node_pool;
   };
 
+  template <typename TKey, const size_t MAX_SIZE_, typename TCompare>
+  ETL_CONSTANT size_t set<TKey, MAX_SIZE_, TCompare>::MAX_SIZE;
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************
diff --git a/include/etl/smallest.h b/include/etl/smallest.h
index c2c981a6..f423ec86 100644
--- a/include/etl/smallest.h
+++ b/include/etl/smallest.h
@@ -303,6 +303,9 @@ namespace etl
     typedef typename private_smallest::best_fit_uint_type<TYPE_INDEX>::type type;
   };
 
+  template <size_t NBITS>
+  ETL_CONSTANT int smallest_uint_for_bits<NBITS>::TYPE_INDEX;
+
 #if ETL_USING_CPP11
   template <size_t NBITS>
   using smallest_uint_for_bits_t = typename smallest_uint_for_bits<NBITS>::type;
@@ -329,6 +332,9 @@ namespace etl
     typedef typename private_smallest::best_fit_int_type<TYPE_INDEX>::type type;
   };
 
+  template <size_t NBITS>
+  ETL_CONSTANT int smallest_int_for_bits<NBITS>::TYPE_INDEX;
+
 #if ETL_USING_CPP11
   template <size_t NBITS>
   using smallest_int_for_bits_t = typename smallest_int_for_bits<NBITS>::type;
@@ -355,6 +361,9 @@ namespace etl
     typedef typename private_smallest::best_fit_uint_type<TYPE_INDEX>::type type;
   };
 
+  template <uintmax_t NBITS>
+  ETL_CONSTANT int smallest_uint_for_value<NBITS>::TYPE_INDEX;
+
 #if ETL_USING_CPP11
   template <uintmax_t VALUE>
   using smallest_uint_for_value_t = typename smallest_uint_for_value<VALUE>::type;
@@ -366,7 +375,7 @@ namespace etl
   /// Defines 'type' which is the type of the smallest signed integer.
   ///\ingroup smallest
   //***************************************************************************
-  template <const intmax_t VALUE>
+  template <intmax_t VALUE>
   struct smallest_int_for_value
   {
   private:
@@ -381,6 +390,9 @@ namespace etl
     typedef typename private_smallest::best_fit_int_type<TYPE_INDEX>::type type;
   };
 
+  template <intmax_t NBITS>
+  ETL_CONSTANT int smallest_int_for_value<NBITS>::TYPE_INDEX;
+
 #if ETL_USING_CPP11
   template <intmax_t VALUE>
   using smallest_int_for_value_t = typename smallest_int_for_value<VALUE>::type;
diff --git a/include/etl/span.h b/include/etl/span.h
index 531e68dc..5c57ee79 100644
--- a/include/etl/span.h
+++ b/include/etl/span.h
@@ -849,6 +849,12 @@ namespace etl
     pointer pend;
   };
 
+  template <typename T, size_t Extent>
+  ETL_CONSTANT size_t span<T, Extent>::extent;
+
+  template <typename T>
+  ETL_CONSTANT size_t span<T, etl::dynamic_extent>::extent;
+
   //*************************************************************************
   /// Compare two spans for equality.
   //*************************************************************************
@@ -933,8 +939,8 @@ namespace etl
   {
     size_t operator()(const etl::span<T>& view) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&view[0]),
-                                                     reinterpret_cast<const uint8_t*>(&view[view.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(view.data()),
+                                                     reinterpret_cast<const uint8_t*>(view.data() + view.size()));
     }
   };
 #endif
diff --git a/include/etl/sqrt.h b/include/etl/sqrt.h
index 18b13db5..31cc8d47 100644
--- a/include/etl/sqrt.h
+++ b/include/etl/sqrt.h
@@ -60,6 +60,11 @@ namespace etl
 #endif
   };
 
+#if ETL_USING_CPP11
+  template <size_t VALUE, size_t I>
+  constexpr size_t sqrt<VALUE, I>::value;
+#endif
+
 #if ETL_USING_CPP17
   template <size_t VALUE, size_t I = 1>
   inline constexpr size_t sqrt_v = sqrt<VALUE, I>::value;
diff --git a/include/etl/stack.h b/include/etl/stack.h
index 54006192..cea00443 100644
--- a/include/etl/stack.h
+++ b/include/etl/stack.h
@@ -601,6 +601,9 @@ namespace etl
     /// The uninitialised buffer of T used in the stack.
     container_type buffer[SIZE];
   };
+
+  template <typename T, const size_t SIZE>
+  ETL_CONSTANT size_t stack<T, SIZE>::MAX_SIZE;
 }
 
 #endif
diff --git a/include/etl/standard_deviation.h b/include/etl/standard_deviation.h
index 0fbb774f..14076d15 100644
--- a/include/etl/standard_deviation.h
+++ b/include/etl/standard_deviation.h
@@ -73,10 +73,24 @@ namespace etl
   //***************************************************************************
   /// Standard Deviation Type.
   //***************************************************************************
-  struct standard_deviation_type
+  namespace private_standard_deviation
+  {
+    template<typename T = void>
+    struct standard_deviation_type_helper
+    {
+      static ETL_CONSTANT bool Sample = false;
+      static ETL_CONSTANT bool Population = true;
+    };
+
+    template <typename T>
+    ETL_CONSTANT bool standard_deviation_type_helper<T>::Sample;
+
+    template <typename T>
+    ETL_CONSTANT bool standard_deviation_type_helper<T>::Population;
+  }
+
+  struct standard_deviation_type : public private_standard_deviation::standard_deviation_type_helper<>
   {
-    static ETL_CONSTANT bool Sample     = false;
-    static ETL_CONSTANT bool Population = true;
   };
 
   //***************************************************************************
diff --git a/include/etl/string.h b/include/etl/string.h
index a84c4d3a..04c52734 100644
--- a/include/etl/string.h
+++ b/include/etl/string.h
@@ -259,6 +259,9 @@ namespace etl
     value_type buffer[MAX_SIZE + 1];
   };
 
+  template <size_t MAX_SIZE_>
+  ETL_CONSTANT size_t string<MAX_SIZE_>::MAX_SIZE;
+
   //***************************************************************************
   /// A string implementation that uses a fixed size external buffer.
   ///\ingroup string
@@ -455,8 +458,8 @@ namespace etl
   {
     size_t operator()(const etl::istring& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-                                                     reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -465,8 +468,8 @@ namespace etl
   {
     size_t operator()(const etl::string<SIZE>& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-                                                     reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -475,8 +478,8 @@ namespace etl
   {
     size_t operator()(const etl::string_ext& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-                                                     reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 #endif
diff --git a/include/etl/string_view.h b/include/etl/string_view.h
index 8bad7c00..753289b8 100644
--- a/include/etl/string_view.h
+++ b/include/etl/string_view.h
@@ -852,8 +852,8 @@ namespace etl
   {
     size_t operator()(const etl::string_view& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-        reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -862,8 +862,8 @@ namespace etl
   {
     size_t operator()(const etl::wstring_view& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-        reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -872,8 +872,8 @@ namespace etl
   {
     size_t operator()(const etl::u16string_view& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-        reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -882,8 +882,8 @@ namespace etl
   {
     size_t operator()(const etl::u32string_view& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-        reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 #endif
diff --git a/include/etl/to_arithmetic.h b/include/etl/to_arithmetic.h
index da0f5052..024bd8f9 100644
--- a/include/etl/to_arithmetic.h
+++ b/include/etl/to_arithmetic.h
@@ -193,11 +193,34 @@ namespace etl
 
   namespace private_to_arithmetic
   {
-    static ETL_CONSTANT char Positive_Char     = '+';
-    static ETL_CONSTANT char Negative_Char     = '-';
-    static ETL_CONSTANT char Radix_Point1_Char = '.';
-    static ETL_CONSTANT char Radix_Point2_Char = ',';
-    static ETL_CONSTANT char Exponential_Char  = 'e';
+    template <typename T = void>
+    struct char_statics
+    {
+      static ETL_CONSTANT char Positive_Char = '+';
+      static ETL_CONSTANT char Negative_Char = '-';
+      static ETL_CONSTANT char Radix_Point1_Char = '.';
+      static ETL_CONSTANT char Radix_Point2_Char = ',';
+      static ETL_CONSTANT char Exponential_Char = 'e';
+    };
+
+    template <typename T>
+    ETL_CONSTANT char char_statics<T>::Positive_Char;
+
+    template <typename T>
+    ETL_CONSTANT char char_statics<T>::Negative_Char;
+
+    template <typename T>
+    ETL_CONSTANT char char_statics<T>::Radix_Point1_Char;
+
+    template <typename T>
+    ETL_CONSTANT char char_statics<T>::Radix_Point2_Char;
+
+    template <typename T>
+    ETL_CONSTANT char char_statics<T>::Exponential_Char;
+
+    struct char_constant : char_statics<>
+    {
+    };
 
     //*******************************************
     ETL_NODISCARD
@@ -312,8 +335,8 @@ namespace etl
       {
         // Check for prefix.
         const char c = convert(view[0]);
-        const bool has_positive_prefix = (c == Positive_Char);
-        const bool has_negative_prefix = (c == Negative_Char);
+        const bool has_positive_prefix = (c == char_constant::Positive_Char);
+        const bool has_negative_prefix = (c == char_constant::Negative_Char);
 
         // Step over the prefix, if present.
         if (has_positive_prefix || has_negative_prefix)
@@ -465,19 +488,19 @@ namespace etl
           //***************************
           case Parsing_Integral:
           {
-            if (expecting_sign && ((c == Positive_Char) || (c == Negative_Char)))
+            if (expecting_sign && ((c == char_constant::Positive_Char) || (c == char_constant::Negative_Char)))
             {
-              is_negative_mantissa = (c == Negative_Char);
+              is_negative_mantissa = (c == char_constant::Negative_Char);
               expecting_sign = false;
             }
             // Radix point?
-            else if ((c == Radix_Point1_Char) || (c == Radix_Point2_Char))
+            else if ((c == char_constant::Radix_Point1_Char) || (c == char_constant::Radix_Point2_Char))
             {
               expecting_sign = false;
               state = Parsing_Fractional;
             }
             // Exponential?
-            else if (c == Exponential_Char)
+            else if (c == char_constant::Exponential_Char)
             {
               expecting_sign = true;
               state = Parsing_Exponential;
@@ -502,13 +525,13 @@ namespace etl
           case Parsing_Fractional:
           {
             // Radix point?
-            if ((c == Radix_Point1_Char) || (c == Radix_Point2_Char))
+            if ((c == char_constant::Radix_Point1_Char) || (c == char_constant::Radix_Point2_Char))
             {
               conversion_status = to_arithmetic_status::Invalid_Format;
               is_success = false;
             }
             // Exponential?
-            else if (c == Exponential_Char)
+            else if (c == char_constant::Exponential_Char)
             {
               expecting_sign = true;
               state = Parsing_Exponential;
@@ -532,13 +555,13 @@ namespace etl
           //***************************
           case Parsing_Exponential:
           {
-            if (expecting_sign && ((c == Positive_Char) || (c == Negative_Char)))
+            if (expecting_sign && ((c == char_constant::Positive_Char) || (c == char_constant::Negative_Char)))
             {
-              is_negative_exponent = (c == Negative_Char);
+              is_negative_exponent = (c == char_constant::Negative_Char);
               expecting_sign = false;
             }
             // Radix point?
-            else if ((c == Radix_Point1_Char) || (c == Radix_Point2_Char) || (c == Exponential_Char))
+            else if ((c == char_constant::Radix_Point1_Char) || (c == char_constant::Radix_Point2_Char) || (c == char_constant::Exponential_Char))
             {
               conversion_status = to_arithmetic_status::Invalid_Format;
               is_success = false;
diff --git a/include/etl/type_lookup.h b/include/etl/type_lookup.h
index 55337455..31803095 100644
--- a/include/etl/type_lookup.h
+++ b/include/etl/type_lookup.h
@@ -125,14 +125,14 @@ namespace etl
     template <typename T, typename T1, typename... TRest>
     struct id_from_type_helper
     {
-      static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? T1::ID : id_from_type_helper<T, TRest...>::value;
+      static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? size_t(T1::ID) : id_from_type_helper<T, TRest...>::value;
     };
 
     // Specialisation for 1 type pair.
     template <typename T, typename T1>
     struct id_from_type_helper<T, T1>
     {
-      static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? T1::ID : UNKNOWN;
+      static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? size_t(T1::ID) : UNKNOWN;
     };
 
   public:
diff --git a/include/etl/type_traits.h b/include/etl/type_traits.h
index 70ecac1a..498f927f 100644
--- a/include/etl/type_traits.h
+++ b/include/etl/type_traits.h
@@ -84,7 +84,7 @@ namespace etl
 
   //***************************************************************************
   /// integral_constant
-  template <typename T, const T VALUE>
+  template <typename T, T VALUE>
   struct integral_constant
   {
     static const T value = VALUE;
@@ -102,12 +102,12 @@ namespace etl
   typedef integral_constant<bool, false> false_type;
   typedef integral_constant<bool, true>  true_type;
 
-  template <typename T, const T VALUE>
+  template <typename T, T VALUE>
   const T integral_constant<T, VALUE>::value;
 
 #if ETL_USING_CPP17
   template <typename T, T VALUE>
-  inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
+  inline constexpr T integral_constant_v = etl::integral_constant<T, VALUE>::value;
 #endif
 
 #if ETL_USING_CPP11
@@ -120,7 +120,7 @@ namespace etl
 
 #if ETL_USING_CPP17
   template <bool B>
-  inline constexpr bool bool_constant_v = std::bool_constant<B>::value;
+  inline constexpr bool bool_constant_v = bool_constant<B>::value;
 #endif
 
   //***************************************************************************
@@ -839,7 +839,7 @@ typedef integral_constant<bool, true>  true_type;
 
 #if ETL_USING_CPP17
   template <bool B>
-  inline constexpr bool bool_constant_v = std::bool_constant<B>::value;
+  inline constexpr bool bool_constant_v = bool_constant<B>::value;
 #endif
 
   //***************************************************************************
@@ -847,9 +847,7 @@ typedef integral_constant<bool, true>  true_type;
   ///\ingroup type_traits
 #if ETL_USING_CPP17
   template <typename T>
-  struct negation : std::negation<T>
-  {
-  };
+  using negation = std::negation<T>;
 #else
   template <typename T>
   struct negation : etl::bool_constant<!bool(T::value)>
@@ -1630,99 +1628,71 @@ typedef integral_constant<bool, true>  true_type;
   //*********************************************
   // is_assignable
   template<typename T1, typename T2>
-  struct is_assignable : public std::is_assignable<T1, T2>
-  {
-  };
+  using is_assignable = std::is_assignable<T1, T2>;
 
   //*********************************************
   // is_constructible
   template<typename T, typename... TArgs>
-  struct is_constructible : public std::is_constructible<T, TArgs...>
-  {
-  };
+  using is_constructible = std::is_constructible<T, TArgs...>;
 
   //*********************************************
   // is_copy_constructible
   template <typename T>
-  struct is_copy_constructible : public std::is_copy_constructible<T>
-  {
-  };
+  using is_copy_constructible = std::is_copy_constructible<T>;
 
   //*********************************************
   // is_move_constructible
   template <typename T>
-  struct is_move_constructible : public std::is_move_constructible<T>
-  {
-  };
+  using is_move_constructible = std::is_move_constructible<T>;
 
   //*********************************************
   // is_trivially_constructible
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
-  struct is_trivially_constructible : public std::is_trivially_constructible<T>
-  {
-  };
+  using is_trivially_constructible = std::is_trivially_constructible<T>;
 #else
   template <typename T>
-  struct is_trivially_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
-  {
-  };
+  using is_trivially_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
 #endif
 
   //*********************************************
   // is_trivially_copy_constructible
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
-  struct is_trivially_copy_constructible : public std::is_trivially_copy_constructible<T>
-  {
-  };
+  using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
 #else
   template <typename T>
-  struct is_trivially_copy_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
-  {
-  };
+  using is_trivially_copy_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
 #endif
 
   //*********************************************
   // is_trivially_destructible
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
-  struct is_trivially_destructible : public std::is_trivially_destructible<T>
-  {
-  };
+  using is_trivially_destructible = std::is_trivially_destructible<T>;
 #else
   template <typename T>
-  struct is_trivially_destructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
-  {
-  };
+  using is_trivially_destructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
 #endif
 
   //*********************************************
   // is_trivially_copy_assignable
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
-  struct is_trivially_copy_assignable : public std::is_trivially_copy_assignable<T>
-  {
-  };
+  using is_trivially_copy_assignable = std::is_trivially_copy_assignable<T>;
 #else
   template <typename T>
-  struct is_trivially_copy_assignable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
-  {
-  };
+  using is_trivially_copy_assignable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
 #endif
 
   //*********************************************
   // is_trivially_copyable
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
-  struct is_trivially_copyable : public std::is_trivially_copyable<T>
-  {
-  };
+  using is_trivially_copyable = std::is_trivially_copyable<T>;
 #else
   template <typename T>
-  struct is_trivially_copyable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
-  {
-  };
+  using is_trivially_copyable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
 #endif
 
 #elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)
diff --git a/include/etl/u16string.h b/include/etl/u16string.h
index 9be06986..bdd6fe4d 100644
--- a/include/etl/u16string.h
+++ b/include/etl/u16string.h
@@ -438,8 +438,8 @@ namespace etl
   {
     size_t operator()(const etl::iu16string& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-                                                     reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -448,8 +448,8 @@ namespace etl
   {
     size_t operator()(const etl::u16string<SIZE>& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-                                                     reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -458,8 +458,8 @@ namespace etl
   {
     size_t operator()(const etl::u16string_ext& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-        reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 #endif
diff --git a/include/etl/u32string.h b/include/etl/u32string.h
index 783f4901..530d248e 100644
--- a/include/etl/u32string.h
+++ b/include/etl/u32string.h
@@ -438,8 +438,8 @@ namespace etl
   {
     size_t operator()(const etl::iu32string& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-                                                     reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -448,8 +448,8 @@ namespace etl
   {
     size_t operator()(const etl::u32string<SIZE>& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-                                                     reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -458,8 +458,8 @@ namespace etl
   {
     size_t operator()(const etl::u32string_ext& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-        reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 #endif
diff --git a/include/etl/unaligned_type.h b/include/etl/unaligned_type.h
index 09acddb7..87204d4d 100644
--- a/include/etl/unaligned_type.h
+++ b/include/etl/unaligned_type.h
@@ -214,6 +214,9 @@ namespace etl
 
       unsigned char storage[Size];
     };
+
+    template <size_t Size_>
+    ETL_CONSTANT size_t unaligned_type_common<Size_>::Size;
   }
 
   //*************************************************************************
@@ -599,6 +602,12 @@ namespace etl
     };
   };
 
+  template <typename T, int Endian_>
+  ETL_CONSTANT int unaligned_type<T, Endian_>::Endian;
+    
+  template <typename T, int Endian_>
+  ETL_CONSTANT size_t unaligned_type<T, Endian_>::Size;
+
 #if ETL_HAS_CONSTEXPR_ENDIANNESS
   // Host order
   typedef unaligned_type<char, etl::endianness::value()> host_char_t;
diff --git a/include/etl/variance.h b/include/etl/variance.h
index f9b6986f..85726917 100644
--- a/include/etl/variance.h
+++ b/include/etl/variance.h
@@ -43,7 +43,7 @@ namespace etl
   namespace private_variance
   {
     //***************************************************************************
-    /// Types for generic correlation.
+    /// Types for generic variance.
     //***************************************************************************
     template <typename TInput, typename TCalc>
     struct variance_traits
@@ -52,7 +52,7 @@ namespace etl
     };
 
     //***************************************************************************
-    /// Types for float correlation.
+    /// Types for float variance.
     //***************************************************************************
     template <typename TCalc>
     struct variance_traits<float, TCalc>
@@ -61,7 +61,7 @@ namespace etl
     };
 
     //***************************************************************************
-    /// Types for double correlation.
+    /// Types for double variance.
     //***************************************************************************
     template <typename TCalc>
     struct variance_traits<double, TCalc>
@@ -73,10 +73,24 @@ namespace etl
   //***************************************************************************
   /// Variance Type.
   //***************************************************************************
-  struct variance_type
+  namespace private_variance
+  {
+    template<typename T = void>
+    struct variance_type_helper
+    {
+      static ETL_CONSTANT bool Sample = false;
+      static ETL_CONSTANT bool Population = true;
+    };
+
+    template <typename T>
+    ETL_CONSTANT bool variance_type_helper<T>::Sample;
+
+    template <typename T>
+    ETL_CONSTANT bool variance_type_helper<T>::Population;
+  }
+
+  struct variance_type : public private_variance::variance_type_helper<>
   {
-    static ETL_CONSTANT bool Sample     = false;
-    static ETL_CONSTANT bool Population = true;
   };
 
   //***************************************************************************
diff --git a/include/etl/wstring.h b/include/etl/wstring.h
index 22caaae6..9b500693 100644
--- a/include/etl/wstring.h
+++ b/include/etl/wstring.h
@@ -438,8 +438,8 @@ namespace etl
   {
     size_t operator()(const etl::iwstring& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-                                                     reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -448,8 +448,8 @@ namespace etl
   {
     size_t operator()(const etl::wstring<SIZE>& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-                                                     reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 
@@ -458,8 +458,8 @@ namespace etl
   {
     size_t operator()(const etl::wstring_ext& text) const
     {
-      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
-                                                     reinterpret_cast<const uint8_t*>(&text[text.size()]));
+      return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
+                                                     reinterpret_cast<const uint8_t*>(text.data() + text.size()));
     }
   };
 #endif
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 97bb4fb0..a235c606 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -16,10 +16,10 @@ add_executable(etl_tests
 	test_algorithm.cpp
 	test_alignment.cpp
 	test_array.cpp
-	test_array_view.cpp
+    test_array_view.cpp
 	test_array_wrapper.cpp
 	test_atomic.cpp
-	test_binary.cpp
+    test_binary.cpp
 	test_bip_buffer_spsc_atomic.cpp
 	test_bit.cpp
 	test_bitset_legacy.cpp
@@ -147,7 +147,7 @@ add_executable(etl_tests
 	test_largest.cpp
 	test_limiter.cpp
 	test_limits.cpp
-	test_list.cpp
+    test_list.cpp
 	test_list_shared_pool.cpp
 	test_make_string.cpp
 	test_map.cpp
@@ -156,7 +156,7 @@ add_executable(etl_tests
 	test_mem_cast.cpp
 	test_mem_cast_ptr.cpp
     test_memory.cpp
-	test_message_broker.cpp
+    test_message_broker.cpp
 	test_message_bus.cpp
 	test_message_packet.cpp
 	test_message_router.cpp
@@ -164,7 +164,7 @@ add_executable(etl_tests
 	test_message_timer.cpp
 	test_message_timer_atomic.cpp
     test_message_timer_interrupt.cpp
-	test_message_timer_locked.cpp
+    test_message_timer_locked.cpp
 	test_multimap.cpp
 	test_multiset.cpp
 	test_multi_array.cpp
@@ -288,7 +288,7 @@ if (ETL_CXX_STANDARD MATCHES "98")
 	message(STATUS "Compiling for C++98")
     set_property(TARGET etl_tests PROPERTY CXX_STANDARD 98)
 elseif (ETL_CXX_STANDARD MATCHES "03")
-	message(STATUS "Compiling for C++98")    
+	message(STATUS "Compiling for C++03 (C++98)")    
 	set_property(TARGET etl_tests PROPERTY CXX_STANDARD 98)
 elseif (ETL_CXX_STANDARD MATCHES "11")
 	message(STATUS "Compiling for C++11")    
@@ -359,6 +359,7 @@ if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Cla
 	target_compile_options(etl_tests
 			PRIVATE
 			-fno-omit-frame-pointer
+			-fno-common
 			-Wall
 			-Wextra
 			-Werror
diff --git a/test/UnitTest++/Checks.h b/test/UnitTest++/Checks.h
index 309954c5..21e783d8 100644
--- a/test/UnitTest++/Checks.h
+++ b/test/UnitTest++/Checks.h
@@ -170,7 +170,7 @@ namespace UnitTest
    }
 
    template< typename Expected, typename Actual >
-   void CheckEqual(TestResults& results, Expected const& expected, Actual const& actual, TestDetails const& details)
+   void CheckEqual(TestResults& results, Expected&& expected, Actual&& actual, TestDetails const& details)
    {
      if (!(expected == actual))
      {
diff --git a/test/etl_initializer_list/CMakeLists.txt b/test/etl_initializer_list/CMakeLists.txt
index bf660abd..132fb00f 100644
--- a/test/etl_initializer_list/CMakeLists.txt
+++ b/test/etl_initializer_list/CMakeLists.txt
@@ -30,6 +30,26 @@ if (ETL_OPTIMISATION MATCHES "-O3")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
 endif()
 
+if (ETL_CXX_STANDARD MATCHES "98")
+	message(STATUS "Compiling for C++98")
+    set_property(TARGET etl_tests PROPERTY CXX_STANDARD 98)
+elseif (ETL_CXX_STANDARD MATCHES "03")
+	message(STATUS "Compiling for C++98")    
+	set_property(TARGET etl_tests PROPERTY CXX_STANDARD 98)
+elseif (ETL_CXX_STANDARD MATCHES "11")
+	message(STATUS "Compiling for C++11")    
+	set_property(TARGET etl_tests PROPERTY CXX_STANDARD 11)
+elseif (ETL_CXX_STANDARD MATCHES "14")
+	message(STATUS "Compiling for C++14")    
+	set_property(TARGET etl_tests PROPERTY CXX_STANDARD 14)
+elseif (ETL_CXX_STANDARD MATCHES "17")
+	message(STATUS "Compiling for C++17")    
+	set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)
+else()
+	message(STATUS "Compiling for C++20")
+	set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
+endif()
+
 target_include_directories(etl_tests
   PUBLIC
   ${CMAKE_CURRENT_LIST_DIR}
@@ -59,6 +79,3 @@ add_test(etl_initializer_list_unit_tests etl_tests)
 add_custom_target(test_verbose COMMAND ${CMAKE_CTEST_COMMAND} --verbose)
 
 
-#RSG
-set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)
-
diff --git a/test/runsanitychecks.sh b/test/runsanitychecks.sh
index 5048f786..9b466520 100644
--- a/test/runsanitychecks.sh
+++ b/test/runsanitychecks.sh
@@ -1,20 +1,77 @@
 #!/bin/sh
 clear
 
+echo -e
+
+testname="Test Name Not Set"
+
+FailColour='\033[38;2;255;128;128m'
+PassColour='\033[38;2;128;255;128m'
+TitleColour='\033[38;2;100;173;254m'
+NoColour='\033[0m'
+
+SetCxxStandard()
+{
+	cxx_standard=$1
+}
+
+SetTestName()
+{
+	testname=$1
+}
+
+PrintHeader()
+{
+	echo "${TitleColour}"
+	echo "----------------------------------------------------------------------------" | tee -a log.txt
+	echo " $testname" | tee -a log.txt
+	echo " Language standard : C++${cxx_standard}" | tee -a log.txt
+	echo "----------------------------------------------------------------------------" | tee -a log.txt
+	echo "${NoColour}"
+}
+
+PassedCompilation()
+{
+	echo "${PassColour}"
+	echo "-----------------------------------------------" | tee -a log.txt
+	echo " Passed Compilation - $testname" | tee -a ../log.txt
+	echo "-----------------------------------------------" | tee -a log.txt
+	echo "${NoColour}"
+}
+
+FailedCompilation()
+{
+	echo "${FailColour}"
+	echo "****************************************************************************" | tee -a log.txt
+    echo "**** Failed Compilation $testname" | tee -a log.txt
+	echo "****************************************************************************" | tee -a ../log.txt
+	echo "${NoColour}"
+}
+
+ChecksCompleted()
+{
+	echo "${PassColour}"
+	echo "-----------------------------------------------" | tee -a log.txt
+	echo " All Checks Completed OK" | tee -a log.txt
+	echo "-----------------------------------------------" | tee -a log.txt
+	echo "${NoColour}"
+}
+
 cd sanity-check || exit 1
 echo "" > log.txt
 
 export CMAKE_BUILD_PARALLEL_LEVEL=4
 
+echo ""
+echo "Using "${CMAKE_BUILD_PARALLEL_LEVEL}" jobs"
+
 ###############################################################################
 cd c++03 || exit 1
-{ echo ""
-echo "Using "${CMAKE_BUILD_PARALLEL_LEVEL}" jobs"
-echo "-----------------------------------------------"
-echo " C++03"
-echo "-----------------------------------------------"
 
-echo "GCC - STL"; } | tee -a ../log.txt
+SetCxxStandard "03 (98)"
+
+SetTestName "GCC - STL"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -22,13 +79,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
 CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 cmake --build bgcc
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-{ echo ""; echo "GCC - No STL"; } | tee -a ../log.txt
+SetTestName "GCC - No STL"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -36,13 +94,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
 CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 cmake --build bgcc
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-##{ echo ""; echo "GCC - No STL - User defined traits"; } | tee -a ../log.txt
+##SetTestName "GCC - No STL - User defined traits"
+# PrintHeader
 #rm -rdf bgcc
 #rm -rdf bclang
 #cmake -E make_directory bgcc bclang
@@ -50,13 +109,14 @@ fi
 #CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 #cmake --build bgcc
 #if [ $? -eq 0 ]; then
-#  echo "Passed"
+#  PassedCompilation
 #else
-#  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+#  FailedCompilation
 #  exit $?
 #fi
 
-{ echo ""; echo "Clang - STL"; } | tee -a ../log.txt
+SetTestName "Clang - STL"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -64,13 +124,14 @@ clang++ --version | head --lines=1 | tee -a ../log.txt
 CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 cmake --build bclang
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-{ echo ""; echo "Clang - No STL"; } | tee -a ../log.txt
+SetTestName "Clang - No STL"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -78,13 +139,14 @@ clang++ --version | head --lines=1 | tee -a ../log.txt
 CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 cmake --build bclang
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-##{ echo ""; echo "Clang - No STL - User defined traits"; } | tee -a ../log.txt
+#SetTestName "Clang - No STL - User defined traits"
+#PrintHeader
 #rm -rdf bgcc
 #rm -rdf bclang
 #cmake -E make_directory bgcc bclang
@@ -92,20 +154,19 @@ fi
 #CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 #cmake --build bclang
 #if [ $? -eq 0 ]; then
-#  echo "Passed"
+#  PassedCompilation
 #else
-#  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+#  FailedCompilation
 #  exit $?
 #fi
 
 ###############################################################################
 cd ../c++11 || exit 1
-{ echo ""
-echo "-----------------------------------------------"
-echo " C++11"
-echo "-----------------------------------------------"
 
-echo "GCC - STL"; } | tee -a ../log.txt
+SetCxxStandard "11"
+
+SetTestName "GCC - STL"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -113,13 +174,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
 CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 cmake --build bgcc
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-{ echo ""; echo "GCC - STL - Force C++03"; } | tee -a ../log.txt
+SetTestName "GCC - STL - Force C++03"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -127,13 +189,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
 CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
 cmake --build bgcc
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-{ echo ""; echo "GCC - No STL"; } | tee -a ../log.txt
+SetTestName "GCC - No STL"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -141,251 +204,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
 CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 cmake --build bgcc
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-##{ echo ""; echo "GCC - No STL - User defined traits"; } | tee -a ../log.txt
-#rm -rdf bgcc
-#rm -rdf bclang
-#cmake -E make_directory bgcc bclang
-#g++ --version | head --lines=1 | tee -a ../log.txt
-#CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-#cmake --build bgcc
-#if [ $? -eq 0 ]; then
-#  echo "Passed"
-#else
-#  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-#  exit $?
-#fi
-
-{ echo ""; echo "Clang - STL"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-clang++ --version | head --lines=1 | tee -a ../log.txt
-CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-cmake --build bclang
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-{ echo ""; echo "Clang - STL - Force C++03"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-clang++ --version | head --lines=1 | tee -a ../log.txt
-CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
-cmake --build bclang
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-{ echo ""; echo "Clang - No STL"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-clang++ --version | head --lines=1 | tee -a ../log.txt
-CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-cmake --build bclang
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-##{ echo ""; echo "Clang - No STL - User defined traits"; } | tee -a ../log.txt
-#rm -rdf bgcc
-#rm -rdf bclang
-#cmake -E make_directory bgcc bclang
-#clang++ --version | head --lines=1 | tee -a ../log.txt
-#CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-#cmake --build bclang
-#if [ $? -eq 0 ]; then
-#  echo "Passed"
-#else
-#  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-#  exit $?
-#fi
-
-###############################################################################
-cd ../c++14 || exit 1
-{ echo ""
-echo "-----------------------------------------------"
-echo " C++14"
-echo "-----------------------------------------------"
-
-echo "GCC - STL"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-g++ --version | head --lines=1 | tee -a ../log.txt
-CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-cmake --build bgcc
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-{ echo ""; echo "GCC - STL - Force C++03"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-g++ --version | head --lines=1 | tee -a ../log.txt
-CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
-cmake --build bgcc
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-{ echo ""; echo "GCC - No STL"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-g++ --version | head --lines=1 | tee -a ../log.txt
-CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-cmake --build bgcc
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-##{ echo ""; echo "GCC - No STL - User defined traits"; } | tee -a ../log.txt
-#rm -rdf bgcc
-#rm -rdf bclang
-#cmake -E make_directory bgcc bclang
-#g++ --version | head --lines=1 | tee -a ../log.txt
-#CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-#cmake --build bgcc
-#if [ $? -eq 0 ]; then
-#  echo "Passed"
-#else
-#  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-#  exit $?
-#fi
-
-{ echo ""; echo "Clang - STL"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-clang++ --version | head --lines=1 | tee -a ../log.txt
-CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-cmake --build bclang
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-{ echo ""; echo "Clang - STL - Force C++03"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-clang++ --version | head --lines=1 | tee -a ../log.txt
-CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
-cmake --build bclang
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-{ echo ""; echo "Clang - No STL"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-clang++ --version | head --lines=1 | tee -a ../log.txt
-CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-cmake --build bclang
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-##{ echo ""; echo "Clang - No STL - User defined traits"; } | tee -a ../log.txt
-#rm -rdf bgcc
-#rm -rdf bclang
-#cmake -E make_directory bgcc bclang
-#clang++ --version | head --lines=1 | tee -a ../log.txt
-#CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-#cmake --build bclang
-#if [ $? -eq 0 ]; then
-#  echo "Passed"
-#else
-#  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-#  exit $?
-#fi
-
-###############################################################################
-cd ../c++17 || exit 1
-{ echo ""
-echo "-----------------------------------------------"
-echo " C++17 "
-echo "-----------------------------------------------"
-
-echo "GCC - STL"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-g++ --version | head --lines=1 | tee -a ../log.txt
-CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-cmake --build bgcc
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-{ echo ""; echo "GCC - STL - Force C++03"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-g++ --version | head --lines=1 | tee -a ../log.txt
-CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
-cmake --build bgcc
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-{ echo ""; echo "GCC - No STL"; } | tee -a ../log.txt
-rm -rdf bgcc
-rm -rdf bclang
-cmake -E make_directory bgcc bclang
-g++ --version | head --lines=1 | tee -a ../log.txt
-CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
-cmake --build bgcc
-if [ $? -eq 0 ]; then
-  echo "Passed"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-{ echo ""; echo "GCC - No STL - Force C++03"; } | tee -a ../log.txt
+SetTestName "GCC - No STL - Force C++03"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -393,13 +219,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
 CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
 cmake --build bgcc
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-##{ echo ""; echo "GCC - No STL - User defined traits"; } | tee -a ../log.txt
+#SetTestName "GCC - No STL - User defined traits"
+#PrintHeader
 #rm -rdf bgcc
 #rm -rdf bclang
 #cmake -E make_directory bgcc bclang
@@ -407,13 +234,14 @@ fi
 #CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 #cmake --build bgcc
 #if [ $? -eq 0 ]; then
-#  echo "Passed"
+#  PassedCompilation
 #else
-#  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+#  FailedCompilation
 #  exit $?
 #fi
 
-{ echo ""; echo "Clang - STL"; } | tee -a ../log.txt
+SetTestName  "Clang - STL"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -421,13 +249,14 @@ clang++ --version | head --lines=1 | tee -a ../log.txt
 CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 cmake --build bclang
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-{ echo ""; echo "Clang - STL - Force C++03"; } | tee -a ../log.txt
+SetTestName "Clang - STL - Force C++03"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -435,13 +264,14 @@ clang++ --version | head --lines=1 | tee -a ../log.txt
 CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
 cmake --build bclang
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-{ echo ""; echo "Clang - No STL"; } | tee -a ../log.txt
+SetTestName "Clang - No STL"
+PrintHeader
 rm -rdf bgcc
 rm -rdf bclang
 cmake -E make_directory bgcc bclang
@@ -449,13 +279,29 @@ clang++ --version | head --lines=1 | tee -a ../log.txt
 CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 cmake --build bclang
 if [ $? -eq 0 ]; then
-  echo "Passed"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 
-##{ echo ""; echo "Clang - No STL - User defined traits"; } | tee -a ../log.txt
+SetTestName "Clang - No STL - Force C++03"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+clang++ --version | head --lines=1 | tee -a ../log.txt
+CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
+cmake --build bclang
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+#SetTestName "Clang - No STL - User defined traits"
+#PrintHeader
 #rm -rdf bgcc
 #rm -rdf bclang
 #cmake -E make_directory bgcc bclang
@@ -463,13 +309,320 @@ fi
 #CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
 #cmake --build bclang
 #if [ $? -eq 0 ]; then
-#  echo "Passed"
+#  PassedCompilation
 #else
-#  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+#  FailedCompilation
 #  exit $?
 #fi
 
-{ echo ""
-echo "-----------------------------------------------"
-echo " All Checks Completed OK"
-echo "-----------------------------------------------"; } | tee -a ../log.txt
+###############################################################################
+cd ../c++14 || exit 1
+
+SetCxxStandard "14"
+
+SetTestName "GCC - STL"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+g++ --version | head --lines=1 | tee -a ../log.txt
+CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+cmake --build bgcc
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "GCC - STL - Force C++03"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+g++ --version | head --lines=1 | tee -a ../log.txt
+CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
+cmake --build bgcc
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "GCC - No STL"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+g++ --version | head --lines=1 | tee -a ../log.txt
+CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+cmake --build bgcc
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "GCC - No STL - Force C++03"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+g++ --version | head --lines=1 | tee -a ../log.txt
+CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
+cmake --build bgcc
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+#SetTestName "GCC - No STL - User defined traits"
+#PrintHeader
+#rm -rdf bgcc
+#rm -rdf bclang
+#cmake -E make_directory bgcc bclang
+#g++ --version | head --lines=1 | tee -a ../log.txt
+#CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+#cmake --build bgcc
+#if [ $? -eq 0 ]; then
+#  PassedCompilation
+#else
+#  FailedCompilation
+#  exit $?
+#fi
+
+SetTestName "Clang - STL"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+clang++ --version | head --lines=1 | tee -a ../log.txt
+CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+cmake --build bclang
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "Clang - STL - Force C++03"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+clang++ --version | head --lines=1 | tee -a ../log.txt
+CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
+cmake --build bclang
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "Clang - No STL"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+clang++ --version | head --lines=1 | tee -a ../log.txt
+CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+cmake --build bclang
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "Clang - No STL - Force C++03"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+clang++ --version | head --lines=1 | tee -a ../log.txt
+CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
+cmake --build bclang
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+#SetTestName "Clang - No STL - User defined traits"
+#PrintHeader
+#rm -rdf bgcc
+#rm -rdf bclang
+#cmake -E make_directory bgcc bclang
+#clang++ --version | head --lines=1 | tee -a ../log.txt
+#CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+#cmake --build bclang
+#if [ $? -eq 0 ]; then
+#  PassedCompilation
+#else
+#  FailedCompilation
+#  exit $?
+#fi
+
+###############################################################################
+cd ../c++17 || exit 1
+
+SetCxxStandard "17"
+
+SetTestName "GCC - STL"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+g++ --version | head --lines=1 | tee -a ../log.txt
+CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+cmake --build bgcc
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "GCC - STL - Force C++03"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+g++ --version | head --lines=1 | tee -a ../log.txt
+CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
+cmake --build bgcc
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "GCC - No STL"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+g++ --version | head --lines=1 | tee -a ../log.txt
+CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+cmake --build bgcc
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "GCC - No STL - Force C++03"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+g++ --version | head --lines=1 | tee -a ../log.txt
+CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
+cmake --build bgcc
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+#SetTestName "GCC - No STL - User defined traits"
+#PrintHeader
+#rm -rdf bgcc
+#rm -rdf bclang
+#cmake -E make_directory bgcc bclang
+#g++ --version | head --lines=1 | tee -a ../log.txt
+#CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+#cmake --build bgcc
+#if [ $? -eq 0 ]; then
+#  PassedCompilation
+#else
+#  FailedCompilation
+#  exit $?
+#fi
+
+SetTestName "Clang - STL"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+clang++ --version | head --lines=1 | tee -a ../log.txt
+CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+cmake --build bclang
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "Clang - STL - Force C++03"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+clang++ --version | head --lines=1 | tee -a ../log.txt
+CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
+cmake --build bclang
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "Clang - No STL"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+clang++ --version | head --lines=1 | tee -a ../log.txt
+CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+cmake --build bclang
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+SetTestName "Clang - No STL - Force C++03"
+PrintHeader
+rm -rdf bgcc
+rm -rdf bclang
+cmake -E make_directory bgcc bclang
+clang++ --version | head --lines=1 | tee -a ../log.txt
+CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
+cmake --build bclang
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+
+#SetTestName "Clang - No STL - User defined traits"
+#PrintHeader
+#rm -rdf bgcc
+#rm -rdf bclang
+#cmake -E make_directory bgcc bclang
+#clang++ --version | head --lines=1 | tee -a ../log.txt
+#CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
+#cmake --build bclang
+#if [ $? -eq 0 ]; then
+#  PassedCompilation
+#else
+#  FailedCompilation
+#  exit $?
+#fi
+
+ChecksCompleted
diff --git a/test/runtests-c++14.sh b/test/runtests-c++14.sh
deleted file mode 100644
index 4dea9034..00000000
--- a/test/runtests-c++14.sh
+++ /dev/null
@@ -1,348 +0,0 @@
-#!/bin/sh
-clear
-
-mkdir -p build-make || exit 1
-cd build-make || exit 1
-
-echo "ETL Tests" > log.txt
-
-opt="-O0"
-cxx_standard="14"
-
-#******************************************************************************
-# GCC
-#******************************************************************************
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - STL" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-rm * -rf
-gcc --version | grep gcc | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - STL - Force C++03" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-rm * -rf
-gcc --version | grep gcc | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - No STL" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-rm * -rf
-gcc --version | grep gcc | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-#******************************************************************************
-# CLANG
-#******************************************************************************
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - STL" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-rm * -rf
-clang --version | grep clang | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - STL - Force C++03" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-rm * -rf
-clang --version | grep clang | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - No STL" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-rm * -rf
-clang --version | grep clang | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - Initializer list test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-cd ../etl_initializer_list/
-mkdir -p build-make || exit 1
-cd build-make || exit 1
-rm * -rf
-gcc --version | grep gcc | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed initializer_list Compilation >>>>"
-else
-  echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - Initializer list test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-rm * -rf
-clang --version | grep clang | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed initializer_list Compilation >>>>"
-else
-  echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - Error macros 'log_errors' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-cd ../../etl_error_handler/log_errors
-mkdir -p build-make || exit 1
-cd build-make || exit 1
-rm * -rf
-gcc --version | grep gcc | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
-else
-  echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - Error macros 'exceptions' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-cd ../../../etl_error_handler/exceptions
-mkdir -p build-make || exit 1
-cd build-make || exit 1
-rm * -rf
-gcc --version | grep gcc | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
-else
-  echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - Error macros 'log_errors and exceptions' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-cd ../../../etl_error_handler/log_errors_and_exceptions
-mkdir -p build-make || exit 1
-cd build-make || exit 1
-rm * -rf
-gcc --version | grep gcc | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
-else
-  echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - Error macros 'log_errors' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-cd ../../../etl_error_handler/log_errors
-mkdir -p build-make || exit 1
-cd build-make || exit 1
-rm * -rf
-clang --version | grep clang | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
-else
-  echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - Error macros 'exceptions' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-cd ../../../etl_error_handler/exceptions
-mkdir -p build-make || exit 1
-cd build-make || exit 1
-rm * -rf
-clang --version | grep clang | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
-else
-  echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - Error macros 'log_errors and exceptions' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-cd ../../../etl_error_handler/log_errors_and_exceptions
-mkdir -p build-make || exit 1
-cd build-make || exit 1
-rm * -rf
-clang --version | grep clang | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
-else
-  echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-
-cd ../..
-
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " All Tests Completed OK" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
diff --git a/test/runtests.sh b/test/runtests.sh
index 249a44b8..909e4c62 100644
--- a/test/runtests.sh
+++ b/test/runtests.sh
@@ -6,365 +6,462 @@ cd build-make || exit 1
 
 echo "ETL Tests" > log.txt
 
-# Set the optimisation level
-if [ "$1" = "1" ]; then
+# Set the language standard. Default C++20
+if [ "$1" = "11" ]; then
+  cxx_standard="11"
+elif [ "$1" = "14" ]; then
+  cxx_standard="14"
+elif [ "$1" = "17" ]; then
+  cxx_standard="17"
+else
+  cxx_standard="20"
+fi
+
+# Set the optimisation level. Default -O0
+if [ "$2" = "1" ]; then
   opt="-O1"
-elif [ "$1" = "2" ]; then
+elif [ "$2" = "2" ]; then
   opt="-O2"
-elif [ "$1" = "3" ]; then
+elif [ "$2" = "3" ]; then
   opt="-O3" 
 else
   opt="-O0"
 fi
 
+export ASAN_OPTIONS=symbol_line=1
+export ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-14/bin//llvm-symbolizer
+
+echo -e
+
+testname="Test Name Not Set"
+
+FailColour='\033[38;2;255;128;128m'
+PassColour='\033[38;2;128;255;128m'
+TitleColour='\033[38;2;100;173;254m'
+NoColour='\033[0m'
+
+SetTestName()
+{
+	testname=$1
+}
+
+PrintHeader()
+{
+	echo "${TitleColour}"
+	echo "----------------------------------------------------------------------------" | tee -a log.txt
+	echo " $testname" | tee -a log.txt
+	echo " Language standard : C++${cxx_standard}" | tee -a log.txt
+    echo " Optimisation      : ${opt}" | tee -a log.txt
+	echo "----------------------------------------------------------------------------" | tee -a log.txt
+	echo "${NoColour}"
+}
+
+PassedCompilation()
+{
+	echo "${PassColour}"
+	echo "-----------------------------------------------" | tee -a log.txt
+	echo " Passed Compilation - $testname" | tee -a ../log.txt
+	echo "-----------------------------------------------" | tee -a log.txt
+	echo "${NoColour}"
+}
+
+PassedTests()
+{
+	echo "${PassColour}"
+	echo "-----------------------------------------------" | tee -a log.txt
+	echo " Passed Tests - $testname" | tee -a ../log.txt
+	echo "-----------------------------------------------" | tee -a log.txt
+	echo "${NoColour}"
+}
+
+FailedCompilation()
+{
+	echo "${FailColour}"
+	echo "****************************************************************************" | tee -a log.txt
+    echo "**** Failed Compilation $testname" | tee -a log.txt
+	echo "****************************************************************************" | tee -a ../log.txt
+	echo "${NoColour}"
+}
+
+FailedTests()
+{
+	echo "${FailColour}"
+	echo "****************************************************************************" | tee -a log.txt
+    echo "**** Failed Tests $testname" | tee -a log.txt
+	echo "****************************************************************************" | tee -a ../log.txt
+	echo "${NoColour}"
+}
+
+TestsCompleted()
+{
+	echo "${PassColour}"
+	echo "-----------------------------------------------" | tee -a log.txt
+	echo " All Tests Completed OK" | tee -a log.txt
+	echo "-----------------------------------------------" | tee -a log.txt
+	echo "${NoColour}"
+}
+
 #******************************************************************************
 # GCC
 #******************************************************************************
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - STL" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+SetTestName "GCC - STL"
+PrintHeader
 rm * -rf
 gcc --version | grep gcc | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - STL - Force C++03" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+
+#******************************************************************************
+SetTestName "GCC - STL - Force C++03"
+PrintHeader
 rm * -rf
 gcc --version | grep gcc | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - No STL" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+
+#******************************************************************************
+SetTestName "GCC - No STL"
+PrintHeader
 rm * -rf
 gcc --version | grep gcc | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedTests
+  exit $?
+fi
+
+#******************************************************************************
+SetTestName "GCC - No STL - Force C++03"
+PrintHeader
+rm * -rf
+gcc --version | grep gcc | tee -a log.txt
+cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
+make -j4
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+./etl_tests
+if [ $? -eq 0 ]; then
+  PassedTests
+else
+  FailedTests
   exit $?
 fi
 
 #******************************************************************************
 # CLANG
 #******************************************************************************
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - STL" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+SetTestName "Clang - STL"
+PrintHeader
 rm * -rf
 clang --version | grep clang | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - STL - Force C++03" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-rm * -rf
-clang --version | grep clang | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - No STL" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
-rm * -rf
-clang --version | grep clang | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt ..
-make -j4
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Compilation >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
-  exit $?
-fi
-./etl_tests
-if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
-else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
 
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - Initializer list test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+#******************************************************************************
+SetTestName "Clang - STL - Force C++03"
+PrintHeader
+rm * -rf
+clang --version | grep clang | tee -a log.txt
+cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
+make -j4
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+./etl_tests
+if [ $? -eq 0 ]; then
+  PassedTests
+else
+  FailedTests
+  exit $?
+fi
+
+#******************************************************************************
+SetTestName "Clang - No STL"
+PrintHeader
+rm * -rf
+clang --version | grep clang | tee -a log.txt
+cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
+make -j4
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+./etl_tests
+if [ $? -eq 0 ]; then
+  PassedTests
+else
+  FailedTests
+  exit $?
+fi
+
+#******************************************************************************
+SetTestName "Clang - No STL - Force C++03"
+PrintHeader
+rm * -rf
+clang --version | grep clang | tee -a log.txt
+cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
+make -j4
+if [ $? -eq 0 ]; then
+  PassedCompilation
+else
+  FailedCompilation
+  exit $?
+fi
+./etl_tests
+if [ $? -eq 0 ]; then
+  PassedTests
+else
+  FailedTests
+  exit $?
+fi
+
+#******************************************************************************
+SetTestName "GCC - Initializer list test"
+PrintHeader
 cd ../etl_initializer_list/
 mkdir -p build-make || exit 1
 cd build-make || exit 1
 rm * -rf
 gcc --version | grep gcc | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed initializer_list Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
 
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - Initializer list test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+#******************************************************************************
+SetTestName "Clang - Initializer list test"
+PrintHeader
 rm * -rf
 clang --version | grep clang | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed initializer_list Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
 
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - Error macros 'log_errors' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+#******************************************************************************
+SetTestName "GCC - Error macros 'log_errors' test"
+PrintHeader
 cd ../../etl_error_handler/log_errors
 mkdir -p build-make || exit 1
 cd build-make || exit 1
 rm * -rf
 gcc --version | grep gcc | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
 
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - Error macros 'exceptions' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+#******************************************************************************
+SetTestName "GCC - Error macros 'exceptions' test"
+PrintHeader
 cd ../../../etl_error_handler/exceptions
 mkdir -p build-make || exit 1
 cd build-make || exit 1
 rm * -rf
 gcc --version | grep gcc | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
 
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " GCC - Error macros 'log_errors and exceptions' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+#******************************************************************************
+SetTestName "GCC - Error macros 'log_errors and exceptions' test"
+PrintHeader
 cd ../../../etl_error_handler/log_errors_and_exceptions
 mkdir -p build-make || exit 1
 cd build-make || exit 1
 rm * -rf
 gcc --version | grep gcc | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
 
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - Error macros 'log_errors' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+#******************************************************************************
+SetTestName "Clang - Error macros 'log_errors' test"
+PrintHeader
 cd ../../../etl_error_handler/log_errors
 mkdir -p build-make || exit 1
 cd build-make || exit 1
 rm * -rf
 clang --version | grep clang | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
 
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - Error macros 'exceptions' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+#******************************************************************************
+SetTestName "Clang - Error macros 'exceptions' test"
+PrintHeader
 cd ../../../etl_error_handler/exceptions
 mkdir -p build-make || exit 1
 cd build-make || exit 1
 rm * -rf
 clang --version | grep clang | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
 
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " Clang - Error macros 'log_errors and exceptions' test" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+#******************************************************************************
+SetTestName "Clang - Error macros 'log_errors and exceptions' test"
+PrintHeader
 cd ../../../etl_error_handler/log_errors_and_exceptions
 mkdir -p build-make || exit 1
 cd build-make || exit 1
 rm * -rf
 clang --version | grep clang | tee -a log.txt
-echo "Using optimisation" $opt | tee -a log.txt
-cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
+cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
 make -j4
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
+  PassedCompilation
 else
-  echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
+  FailedCompilation
   exit $?
 fi
 ./etl_tests
 if [ $? -eq 0 ]; then
-  echo "<<<< Passed Tests >>>>"
+  PassedTests
 else
-  echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
+  FailedTests
   exit $?
 fi
 
 cd ../..
 
-echo ""
-echo "-----------------------------------------------" | tee -a log.txt
-echo " All Tests Completed OK" | tee -a log.txt
-echo "-----------------------------------------------" | tee -a log.txt
+TestsCompleted
diff --git a/test/test_algorithm.cpp b/test/test_algorithm.cpp
index d68e6b48..8828cb96 100644
--- a/test/test_algorithm.cpp
+++ b/test/test_algorithm.cpp
@@ -1601,7 +1601,7 @@ namespace
       etl::transform_s(std::begin(input),
                        std::end(input),
                        std::begin(output),
-                       std::begin(output) + (ETL_OR_STD::size(output) / 2),
+                       std::begin(output) + (ETL_OR_STD17::size(output) / 2),
                        std::bind(std::multiplies<int>(), std::placeholders::_1, 2));
 
       bool is_same = std::equal(std::begin(output), std::end(output), std::begin(compare));
@@ -1610,7 +1610,7 @@ namespace
       std::fill(std::begin(output), std::end(output), 0);
 
       etl::transform_s(std::begin(input),
-                       std::begin(input) + (ETL_OR_STD::size(input) / 2),
+                       std::begin(input) + (ETL_OR_STD17::size(input) / 2),
                        std::begin(output),
                        std::end(output),
                        std::bind(std::multiplies<int>(), std::placeholders::_1, 2));
diff --git a/test/test_array_view.cpp b/test/test_array_view.cpp
index a29d8399..0202dcd1 100644
--- a/test/test_array_view.cpp
+++ b/test/test_array_view.cpp
@@ -722,8 +722,8 @@ namespace
       View  view(etldata.begin(), etldata.end());
       CView cview(etldata.begin(), etldata.end());
 
-      size_t hashdata = etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&etldata[0]),
-                                                                reinterpret_cast<const uint8_t*>(&etldata[etldata.size()]));
+      size_t hashdata = etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(etldata.data()),
+                                                                reinterpret_cast<const uint8_t*>(etldata.data() + etldata.size()));
 
       size_t hashview  = etl::hash<View>()(view);
       size_t hashcview = etl::hash<CView>()(cview);
diff --git a/test/test_array_wrapper.cpp b/test/test_array_wrapper.cpp
index 4c2ab952..b93ff35d 100644
--- a/test/test_array_wrapper.cpp
+++ b/test/test_array_wrapper.cpp
@@ -563,10 +563,8 @@ namespace
       Data5  aw5;
       size_t hash = etl::hash<Data5>()(aw5);
 
-
       size_t compare_hash = etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(data5), reinterpret_cast<const uint8_t*>(data5 + 5U));
 
-
       CHECK_EQUAL(compare_hash, hash);
     }
   };
diff --git a/test/test_byte_stream.cpp b/test/test_byte_stream.cpp
index 3f8e8296..2587719c 100644
--- a/test/test_byte_stream.cpp
+++ b/test/test_byte_stream.cpp
@@ -109,7 +109,7 @@ namespace
     {
       char storage[7];
 
-      etl::byte_stream_writer writer(storage, ETL_OR_STD::size(storage), etl::endian::big);
+      etl::byte_stream_writer writer(storage, ETL_OR_STD17::size(storage), etl::endian::big);
       etl::byte_stream_reader reader(storage, writer.size_bytes(), etl::endian::big); // Capacity is zero.
 
       CHECK(writer.empty());
@@ -120,7 +120,7 @@ namespace
       CHECK_EQUAL(0U, writer.size_bytes());
       CHECK_EQUAL(0U, reader.size_bytes());
 
-      CHECK_EQUAL(ETL_OR_STD::size(storage), writer.capacity());
+      CHECK_EQUAL(ETL_OR_STD17::size(storage), writer.capacity());
 
       CHECK_EQUAL(0U, reader.available<int8_t>());
 
@@ -136,9 +136,9 @@ namespace
     {
       char storage[8];
 
-      etl::byte_stream_writer writer(storage, ETL_OR_STD::size(storage), etl::endian::big);
+      etl::byte_stream_writer writer(storage, ETL_OR_STD17::size(storage), etl::endian::big);
 
-      etl::span<char> storage_span(storage, storage + ETL_OR_STD::size(storage));
+      etl::span<char> storage_span(storage, storage + ETL_OR_STD17::size(storage));
       etl::span<char> writer_span = writer.data();
       CHECK(writer_span.begin() == storage_span.begin());
       CHECK(writer_span.end()   == storage_span.end());
@@ -150,7 +150,7 @@ namespace
       etl::span<char> free_span = writer.free_data();
 
       CHECK_EQUAL(sizeof(uint8_t) + sizeof(uint16_t), (std::distance(used_span.begin(), used_span.end())));
-      CHECK_EQUAL(ETL_OR_STD::size(storage) - sizeof(uint8_t) - sizeof(uint16_t), (std::distance(free_span.begin(), free_span.end())));
+      CHECK_EQUAL(ETL_OR_STD17::size(storage) - sizeof(uint8_t) - sizeof(uint16_t), (std::distance(free_span.begin(), free_span.end())));
 
       CHECK(writer.write(uint32_t(0x12345678U)));       // 4 more written.
       CHECK_FALSE(writer.write(uint32_t(0x12345678U))); // Can't write 4 more.
diff --git a/test/test_char_traits.cpp b/test/test_char_traits.cpp
index 1963c767..483faa56 100644
--- a/test/test_char_traits.cpp
+++ b/test/test_char_traits.cpp
@@ -74,7 +74,7 @@ namespace
       char_type r = 'A';
       char_type c = 'B';
       char_type src[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-      char_type dst[ETL_OR_STD::size(src)];
+      char_type dst[ETL_OR_STD17::size(src)];
       char_type filled[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
       const char_type* p_src;
       char_type* p_dst;
@@ -96,18 +96,18 @@ namespace
       CHECK_EQUAL(-1, char_traits::compare("ABCDEE", "ABCDEF", 6U));
       CHECK_EQUAL(1,  char_traits::compare("ABCDEF", "ABCDEE", 6U));
 
-      p_dst = char_traits::assign(dst, ETL_OR_STD::size(dst), 9);
-      CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD::size(filled));
+      p_dst = char_traits::assign(dst, ETL_OR_STD17::size(dst), 9);
+      CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD17::size(filled));
 
-      std::fill_n(dst, ETL_OR_STD::size(dst), 0);
-      p_dst = char_traits::copy(dst, src, ETL_OR_STD::size(src));
-      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
+      std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
+      p_dst = char_traits::copy(dst, src, ETL_OR_STD17::size(src));
+      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
       
-      std::fill_n(dst, ETL_OR_STD::size(dst), 0);
-      p_dst = char_traits::move(dst, src, ETL_OR_STD::size(src));
-      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
+      std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
+      p_dst = char_traits::move(dst, src, ETL_OR_STD17::size(src));
+      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
 
-      p_src = char_traits::find(src, ETL_OR_STD::size(src), 4);
+      p_src = char_traits::find(src, ETL_OR_STD17::size(src), 4);
       CHECK_EQUAL(src[4], *p_src);
 
       CHECK_EQUAL(127, char_traits::to_char_type(int_type(127)));
@@ -130,7 +130,7 @@ namespace
       char_type r = L'A';
       char_type c = L'B';
       char_type src[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-      char_type dst[ETL_OR_STD::size(src)];
+      char_type dst[ETL_OR_STD17::size(src)];
       char_type filled[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
       const char_type* p_src;
       char_type* p_dst;
@@ -152,18 +152,18 @@ namespace
       CHECK_EQUAL(-1, char_traits::compare(L"ABCDEE", L"ABCDEF", 6U));
       CHECK_EQUAL(1, char_traits::compare(L"ABCDEF", L"ABCDEE", 6U));
 
-      p_dst = char_traits::assign(dst, ETL_OR_STD::size(dst), 9);
-      CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD::size(filled));
+      p_dst = char_traits::assign(dst, ETL_OR_STD17::size(dst), 9);
+      CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD17::size(filled));
 
-      std::fill_n(dst, ETL_OR_STD::size(dst), 0);
-      p_dst = char_traits::copy(dst, src, ETL_OR_STD::size(src));
-      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
+      std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
+      p_dst = char_traits::copy(dst, src, ETL_OR_STD17::size(src));
+      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
 
-      std::fill_n(dst, ETL_OR_STD::size(dst), 0);
-      p_dst = char_traits::move(dst, src, ETL_OR_STD::size(src));
-      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
+      std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
+      p_dst = char_traits::move(dst, src, ETL_OR_STD17::size(src));
+      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
 
-      p_src = char_traits::find(src, ETL_OR_STD::size(src), 4);
+      p_src = char_traits::find(src, ETL_OR_STD17::size(src), 4);
       CHECK_EQUAL(src[4], *p_src);
 
       CHECK_TRUE(127 == char_traits::to_char_type(int_type(127)));
@@ -186,7 +186,7 @@ namespace
       char_type r = u'A';
       char_type c = u'B';
       char_type src[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-      char_type dst[ETL_OR_STD::size(src)];
+      char_type dst[ETL_OR_STD17::size(src)];
       char_type filled[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
       const char_type* p_src;
       char_type* p_dst;
@@ -208,18 +208,18 @@ namespace
       CHECK_EQUAL(-1, char_traits::compare(u"ABCDEE", u"ABCDEF", 6U));
       CHECK_EQUAL(1, char_traits::compare(u"ABCDEF", u"ABCDEE", 6U));
 
-      p_dst = char_traits::assign(dst, ETL_OR_STD::size(dst), 9);
-      CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD::size(filled));
+      p_dst = char_traits::assign(dst, ETL_OR_STD17::size(dst), 9);
+      CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD17::size(filled));
 
-      std::fill_n(dst, ETL_OR_STD::size(dst), 0);
-      p_dst = char_traits::copy(dst, src, ETL_OR_STD::size(src));
-      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
+      std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
+      p_dst = char_traits::copy(dst, src, ETL_OR_STD17::size(src));
+      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
 
-      std::fill_n(dst, ETL_OR_STD::size(dst), 0);
-      p_dst = char_traits::move(dst, src, ETL_OR_STD::size(src));
-      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
+      std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
+      p_dst = char_traits::move(dst, src, ETL_OR_STD17::size(src));
+      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
 
-      p_src = char_traits::find(src, ETL_OR_STD::size(src), 4);
+      p_src = char_traits::find(src, ETL_OR_STD17::size(src), 4);
       CHECK_EQUAL(src[4], *p_src);
 
       CHECK_EQUAL(127, char_type(127));
@@ -241,7 +241,7 @@ namespace
       char_type r = U'A';
       char_type c = U'B';
       char_type src[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-      char_type dst[ETL_OR_STD::size(src)];
+      char_type dst[ETL_OR_STD17::size(src)];
       char_type filled[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
       const char_type* p_src;
       char_type* p_dst;
@@ -263,18 +263,18 @@ namespace
       CHECK_EQUAL(-1, char_traits::compare(U"ABCDEE", U"ABCDEF", 6U));
       CHECK_EQUAL(1, char_traits::compare(U"ABCDEF", U"ABCDEE", 6U));
 
-      p_dst = char_traits::assign(dst, ETL_OR_STD::size(dst), 9);
-      CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD::size(filled));
+      p_dst = char_traits::assign(dst, ETL_OR_STD17::size(dst), 9);
+      CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD17::size(filled));
 
-      std::fill_n(dst, ETL_OR_STD::size(dst), 0);
-      p_dst = char_traits::copy(dst, src, ETL_OR_STD::size(src));
-      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
+      std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
+      p_dst = char_traits::copy(dst, src, ETL_OR_STD17::size(src));
+      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
 
-      std::fill_n(dst, ETL_OR_STD::size(dst), 0);
-      p_dst = char_traits::move(dst, src, ETL_OR_STD::size(src));
-      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
+      std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
+      p_dst = char_traits::move(dst, src, ETL_OR_STD17::size(src));
+      CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
 
-      p_src = char_traits::find(src, ETL_OR_STD::size(src), 4);
+      p_src = char_traits::find(src, ETL_OR_STD17::size(src), 4);
       CHECK_EQUAL(src[4], *p_src);
 
       CHECK_EQUAL(127, char_traits::to_int_type(char_type(127)));
diff --git a/test/test_circular_iterator.cpp b/test/test_circular_iterator.cpp
index 2888d3a9..fdfd64d4 100644
--- a/test/test_circular_iterator.cpp
+++ b/test/test_circular_iterator.cpp
@@ -63,8 +63,8 @@ namespace
       CHECK(std::begin(data) == ci.begin());
       CHECK(std::end(data)   == ci.end());
       CHECK(std::begin(data) == ci.current());
-      CHECK_EQUAL(ETL_OR_STD::size(data), size_t(std::distance(ci.begin(), ci.end())));
-      CHECK_EQUAL(ETL_OR_STD::size(data), ci.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), size_t(std::distance(ci.begin(), ci.end())));
+      CHECK_EQUAL(ETL_OR_STD17::size(data), ci.size());
     }
 
     //*************************************************************************
@@ -80,8 +80,8 @@ namespace
       CHECK(std::begin(data) == ci.begin());
       CHECK(std::end(data)   == ci.end());
       CHECK(start            == ci.current());
-      CHECK_EQUAL(ETL_OR_STD::size(data), size_t(std::distance(ci.begin(), ci.end())));
-      CHECK_EQUAL(ETL_OR_STD::size(data), ci.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), size_t(std::distance(ci.begin(), ci.end())));
+      CHECK_EQUAL(ETL_OR_STD17::size(data), ci.size());
     }
 
     //*************************************************************************
@@ -645,7 +645,7 @@ namespace
         
         for (int i = 0; i < 20; i += step)
         {
-          CHECK_EQUAL(expected[i % ETL_OR_STD::size(data)], *ci);
+          CHECK_EQUAL(expected[i % ETL_OR_STD17::size(data)], *ci);
           ci -= step;
         }
       }
@@ -663,7 +663,7 @@ namespace
 
         for (int i = 0; i < 20; i += step)
         {
-          CHECK_EQUAL(expected[i % ETL_OR_STD::size(data)], *ci);
+          CHECK_EQUAL(expected[i % ETL_OR_STD17::size(data)], *ci);
           ci = ci - step;
         }
       }
diff --git a/test/test_container.cpp b/test/test_container.cpp
index bb28bb8c..e2fbb811 100644
--- a/test/test_container.cpp
+++ b/test/test_container.cpp
@@ -74,7 +74,7 @@ namespace
       CHECK(&data[0] == iBegin);
 
       int* iEnd = etl::end(data);
-      CHECK(&data[SIZE] == iEnd);
+      CHECK((data + SIZE) == iEnd);
     }
 
     //*************************************************************************
@@ -87,7 +87,7 @@ namespace
       CHECK(&data[0] == iBegin);
 
       const int* const iEnd = etl::end(data);
-      CHECK(&data[SIZE] == iEnd);
+      CHECK((data + SIZE) == iEnd);
     }
 
 
@@ -129,7 +129,7 @@ namespace
       const size_t SIZE = 10UL;
       std::list<int> data(SIZE);
 
-      size_t runtime_size = ETL_OR_STD::size(data);
+      size_t runtime_size = ETL_OR_STD17::size(data);
       CHECK_EQUAL(SIZE, runtime_size);
     }
 
@@ -139,7 +139,7 @@ namespace
       const size_t SIZE = 10UL;
       int data[SIZE];
 
-      size_t runtime_size = ETL_OR_STD::size(data);
+      size_t runtime_size = ETL_OR_STD17::size(data);
       CHECK_EQUAL(SIZE, runtime_size);
 
       size_t compiletime_size = sizeof(etl::array_size(data));
diff --git a/test/test_fsm.cpp b/test/test_fsm.cpp
index a057a055..848d9632 100644
--- a/test/test_fsm.cpp
+++ b/test/test_fsm.cpp
@@ -341,7 +341,7 @@ namespace
       CHECK(motorControl.is_producer());
       CHECK(motorControl.is_consumer());
 
-      motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
+      motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
       motorControl.reset();
       motorControl.ClearStatistics();
 
@@ -480,7 +480,7 @@ namespace
     {
       etl::null_message_router nmr;
 
-      motorControl.Initialise(stateList, ETL_OR_STD::size(stateList)); 
+      motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList)); 
       motorControl.reset();
       motorControl.ClearStatistics();
 
@@ -529,7 +529,7 @@ namespace
     {
       etl::null_message_router nmr;
 
-      motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
+      motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
       motorControl.reset();
       motorControl.ClearStatistics();
 
diff --git a/test/test_hfsm.cpp b/test/test_hfsm.cpp
index d7361c08..584c3f48 100644
--- a/test/test_hfsm.cpp
+++ b/test/test_hfsm.cpp
@@ -474,9 +474,9 @@ namespace
       CHECK(motorControl.is_producer());
       CHECK(motorControl.is_consumer());
 
-      running.set_child_states(childStates, ETL_OR_STD::size(childStates));
+      running.set_child_states(childStates, ETL_OR_STD17::size(childStates));
 
-      motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
+      motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
       motorControl.reset();
       motorControl.ClearStatistics();
 
@@ -647,7 +647,7 @@ namespace
     {
       etl::null_message_router nmr;
 
-      motorControl.Initialise(stateList, ETL_OR_STD::size(stateList)); 
+      motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList)); 
       motorControl.reset();
       motorControl.ClearStatistics();
 
@@ -700,7 +700,7 @@ namespace
     {
       etl::null_message_router nmr;
 
-      motorControl.Initialise(stateList, ETL_OR_STD::size(stateList)); 
+      motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList)); 
       motorControl.reset();
       motorControl.ClearStatistics();
 
@@ -754,7 +754,7 @@ namespace
     {
       etl::null_message_router nmr;
 
-      motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
+      motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
       motorControl.reset();
       motorControl.ClearStatistics();
 
@@ -809,7 +809,7 @@ namespace
     {
       etl::null_message_router nmr;
 
-      motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
+      motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
       motorControl.reset();
       motorControl.ClearStatistics();
 
@@ -902,7 +902,7 @@ namespace
     {
       MotorControl mc;
 
-      motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
+      motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
       motorControl.reset();
       motorControl.ClearStatistics();
 
@@ -941,7 +941,7 @@ namespace
     {
       MotorControl mc;
 
-      motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
+      motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
       motorControl.reset();
       motorControl.ClearStatistics();
 
diff --git a/test/test_integral_limits.cpp b/test/test_integral_limits.cpp
index 0c97e940..9fcba6d8 100644
--- a/test/test_integral_limits.cpp
+++ b/test/test_integral_limits.cpp
@@ -41,7 +41,7 @@ namespace
     //*************************************************************************
     TEST(test_min)
     {
-      CHECK_EQUAL(std::numeric_limits<char>::min(),               (char)etl::integral_limits<char>::min);
+      CHECK_EQUAL(std::numeric_limits<char>::min(),               etl::integral_limits<char>::min);
       CHECK_EQUAL(std::numeric_limits<signed char>::min(),        (signed char)etl::integral_limits<signed char>::min);
       CHECK_EQUAL(std::numeric_limits<unsigned char>::min(),      (unsigned char)etl::integral_limits<unsigned char>::min);
       CHECK_EQUAL(std::numeric_limits<short>::min(),              (short)etl::integral_limits<short>::min);
diff --git a/test/test_iterator.cpp b/test/test_iterator.cpp
index 729c0a50..fbbb0f4a 100644
--- a/test/test_iterator.cpp
+++ b/test/test_iterator.cpp
@@ -79,7 +79,7 @@ namespace
     //*************************************************************************
     TEST(distance_non_random)
     {
-      ptrdiff_t d = etl::distance(non_random_iterator<int>(&dataA[0]), non_random_iterator<int>(&dataA[SIZE]));
+      ptrdiff_t d = etl::distance(non_random_iterator<int>(&dataA[0]), non_random_iterator<int>(dataA + SIZE));
 
       CHECK_EQUAL(SIZE, d);
     }
@@ -87,7 +87,7 @@ namespace
     //*************************************************************************
     TEST(distance_random)
     {
-      ptrdiff_t d = etl::distance(random_iterator<int>(&dataA[0]), random_iterator<int>(&dataA[SIZE]));
+      ptrdiff_t d = etl::distance(random_iterator<int>(&dataA[0]), random_iterator<int>(dataA + SIZE));
 
       CHECK_EQUAL(SIZE, d);
     }
diff --git a/test/test_multi_array.cpp b/test/test_multi_array.cpp
index 78ba585c..0b399cc5 100644
--- a/test/test_multi_array.cpp
+++ b/test/test_multi_array.cpp
@@ -208,11 +208,11 @@ namespace
     {
       Data data = { { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 }, { 9, 10, 11 } } };
 
-      CHECK(data.end() == &data[SIZE1]);
-      CHECK(data[0].end() == &data[0][SIZE2]);
-      CHECK(data[1].end() == &data[1][SIZE2]);
-      CHECK(data[2].end() == &data[2][SIZE2]);
-      CHECK(data[3].end() == &data[3][SIZE2]);
+      CHECK(data.end() == &data[0] + SIZE1);
+      CHECK(data[0].end() == &data[0][0] + SIZE2);
+      CHECK(data[1].end() == &data[1][0] + SIZE2);
+      CHECK(data[2].end() == &data[2][0] + SIZE2);
+      CHECK(data[3].end() == &data[3][0] + SIZE2);
     }
 
     //*************************************************************************
@@ -232,11 +232,11 @@ namespace
     {
       const Data data = { { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 }, { 9, 10, 11 } } };
 
-      CHECK(data.cend() == &data[SIZE1]);
-      CHECK(data[0].cend() == &data[0][SIZE2]);
-      CHECK(data[1].cend() == &data[1][SIZE2]);
-      CHECK(data[2].cend() == &data[2][SIZE2]);
-      CHECK(data[3].cend() == &data[3][SIZE2]);
+      CHECK(data.cend() == &data[0] + SIZE1);
+      CHECK(data[0].cend() == &data[0][0] + SIZE2);
+      CHECK(data[1].cend() == &data[1][0] + SIZE2);
+      CHECK(data[2].cend() == &data[2][0] + SIZE2);
+      CHECK(data[3].cend() == &data[3][0] + SIZE2);
     }
 
     //*************************************************************************
@@ -246,11 +246,11 @@ namespace
 
       typedef etl::multi_array<int, SIZE2> Inner;
 
-      CHECK(data.rbegin() == Data::reverse_iterator(&data[SIZE1]));
-      CHECK(data[0].rbegin() == Inner::reverse_iterator(&data[0][SIZE2]));
-      CHECK(data[1].rbegin() == Inner::reverse_iterator(&data[1][SIZE2]));
-      CHECK(data[2].rbegin() == Inner::reverse_iterator(&data[2][SIZE2]));
-      CHECK(data[3].rbegin() == Inner::reverse_iterator(&data[3][SIZE2]));
+      CHECK(data.rbegin() == Data::reverse_iterator(&data[0] + SIZE1));
+      CHECK(data[0].rbegin() == Inner::reverse_iterator(&data[0][0] + SIZE2));
+      CHECK(data[1].rbegin() == Inner::reverse_iterator(&data[1][0] + SIZE2));
+      CHECK(data[2].rbegin() == Inner::reverse_iterator(&data[2][0] + SIZE2));
+      CHECK(data[3].rbegin() == Inner::reverse_iterator(&data[3][0] + SIZE2));
     }
 
     //*************************************************************************
@@ -274,11 +274,11 @@ namespace
 
       typedef etl::multi_array<int, SIZE2> Inner;
 
-      CHECK(data.rbegin() == Data::const_reverse_iterator(&data[SIZE1]));
-      CHECK(data[0].rbegin() == Inner::const_reverse_iterator(&data[0][SIZE2]));
-      CHECK(data[1].rbegin() == Inner::const_reverse_iterator(&data[1][SIZE2]));
-      CHECK(data[2].rbegin() == Inner::const_reverse_iterator(&data[2][SIZE2]));
-      CHECK(data[3].rbegin() == Inner::const_reverse_iterator(&data[3][SIZE2]));
+      CHECK(data.rbegin() == Data::const_reverse_iterator(data.data() + data.size()));
+      CHECK(data[0].rbegin() == Inner::const_reverse_iterator(&data[0][0] + SIZE2));
+      CHECK(data[1].rbegin() == Inner::const_reverse_iterator(&data[1][0] + SIZE2));
+      CHECK(data[2].rbegin() == Inner::const_reverse_iterator(&data[2][0] + SIZE2));
+      CHECK(data[3].rbegin() == Inner::const_reverse_iterator(&data[3][0] + SIZE2));
     }
 
     //*************************************************************************
diff --git a/test/test_multi_vector.cpp b/test/test_multi_vector.cpp
index 18777041..560bf3e2 100644
--- a/test/test_multi_vector.cpp
+++ b/test/test_multi_vector.cpp
@@ -253,11 +253,11 @@ namespace
       Data data;
       Copy(initial, data);
 
-      CHECK(data.end() == &data[SIZE1]);
-      CHECK(data[0].end() == &data[0][SIZE2]);
-      CHECK(data[1].end() == &data[1][SIZE2]);
-      CHECK(data[2].end() == &data[2][SIZE2]);
-      CHECK(data[3].end() == &data[3][SIZE2]);
+      CHECK(data.end() == &data[0] + SIZE1);
+      CHECK(data[0].end() == &data[0][0] + SIZE2);
+      CHECK(data[1].end() == &data[1][0] + SIZE2);
+      CHECK(data[2].end() == &data[2][0] + SIZE2);
+      CHECK(data[3].end() == &data[3][0] + SIZE2);
     }
 
     //*************************************************************************
@@ -281,11 +281,11 @@ namespace
       Data data;
       Copy(initial, data);
 
-      CHECK(data.cend() == &data[SIZE1]);
-      CHECK(data[0].cend() == &data[0][SIZE2]);
-      CHECK(data[1].cend() == &data[1][SIZE2]);
-      CHECK(data[2].cend() == &data[2][SIZE2]);
-      CHECK(data[3].cend() == &data[3][SIZE2]);
+      CHECK(data.cend() == &data[0] + SIZE1);
+      CHECK(data[0].cend() == &data[0][0] + SIZE2);
+      CHECK(data[1].cend() == &data[1][0] + SIZE2);
+      CHECK(data[2].cend() == &data[2][0] + SIZE2);
+      CHECK(data[3].cend() == &data[3][0] + SIZE2);
     }
 
     //*************************************************************************
@@ -297,11 +297,11 @@ namespace
 
       typedef etl::multi_vector<int, SIZE2> Inner;
 
-      CHECK(data.rbegin() == Data::reverse_iterator(&data[SIZE1]));
-      CHECK(data[0].rbegin() == Inner::reverse_iterator(&data[0][SIZE2]));
-      CHECK(data[1].rbegin() == Inner::reverse_iterator(&data[1][SIZE2]));
-      CHECK(data[2].rbegin() == Inner::reverse_iterator(&data[2][SIZE2]));
-      CHECK(data[3].rbegin() == Inner::reverse_iterator(&data[3][SIZE2]));
+      CHECK(data.rbegin() == Data::reverse_iterator(&data[0] + SIZE1));
+      CHECK(data[0].rbegin() == Inner::reverse_iterator(&data[0][0] + SIZE2));
+      CHECK(data[1].rbegin() == Inner::reverse_iterator(&data[1][0] + SIZE2));
+      CHECK(data[2].rbegin() == Inner::reverse_iterator(&data[2][0] + SIZE2));
+      CHECK(data[3].rbegin() == Inner::reverse_iterator(&data[3][0] + SIZE2));
     }
 
     //*************************************************************************
@@ -329,11 +329,11 @@ namespace
 
       typedef etl::multi_vector<int, SIZE2> Inner;
 
-      CHECK(data.rbegin() == Data::const_reverse_iterator(&data[SIZE1]));
-      CHECK(data[0].rbegin() == Inner::const_reverse_iterator(&data[0][SIZE2]));
-      CHECK(data[1].rbegin() == Inner::const_reverse_iterator(&data[1][SIZE2]));
-      CHECK(data[2].rbegin() == Inner::const_reverse_iterator(&data[2][SIZE2]));
-      CHECK(data[3].rbegin() == Inner::const_reverse_iterator(&data[3][SIZE2]));
+      CHECK(data.rbegin() == Data::const_reverse_iterator(&data[0] + SIZE1));
+      CHECK(data[0].rbegin() == Inner::const_reverse_iterator(&data[0][0] + SIZE2));
+      CHECK(data[1].rbegin() == Inner::const_reverse_iterator(&data[1][0] + SIZE2));
+      CHECK(data[2].rbegin() == Inner::const_reverse_iterator(&data[2][0] + SIZE2));
+      CHECK(data[3].rbegin() == Inner::const_reverse_iterator(&data[3][0] + SIZE2));
     }
 
     //*************************************************************************
diff --git a/test/test_murmur3.cpp b/test/test_murmur3.cpp
index e5217d5a..23c1b469 100644
--- a/test/test_murmur3.cpp
+++ b/test/test_murmur3.cpp
@@ -44,7 +44,7 @@ namespace
     //*************************************************************************
     TEST(test_murmur3_32_constructor)
     {
-      std::aligned_storage_t<sizeof(char), std::alignment_of_v<uint32_t>> storage[10];
+      std::aligned_storage_t<sizeof(char), std::alignment_of<uint32_t>::value> storage[10];
       std::string data("123456789");      
 
       char* begin = (char*)&storage[0];
@@ -61,7 +61,7 @@ namespace
     //*************************************************************************
     TEST(test_murmur3_32_add_values)
     {
-      std::aligned_storage_t<sizeof(char), std::alignment_of_v<uint32_t>> storage[10];
+      std::aligned_storage_t<sizeof(char), std::alignment_of<uint32_t>::value> storage[10];
       std::string data("123456789");
 
       char* begin = (char*)&storage[0];
@@ -85,7 +85,7 @@ namespace
     //*************************************************************************
     TEST(test_murmur3_32_add_range)
     {
-      std::aligned_storage_t<sizeof(char), std::alignment_of_v<uint32_t>> storage[10];
+      std::aligned_storage_t<sizeof(char), std::alignment_of<uint32_t>::value> storage[10];
       std::string data("123456789");
 
       char* begin = (char*)&storage[0];
diff --git a/test/test_numeric.cpp b/test/test_numeric.cpp
index 411f74a5..4029c484 100644
--- a/test/test_numeric.cpp
+++ b/test/test_numeric.cpp
@@ -33,6 +33,7 @@ SOFTWARE.
 #include "etl/list.h"
 
 #include <algorithm>
+#include <limits>
 #include <numeric>
 #include <vector>
 #include <deque>
diff --git a/test/test_poly_span_dynamic_extent.cpp b/test/test_poly_span_dynamic_extent.cpp
index 2378f564..b617ec2b 100644
--- a/test/test_poly_span_dynamic_extent.cpp
+++ b/test/test_poly_span_dynamic_extent.cpp
@@ -158,7 +158,7 @@ namespace
       etl::poly_span<Base> s(data);
       CHECK_EQUAL(sizeof(Derived), s.size_of_element());
       CHECK(!s.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK_EQUAL(s.size() * sizeof(Derived), s.size_bytes());
       CHECK_EQUAL(data[0].value(), s[0].value());
       CHECK_EQUAL(data[1].value(), s[1].value());
@@ -173,7 +173,7 @@ namespace
       etl::poly_span<const Base> s(data);
       CHECK_EQUAL(sizeof(Derived), s.size_of_element());
       CHECK(!s.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK_EQUAL(s.size() * sizeof(Derived), s.size_bytes());
       CHECK_EQUAL(data[0].value(), s[0].value());
       CHECK_EQUAL(data[1].value(), s[1].value());
@@ -491,8 +491,8 @@ namespace
 
       etl::poly_span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 
@@ -504,8 +504,8 @@ namespace
 
       etl::poly_span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 #endif
@@ -517,8 +517,8 @@ namespace
 
       etl::poly_span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 
diff --git a/test/test_poly_span_fixed_extent.cpp b/test/test_poly_span_fixed_extent.cpp
index 3c51ddb3..b6cb5976 100644
--- a/test/test_poly_span_fixed_extent.cpp
+++ b/test/test_poly_span_fixed_extent.cpp
@@ -158,7 +158,7 @@ namespace
       etl::poly_span<Base, 4U> s(data);
       CHECK_EQUAL(sizeof(Derived), s.size_of_element());
       CHECK(!s.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK_EQUAL(s.size() * sizeof(Derived), s.size_bytes());
       CHECK_EQUAL(data[0].value(), s[0].value());
       CHECK_EQUAL(data[1].value(), s[1].value());
@@ -173,7 +173,7 @@ namespace
       etl::poly_span<const Base, 4U> s(data);
       CHECK_EQUAL(sizeof(Derived), s.size_of_element());
       CHECK(!s.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK_EQUAL(s.size() * sizeof(Derived), s.size_bytes());
       CHECK_EQUAL(data[0].value(), s[0].value());
       CHECK_EQUAL(data[1].value(), s[1].value());
@@ -510,8 +510,8 @@ namespace
 
       etl::poly_span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 
@@ -523,8 +523,8 @@ namespace
 
       etl::poly_span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 #endif
@@ -536,8 +536,8 @@ namespace
 
       etl::poly_span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 
diff --git a/test/test_smallest.cpp b/test/test_smallest.cpp
index 6b38aae9..e7aaa290 100644
--- a/test/test_smallest.cpp
+++ b/test/test_smallest.cpp
@@ -102,7 +102,6 @@ namespace
     //*************************************************************************
     TEST(test_non_pod_vt)
     {
-      size_t size;
       bool   type;
 
       struct S1 { char a; char  b; char c; };
@@ -110,6 +109,8 @@ namespace
       struct S3 { int  a; short b; char c; };
 
 #if ETL_USING_CPP17
+      size_t size;
+      
       size = etl::smallest_type_v<S1, S2, S3>;
       CHECK_EQUAL(sizeof(S1), size);
 #endif
diff --git a/test/test_span_dynamic_extent.cpp b/test/test_span_dynamic_extent.cpp
index 48fc6566..b1a325ef 100644
--- a/test/test_span_dynamic_extent.cpp
+++ b/test/test_span_dynamic_extent.cpp
@@ -620,8 +620,8 @@ namespace
       View  view(etldata.begin(), etldata.end());
       CView cview(etldata.begin(), etldata.end());
 
-      size_t hashdata = etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&etldata[0]),
-                                                                reinterpret_cast<const uint8_t*>(&etldata[etldata.size()]));
+      size_t hashdata = etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(etldata.data()),
+                                                                reinterpret_cast<const uint8_t*>(etldata.data() + etldata.size()));
 
       size_t hashview  = etl::hash<View>()(view);
       size_t hashcview = etl::hash<CView>()(cview);
@@ -638,8 +638,8 @@ namespace
 
       etl::span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 
@@ -651,8 +651,8 @@ namespace
 
       etl::span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 #endif
@@ -664,8 +664,8 @@ namespace
 
       etl::span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 
@@ -805,7 +805,7 @@ namespace
 
       for (int i = 0; i < 20; ++i)
       {
-        CHECK_EQUAL(expected[i % ETL_OR_STD::size(expected)], *sci++);
+        CHECK_EQUAL(expected[i % ETL_OR_STD17::size(expected)], *sci++);
       }
     }
 
@@ -838,7 +838,7 @@ namespace
 
       for (int i = 0; i < 20; ++i)
       {
-        CHECK_EQUAL(expected[i % ETL_OR_STD::size(expected)], *++sci);
+        CHECK_EQUAL(expected[i % ETL_OR_STD17::size(expected)], *++sci);
       }
     }
 
@@ -855,7 +855,7 @@ namespace
 
       for (int i = 0; i < 20; ++i)
       {
-        CHECK_EQUAL(expected[i % ETL_OR_STD::size(expected)], *++sci);
+        CHECK_EQUAL(expected[i % ETL_OR_STD17::size(expected)], *++sci);
       }
     }
 
@@ -871,7 +871,7 @@ namespace
 
       for (int i = 0; i < 20; ++i)
       {
-        CHECK_EQUAL(expected[i % ETL_OR_STD::size(expected)], *sci++);
+        CHECK_EQUAL(expected[i % ETL_OR_STD17::size(expected)], *sci++);
       }
     }
 
@@ -888,7 +888,7 @@ namespace
 
       for (int i = 0; i < 20; ++i)
       {
-        CHECK_EQUAL(expected[i % ETL_OR_STD::size(expected)], *sci++);
+        CHECK_EQUAL(expected[i % ETL_OR_STD17::size(expected)], *sci++);
       }
     }
 
diff --git a/test/test_span_fixed_extent.cpp b/test/test_span_fixed_extent.cpp
index 185f85af..f251b3d7 100644
--- a/test/test_span_fixed_extent.cpp
+++ b/test/test_span_fixed_extent.cpp
@@ -610,8 +610,8 @@ namespace
       View  view(etldata.begin(), etldata.end());
       CView cview(etldata.begin(), etldata.end());
 
-      size_t hashdata = etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&etldata[0]),
-                                                                reinterpret_cast<const uint8_t*>(&etldata[etldata.size()]));
+      size_t hashdata = etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(etldata.data()),
+                                                                reinterpret_cast<const uint8_t*>(etldata.data() + etldata.size()));
 
       size_t hashview  = etl::hash<View>()(view);
       size_t hashcview = etl::hash<CView>()(cview);
@@ -628,8 +628,8 @@ namespace
 
       etl::span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 
@@ -641,8 +641,8 @@ namespace
 
       etl::span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 #endif
@@ -654,8 +654,8 @@ namespace
 
       etl::span s = data;
 
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.extent);
-      CHECK_EQUAL(ETL_OR_STD::size(data), s.size());
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.extent);
+      CHECK_EQUAL(ETL_OR_STD17::size(data), s.size());
       CHECK((std::is_same_v<int, std::remove_reference_t<decltype(s.front())>>));
     }
 
@@ -795,7 +795,7 @@ namespace
 
       for (int i = 0; i < 20; ++i)
       {
-        CHECK_EQUAL(expected[i % ETL_OR_STD::size(expected)], *sci++);
+        CHECK_EQUAL(expected[i % ETL_OR_STD17::size(expected)], *sci++);
       }
     }
 
@@ -828,7 +828,7 @@ namespace
 
       for (int i = 0; i < 20; ++i)
       {
-        CHECK_EQUAL(expected[i % ETL_OR_STD::size(expected)], *++sci);
+        CHECK_EQUAL(expected[i % ETL_OR_STD17::size(expected)], *++sci);
       }
     }
 
@@ -845,7 +845,7 @@ namespace
 
       for (int i = 0; i < 20; ++i)
       {
-        CHECK_EQUAL(expected[i % ETL_OR_STD::size(expected)], *++sci);
+        CHECK_EQUAL(expected[i % ETL_OR_STD17::size(expected)], *++sci);
       }
     }
 
@@ -861,7 +861,7 @@ namespace
 
       for (int i = 0; i < 20; ++i)
       {
-        CHECK_EQUAL(expected[i % ETL_OR_STD::size(expected)], *sci++);
+        CHECK_EQUAL(expected[i % ETL_OR_STD17::size(expected)], *sci++);
       }
     }
 
@@ -878,7 +878,7 @@ namespace
 
       for (int i = 0; i < 20; ++i)
       {
-        CHECK_EQUAL(expected[i % ETL_OR_STD::size(expected)], *sci++);
+        CHECK_EQUAL(expected[i % ETL_OR_STD17::size(expected)], *sci++);
       }
     }
 
diff --git a/test/test_string_char_external_buffer.cpp b/test/test_string_char_external_buffer.cpp
index ec49a3de..0ae93d4a 100644
--- a/test/test_string_char_external_buffer.cpp
+++ b/test/test_string_char_external_buffer.cpp
@@ -152,12 +152,12 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_default_constructor_use_array_buffer)
     {
-      Text text(array_text, ETL_OR_STD::size(array_text));
+      Text text(array_text, ETL_OR_STD17::size(array_text));
 
       CHECK_EQUAL(0U, text.size());
       CHECK(text.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.capacity());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.max_size());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.capacity());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.max_size());
       CHECK(text.begin() == text.end());
 #if ETL_HAS_STRING_TRUNCATION_CHECKS
       CHECK(!text.is_truncated());
@@ -167,12 +167,12 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_default_constructor_use_array_buffer_text)
     {
-      Text text(array_text, array_text, ETL_OR_STD::size(array_text));
+      Text text(array_text, array_text, ETL_OR_STD17::size(array_text));
 
       CHECK_EQUAL(text.size(), etl::strlen(array_text));
       CHECK(!text.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.capacity());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.max_size());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.capacity());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.max_size());
       CHECK(text.begin() != text.end());
 #if ETL_HAS_STRING_TRUNCATION_CHECKS
       CHECK(!text.is_truncated());
diff --git a/test/test_string_u16_external_buffer.cpp b/test/test_string_u16_external_buffer.cpp
index b013f52c..f73d7f4f 100644
--- a/test/test_string_u16_external_buffer.cpp
+++ b/test/test_string_u16_external_buffer.cpp
@@ -167,12 +167,12 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_default_constructor_use_array_buffer)
     {
-      Text text(array_text, ETL_OR_STD::size(array_text));
+      Text text(array_text, ETL_OR_STD17::size(array_text));
 
       CHECK_EQUAL(0U, text.size());
       CHECK(text.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.capacity());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.max_size());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.capacity());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.max_size());
       CHECK(text.begin() == text.end());
 #if ETL_HAS_STRING_TRUNCATION_CHECKS
       CHECK(!text.is_truncated());
@@ -182,12 +182,12 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_default_constructor_use_array_buffer_text)
     {
-      Text text(array_text, array_text, ETL_OR_STD::size(array_text));
+      Text text(array_text, array_text, ETL_OR_STD17::size(array_text));
 
       CHECK_EQUAL(text.size(), etl::strlen(array_text));
       CHECK(!text.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.capacity());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.max_size());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.capacity());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.max_size());
       CHECK(text.begin() != text.end());
 #if ETL_HAS_STRING_TRUNCATION_CHECKS
       CHECK(!text.is_truncated());
diff --git a/test/test_string_u32_external_buffer.cpp b/test/test_string_u32_external_buffer.cpp
index 133f2231..7ab8d612 100644
--- a/test/test_string_u32_external_buffer.cpp
+++ b/test/test_string_u32_external_buffer.cpp
@@ -167,12 +167,12 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_default_constructor_use_array_buffer)
     {
-      Text text(array_text, ETL_OR_STD::size(array_text));
+      Text text(array_text, ETL_OR_STD17::size(array_text));
 
       CHECK_EQUAL(0U, text.size());
       CHECK(text.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.capacity());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.max_size());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.capacity());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.max_size());
       CHECK(text.begin() == text.end());
 #if ETL_HAS_STRING_TRUNCATION_CHECKS
       CHECK(!text.is_truncated());
@@ -182,12 +182,12 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_default_constructor_use_array_buffer_text)
     {
-      Text text(array_text, array_text, ETL_OR_STD::size(array_text));
+      Text text(array_text, array_text, ETL_OR_STD17::size(array_text));
 
       CHECK_EQUAL(text.size(), etl::strlen(array_text));
       CHECK(!text.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.capacity());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.max_size());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.capacity());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.max_size());
       CHECK(text.begin() != text.end());
 #if ETL_HAS_STRING_TRUNCATION_CHECKS
       CHECK(!text.is_truncated());
diff --git a/test/test_string_wchar_t_external_buffer.cpp b/test/test_string_wchar_t_external_buffer.cpp
index 7c092548..cd694a84 100644
--- a/test/test_string_wchar_t_external_buffer.cpp
+++ b/test/test_string_wchar_t_external_buffer.cpp
@@ -168,12 +168,12 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_default_constructor_use_array_buffer)
     {
-      Text text(array_text, ETL_OR_STD::size(array_text));
+      Text text(array_text, ETL_OR_STD17::size(array_text));
 
       CHECK_EQUAL(0U, text.size());
       CHECK(text.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.capacity());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.max_size());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.capacity());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.max_size());
       CHECK(text.begin() == text.end());
 #if ETL_HAS_STRING_TRUNCATION_CHECKS
       CHECK(!text.is_truncated());
@@ -183,12 +183,12 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_default_constructor_use_array_buffer_text)
     {
-      Text text(array_text, array_text, ETL_OR_STD::size(array_text));
+      Text text(array_text, array_text, ETL_OR_STD17::size(array_text));
 
       CHECK_EQUAL(text.size(), etl::strlen(array_text));
       CHECK(!text.empty());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.capacity());
-      CHECK_EQUAL(ETL_OR_STD::size(array_text) - 1, text.max_size());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.capacity());
+      CHECK_EQUAL(ETL_OR_STD17::size(array_text) - 1, text.max_size());
       CHECK(text.begin() != text.end());
 #if ETL_HAS_STRING_TRUNCATION_CHECKS
       CHECK(!text.is_truncated());
diff --git a/test/test_task_scheduler.cpp b/test/test_task_scheduler.cpp
index 76350e9b..5d33f669 100644
--- a/test/test_task_scheduler.cpp
+++ b/test/test_task_scheduler.cpp
@@ -181,7 +181,7 @@ namespace
 
       common.Clear();
 
-      s.add_task_list(taskList, ETL_OR_STD::size(taskList));
+      s.add_task_list(taskList, ETL_OR_STD17::size(taskList));
 
       CHECK(task1.task_added);
       CHECK(task2.task_added);
@@ -204,7 +204,7 @@ namespace
 
       s.set_idle_callback(common.idle_callback);
       s.set_watchdog_callback(common.watchdog_callback);
-      s.add_task_list(taskList, ETL_OR_STD::size(taskList));
+      s.add_task_list(taskList, ETL_OR_STD17::size(taskList));
       s.start(); // If 'start' returns then the idle callback was successfully called.
 
       WorkList_t expected = { "T3W1", "T2W1", "T1W1", "T3W2", "T2W2", "T1W2", "T3W3", "T2W3", "T1W3", "T2W4" };
@@ -229,7 +229,7 @@ namespace
 
       s.set_idle_callback(common.idle_callback);
       s.set_watchdog_callback(common.watchdog_callback);
-      s.add_task_list(taskList, ETL_OR_STD::size(taskList));
+      s.add_task_list(taskList, ETL_OR_STD17::size(taskList));
       s.start(); // If 'start' returns then the idle callback was successfully called.
 
       WorkList_t expected = { "T3W1", "T3W2", "T2W1", "T2W2", "T2W3", "T2W4", "T1W1", "T1W2", "T1W3", "T3W3" };
@@ -254,7 +254,7 @@ namespace
 
       s.set_idle_callback(common.idle_callback);
       s.set_watchdog_callback(common.watchdog_callback);
-      s.add_task_list(taskList, ETL_OR_STD::size(taskList));
+      s.add_task_list(taskList, ETL_OR_STD17::size(taskList));
       s.start(); // If 'start' returns then the idle callback was successfully called.
 
       WorkList_t expected = { "T3W1", "T3W2", "T2W1", "T2W2", "T3W3", "T2W3", "T2W4", "T1W1", "T1W2", "T1W3" };
@@ -279,7 +279,7 @@ namespace
 
       s.set_idle_callback(common.idle_callback);
       s.set_watchdog_callback(common.watchdog_callback);
-      s.add_task_list(taskList, ETL_OR_STD::size(taskList));
+      s.add_task_list(taskList, ETL_OR_STD17::size(taskList));
       s.start(); // If 'start' returns then the idle callback was successfully called.
 
       WorkList_t expected = { "T2W1", "T2W2", "T1W1", "T3W1", "T2W3", "T3W2", "T1W2", "T3W3", "T2W4", "T1W3" };
diff --git a/test/test_to_arithmetic.cpp b/test/test_to_arithmetic.cpp
index 2084ea86..d4695216 100644
--- a/test/test_to_arithmetic.cpp
+++ b/test/test_to_arithmetic.cpp
@@ -31,6 +31,7 @@ SOFTWARE.
 #include <ostream>
 #include <sstream>
 #include <iomanip>
+#include <limits>
 
 #include "etl/to_arithmetic.h"
 #include "etl/string.h"
diff --git a/test/test_to_arithmetic_u16.cpp b/test/test_to_arithmetic_u16.cpp
index 1e0415df..6dd0e6e7 100644
--- a/test/test_to_arithmetic_u16.cpp
+++ b/test/test_to_arithmetic_u16.cpp
@@ -31,6 +31,7 @@ SOFTWARE.
 #include <ostream>
 #include <sstream>
 #include <iomanip>
+#include <limits>
 
 #include "etl/to_arithmetic.h"
 #include "etl/u16string.h"
diff --git a/test/test_to_arithmetic_u32.cpp b/test/test_to_arithmetic_u32.cpp
index 8fa3e2ed..23474453 100644
--- a/test/test_to_arithmetic_u32.cpp
+++ b/test/test_to_arithmetic_u32.cpp
@@ -31,6 +31,7 @@ SOFTWARE.
 #include <ostream>
 #include <sstream>
 #include <iomanip>
+#include <limits>
 
 #include "etl/to_arithmetic.h"
 #include "etl/u32string.h"
diff --git a/test/test_to_arithmetic_wchar_t.cpp b/test/test_to_arithmetic_wchar_t.cpp
index d15b71f5..2754e1af 100644
--- a/test/test_to_arithmetic_wchar_t.cpp
+++ b/test/test_to_arithmetic_wchar_t.cpp
@@ -31,6 +31,7 @@ SOFTWARE.
 #include <ostream>
 #include <sstream>
 #include <iomanip>
+#include <limits>
 
 #include "etl/to_arithmetic.h"
 #include "etl/wstring.h"
diff --git a/test/vs2022/cpp.hint b/test/vs2022/cpp.hint
index 0fd4bafc..31a4b7d1 100644
--- a/test/vs2022/cpp.hint
+++ b/test/vs2022/cpp.hint
@@ -21,33 +21,16 @@
 #define ETL_CPP11_SUPPORTED
 #define ETL_CPP14_SUPPORTED
 #define ETL_CPP17_SUPPORTED
-
 #define TEST
 #define CHECK
 #define CHECK_EQUAL
 #define CHECK_THROW
-// Hint files help the Visual Studio IDE interpret Visual C++ identifiers
-// such as names of functions and macros.
-// For more information see https://go.microsoft.com/fwlink/?linkid=865984
 #define ETL_ASSERT(b, e)
 #define ETL_ASSERT(b, e) {if (!(b)) {etl::error_handler::error((e)); throw((e));}}
 #define ETL_ASSERT(b, e) {if (!(b)) {throw((e));}}
 #define ETL_ASSERT(b, e) {if(!(b)) {etl::error_handler::error((e));}}
 #define ETL_ASSERT(b, e) assert((b))
-// Hint files help the Visual Studio IDE interpret Visual C++ identifiers
-// such as names of functions and macros.
-// For more information see https://go.microsoft.com/fwlink/?linkid=865984
 #define ETL_NULLPTR
-// Hint files help the Visual Studio IDE interpret Visual C++ identifiers
-// such as names of functions and macros.
-// For more information see https://go.microsoft.com/fwlink/?linkid=865984
 #define ETL_NODISCARD [[nodiscard]]
 #define ETL_NODISCARD
-// Hint files help the Visual Studio IDE interpret Visual C++ identifiers
-// such as names of functions and macros.
-// For more information see https://go.microsoft.com/fwlink/?linkid=865984
-#define ETL_CONSTEXPR
-// Hint files help the Visual Studio IDE interpret Visual C++ identifiers
-// such as names of functions and macros.
-// For more information see https://go.microsoft.com/fwlink/?linkid=865984
-#define ETL_NOEXCEPT
+#define ETL_CONSTANT
diff --git a/test/vs2022/etl.vcxproj b/test/vs2022/etl.vcxproj
index 7db39d34..01d70e22 100644
--- a/test/vs2022/etl.vcxproj
+++ b/test/vs2022/etl.vcxproj
@@ -13452,10 +13452,6 @@
     <None Include="..\..\scripts\update_release.py" />
     <None Include="..\meson.build" />
     <None Include="..\runsanitychecks.sh" />
-    <None Include="..\runtests-O1.sh" />
-    <None Include="..\runtests-O2.sh" />
-    <None Include="..\runtests-O3.sh" />
-    <None Include="..\runtests-c++14.sh" />
     <None Include="..\runtests.sh" />
     <None Include="cpp.hint" />
   </ItemGroup>
diff --git a/test/vs2022/etl.vcxproj.filters b/test/vs2022/etl.vcxproj.filters
index 6e042a5a..24db7477 100644
--- a/test/vs2022/etl.vcxproj.filters
+++ b/test/vs2022/etl.vcxproj.filters
@@ -3472,9 +3472,6 @@
     <None Include="..\runsanitychecks.sh">
       <Filter>Tests\Scripts</Filter>
     </None>
-    <None Include="..\runtests.sh">
-      <Filter>Tests\Scripts</Filter>
-    </None>
     <None Include="..\..\.clang-format">
       <Filter>Resource Files</Filter>
     </None>
@@ -3517,22 +3514,7 @@
     <None Include="..\..\.github\workflows\msvc.yml">
       <Filter>Resource Files\CI\Github</Filter>
     </None>
-    <None Include="..\runtests-c++14.sh">
-      <Filter>Tests\Scripts</Filter>
-    </None>
-    <None Include="..\runtests-O1.sh">
-      <Filter>Tests\Scripts</Filter>
-    </None>
-    <None Include="..\runtests-O2.sh">
-      <Filter>Tests\Scripts</Filter>
-    </None>
-    <None Include="..\runtests-O3.sh">
-      <Filter>Tests\Scripts</Filter>
-    </None>
-    <None Include="..\..\.github\workflows\msvc.yml">
-      <Filter>Resource Files\CI\Github</Filter>
-    </None>
-    <None Include="..\runtests-c++14.sh">
+    <None Include="..\runtests.sh">
       <Filter>Tests\Scripts</Filter>
     </None>
   </ItemGroup>