diff --git a/include/etl/circular_iterator.h b/include/etl/circular_iterator.h
index 764f1467..468102f5 100644
--- a/include/etl/circular_iterator.h
+++ b/include/etl/circular_iterator.h
@@ -34,42 +34,233 @@ SOFTWARE.
 #include "platform.h"
 #include "iterator.h"
 #include "span.h"
+#include "static_assert.h"
 
 ///\defgroup iterator Iterator types
 
 namespace etl
 {
+  namespace private_circular_iterator
+  {
+    //***************************************************************************
+    /// Common circular iterator implementation.
+    //***************************************************************************
+    template <typename TIterator>
+    class circular_iterator_common
+      : public etl::iterator<typename etl::iterator_traits<TIterator>::iterator_category, typename etl::iterator_traits<TIterator>::value_type>
+    {
+    public:
+
+      typedef typename etl::iterator_traits<TIterator>::value_type        value_type;
+      typedef typename etl::iterator_traits<TIterator>::difference_type   difference_type;
+      typedef typename etl::iterator_traits<TIterator>::pointer           pointer;
+      typedef typename etl::iterator_traits<TIterator>::reference         reference;
+      typedef typename etl::iterator_traits<TIterator>::iterator_category iterator_category;
+
+      //***************************************************************************
+      /// Default constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR14 circular_iterator_common()
+        : itr_begin(TIterator())
+        , itr_end(TIterator())
+        , itr(TIterator())
+      {
+      }
+
+      //***************************************************************************
+      /// Construct from iterators.
+      //***************************************************************************
+      ETL_CONSTEXPR14 circular_iterator_common(TIterator itr_begin_, TIterator itr_end_, TIterator start_)
+        : itr_begin(itr_begin_)
+        , itr_end(itr_end_)
+        , itr(start_)
+      {
+      }
+
+      //***************************************************************************
+      /// Copy constructor
+      //***************************************************************************
+      ETL_CONSTEXPR14 circular_iterator_common(const circular_iterator_common& other)
+        : itr_begin(other.itr_begin)
+        , itr_end(other.itr_end)
+        , itr(other.itr)
+      {
+      }
+
+      //***************************************************************************
+      /// Assignment from span.
+      //***************************************************************************
+      ETL_CONSTEXPR14 circular_iterator_common& operator =(const etl::span<TIterator>& span_)
+      {
+        itr_begin = span_.begin();
+        itr_end   = span_.end();
+        itr       = itr_begin;
+
+        return *this;
+      }
+
+      //***************************************************************************
+      /// Assignment from circular_iterator.
+      //***************************************************************************
+      ETL_CONSTEXPR14 circular_iterator_common& operator =(const circular_iterator_common& other)
+      {
+        itr_begin = other.itr_begin;
+        itr_end   = other.itr_end;
+        itr       = other.itr;
+
+        return *this;
+      }
+
+      //***************************************************************************
+      /// Beginning of the range.
+      //***************************************************************************
+      ETL_CONSTEXPR14 TIterator begin() const
+      {
+        return itr_begin;
+      }
+
+      //***************************************************************************
+      /// End of the range.
+      //***************************************************************************
+      ETL_CONSTEXPR14 TIterator end() const
+      {
+        return itr_end;
+      }
+
+      //***************************************************************************
+      /// How long is the range?
+      //***************************************************************************
+      ETL_CONSTEXPR14 size_t size() const
+      {
+        return etl::distance(itr_begin, itr_end);
+      }
+
+      //***************************************************************************
+      /// Is there nothing to iterate over?
+      //***************************************************************************
+      ETL_CONSTEXPR14 bool empty() const
+      {
+        return (itr_begin == itr_end);
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14 value_type operator *()
+      {
+        return *itr;
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14 const value_type operator *() const
+      {
+        return *itr;
+      }
+
+      //***************************************************************************
+      /// -> operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14 TIterator operator ->()
+      {
+        return itr;
+      }
+
+      //***************************************************************************
+      /// -> operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14 const TIterator operator ->() const
+      {
+        return itr;
+      }
+
+      //***************************************************************************
+      /// Conversion operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14 operator TIterator() const
+      {
+        return itr;
+      }
+
+      //***************************************************************************
+      /// Conversion to base iterator type.
+      //***************************************************************************
+      ETL_CONSTEXPR14 TIterator current() const
+      {
+        return itr;
+      }
+
+      //***************************************************************************
+      /// Assign from iterator.
+      //***************************************************************************
+      ETL_CONSTEXPR14 void set(TIterator itr_)
+      {
+        itr = itr_;
+      }
+
+    protected:
+
+      TIterator itr_begin; ///< The underlying begin iterator.
+      TIterator itr_end;   ///< The underlying end iterator.
+      TIterator itr;       ///< The underlying iterator.
+    };
+  }
+
+  //***************************************************************************
   /// A circular iterator class.
   /// This iterator can be given a pair of iterator values, which will loop if the start or end of the range is reached.
   ///\ingroup iterator
-  template <typename TIterator>
-  class circular_iterator : etl::iterator<typename etl::iterator_traits<TIterator>::iterator_category, typename etl::iterator_traits<TIterator>::value_type>
+  //***************************************************************************
+  template <typename TIterator, typename TTag = typename etl::iterator_traits<TIterator>::iterator_category>
+  class circular_iterator
   {
+    ETL_STATIC_ASSERT((etl::is_same<TTag, ETL_OR_STD::input_iterator_tag>::value_type),  "input_iterator_catagory is not supported by circular_iterator");
+    ETL_STATIC_ASSERT((etl::is_same<TTag, ETL_OR_STD::output_iterator_tag>::value_type), "output_iterator_catagory is not supported by circular_iterator");
+  };
+
+  //***************************************************************************
+  /// A circular iterator class.
+  /// Specialisation for forward iterators.
+  ///\ingroup iterator
+  /// //***************************************************************************
+  template <typename TIterator>
+  class circular_iterator<TIterator, ETL_OR_STD::forward_iterator_tag> 
+    : public etl::private_circular_iterator::circular_iterator_common<TIterator>
+  {
+  private:
+
+    typedef etl::private_circular_iterator::circular_iterator_common<TIterator> base_t;
+
   public:
 
-    typedef typename etl::iterator_traits<TIterator>::value_type        value_type;
-    typedef typename etl::iterator_traits<TIterator>::difference_type   difference_type;
-    typedef typename etl::iterator_traits<TIterator>::pointer           pointer;
-    typedef typename etl::iterator_traits<TIterator>::reference         reference;
-    typedef typename etl::iterator_traits<TIterator>::iterator_category iterator_category;
+    typedef typename base_t::value_type        value_type;
+    typedef typename base_t::difference_type   difference_type;
+    typedef typename base_t::pointer           pointer;
+    typedef typename base_t::reference         reference;
+    typedef typename base_t::iterator_category iterator_category;
 
     //***************************************************************************
     /// Default constructor.
     //***************************************************************************
-    circular_iterator()
-      : itr_begin(TIterator())
-      , itr_end(TIterator())
-      , itr(TIterator())
+    ETL_CONSTEXPR14 circular_iterator()
+      : circular_iterator_common()
     {
     }
 
     //***************************************************************************
     /// Construct from iterators.
     //***************************************************************************
-    circular_iterator(TIterator itr_begin_, TIterator itr_end_)
-      : itr_begin(itr_begin_)
-      , itr_end(itr_end_)
-      , itr(itr_begin_)
+    ETL_CONSTEXPR14 circular_iterator(TIterator itr_begin_, TIterator itr_end_)
+      : circular_iterator_common(itr_begin_, itr_end_, itr_begin_)
+    {
+    }
+
+    //***************************************************************************
+    /// Construct from start + iterators.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator(TIterator itr_begin_, TIterator itr_end_, TIterator start_)
+      : circular_iterator_common(itr_begin_, itr_end_, start_)
     {
     }
 
@@ -77,59 +268,139 @@ namespace etl
     /// Construct from span.
     //***************************************************************************
     template <typename T>
-    circular_iterator(const etl::span<T>& span_)
-      : itr_begin(span_.begin())
-      , itr_end(span_.end())
-      , itr(itr_begin)
+    ETL_CONSTEXPR14 circular_iterator(const etl::span<T>& span_)
+      : circular_iterator_common(span_.begin(), span_.end(), span_.begin())
+    {
+    }
+
+    //***************************************************************************
+    /// Construct from start + span.
+    //***************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14 circular_iterator(const etl::span<T>& span_, TIterator start_)
+      : circular_iterator_common(span_.begin(), span_.end(), start_)
     {
     }
 
     //***************************************************************************
     /// Copy constructor
     //***************************************************************************
-    circular_iterator(const circular_iterator& other)
-      : itr_begin(other.itr_begin)
-      , itr_end(other.itr_end)
-      , itr(other.itr)
+    ETL_CONSTEXPR14 circular_iterator(const circular_iterator& other)
+      : circular_iterator_common(other)
     {
     }
 
-    //***************************************************************************
-    /// Beginning of the range.
-    //***************************************************************************
-    TIterator begin() const
-    {
-      return itr_begin;
-    }
-
-    //***************************************************************************
-    /// End of the range.
-    //***************************************************************************
-    TIterator end() const
-    {
-      return itr_end;
-    }
-
-    //***************************************************************************
-    /// How long is the range?
-    //***************************************************************************
-    size_t size() const
-    {
-      return etl::distance(itr_begin, itr_end);
-    }
-
-    //***************************************************************************
-    /// Is there nothing to iteratte over?
-    //***************************************************************************
-    bool empty() const
-    {
-      return (itr_begin == itr_end);
-    }
-
     //***************************************************************************
     /// Increment.
     //***************************************************************************
-    circular_iterator& operator ++()
+    ETL_CONSTEXPR14 circular_iterator& operator ++()
+    {
+      if (++this->itr == this->itr_end)
+      {
+        this->itr = this->itr_begin;
+      }
+
+      return *this;
+    }
+
+    //***************************************************************************
+    /// Increment.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator operator ++(int)
+    {
+      circular_iterator original(*this);
+
+      ++(*this);
+
+      return (original);
+    }
+
+    //***************************************************************************
+    /// Assign from iterator.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator& operator =(TIterator itr_)
+    {
+      itr = itr_;
+
+      return *this;
+    }
+  };
+
+  //***************************************************************************
+  /// A circular iterator class.
+  /// Specialisation for random access iterators.
+  ///\ingroup iterator
+  /// //***************************************************************************
+  template <typename TIterator>
+  class circular_iterator<TIterator, ETL_OR_STD::bidirectional_iterator_tag>
+    : public etl::private_circular_iterator::circular_iterator_common<TIterator>
+  {
+  private:
+
+    typedef etl::private_circular_iterator::circular_iterator_common<TIterator> base_t;
+
+  public:
+
+    typedef typename base_t::value_type        value_type;
+    typedef typename base_t::difference_type   difference_type;
+    typedef typename base_t::pointer           pointer;
+    typedef typename base_t::reference         reference;
+    typedef typename base_t::iterator_category iterator_category;
+
+    //***************************************************************************
+    /// Default constructor.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator()
+      : circular_iterator_common()
+    {
+    }
+
+    //***************************************************************************
+    /// Construct from iterators.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator(TIterator itr_begin_, TIterator itr_end_)
+      : circular_iterator_common(itr_begin_, itr_end_, itr_begin_)
+    {
+    }
+
+    //***************************************************************************
+    /// Construct from start + iterators.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator(TIterator itr_begin_, TIterator itr_end_, TIterator start_)
+      : circular_iterator_common(itr_begin_, itr_end_, start_)
+    {
+    }
+
+    //***************************************************************************
+    /// Construct from span.
+    //***************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14 circular_iterator(const etl::span<T>& span_)
+      : circular_iterator_common(span_.begin(), span_.end(), span_.begin())
+    {
+    }
+
+    //***************************************************************************
+    /// Construct from start + span.
+    //***************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14 circular_iterator(const etl::span<T>& span_, TIterator start_)
+      : circular_iterator_common(span_.begin(), span_.end(), start_)
+    {
+    }
+
+    //***************************************************************************
+    /// Copy constructor
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator(const circular_iterator& other)
+      : circular_iterator_common(other)
+    {
+    }
+
+    //***************************************************************************
+    /// Increment.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator& operator ++()
     {
       if (++itr == itr_end)
       {
@@ -142,7 +413,7 @@ namespace etl
     //***************************************************************************
     /// Increment.
     //***************************************************************************
-    circular_iterator operator ++(int)
+    ETL_CONSTEXPR14 circular_iterator operator ++(int)
     {
       circular_iterator original(*this);
 
@@ -154,7 +425,7 @@ namespace etl
     //***************************************************************************
     /// Decrement.
     //***************************************************************************
-    circular_iterator& operator --()
+    ETL_CONSTEXPR14 circular_iterator& operator --()
     {
       if (itr == itr_begin)
       {
@@ -173,7 +444,7 @@ namespace etl
     //***************************************************************************
     /// Decrement.
     //***************************************************************************
-    circular_iterator operator --(int)
+    ETL_CONSTEXPR14 circular_iterator operator --(int)
     {
       circular_iterator original(*this);
 
@@ -183,86 +454,183 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Dereference operator.
+    /// Assign from iterator.
     //***************************************************************************
-    value_type operator *()
+    ETL_CONSTEXPR14 circular_iterator& operator =(TIterator itr_)
+    {
+      itr = itr_;
+
+      return *this;
+    }
+  };
+
+  //***************************************************************************
+  /// A circular iterator class.
+  /// Specialisation for random access iterators.
+  ///\ingroup iterator
+  //***************************************************************************
+  template <typename TIterator>
+  class circular_iterator<TIterator, ETL_OR_STD::random_access_iterator_tag>
+    : public etl::private_circular_iterator::circular_iterator_common<TIterator>
+  {
+  private:
+
+    typedef etl::private_circular_iterator::circular_iterator_common<TIterator> base_t;
+
+  public:
+
+    typedef typename base_t::value_type        value_type;
+    typedef typename base_t::difference_type   difference_type;
+    typedef typename base_t::pointer           pointer;
+    typedef typename base_t::reference         reference;
+    typedef typename base_t::iterator_category iterator_category;
+
+    //***************************************************************************
+    /// Default constructor.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator()
+      : circular_iterator_common()
     {
-      return *itr;
     }
 
     //***************************************************************************
-    /// Dereference operator.
+    /// Construct from iterators.
     //***************************************************************************
-    const value_type operator *() const
+    ETL_CONSTEXPR14 circular_iterator(TIterator itr_begin_, TIterator itr_end_)
+      : circular_iterator_common(itr_begin_, itr_end_, itr_begin_)
     {
-      return *itr;
     }
 
     //***************************************************************************
-    /// -> operator.
+    /// Construct from start + iterators.
     //***************************************************************************
-    TIterator operator ->()
+    ETL_CONSTEXPR14 circular_iterator(TIterator itr_begin_, TIterator itr_end_, TIterator start_)
+      : circular_iterator_common(itr_begin_, itr_end_, start_)
     {
-      return itr;
     }
 
     //***************************************************************************
-    /// -> operator.
+    /// Construct from span.
     //***************************************************************************
-    const TIterator operator ->() const
+    template <typename T>
+    ETL_CONSTEXPR14 circular_iterator(const etl::span<T>& span_)
+      : circular_iterator_common(span_.begin(), span_.end(), span_.begin())
     {
-      return itr;
     }
 
     //***************************************************************************
-    /// Conversion operator.
+    /// Construct from start + span.
     //***************************************************************************
-    operator TIterator() const
+    template <typename T>
+    ETL_CONSTEXPR14 circular_iterator(const etl::span<T>& span_, TIterator start_)
+      : circular_iterator_common(span_.begin(), span_.end(), start_)
     {
-      return itr;
+    }
+
+    //***************************************************************************
+    /// Copy constructor
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator(const circular_iterator& other)
+      : circular_iterator_common(other)
+    {
+    }
+
+    //***************************************************************************
+    /// Increment.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator& operator ++()
+    {
+      if (++itr == itr_end)
+      {
+        itr = itr_begin;
+      }
+
+      return *this;
+    }
+
+    //***************************************************************************
+    /// Increment.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator operator ++(int)
+    {
+      circular_iterator original(*this);
+
+      ++(*this);
+
+      return (original);
+    }
+
+    //***************************************************************************
+    /// Decrement.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator& operator --()
+    {
+      if (itr == itr_begin)
+      {
+        typename etl::reverse_iterator<TIterator> ritr(itr_end);
+        ++ritr;
+        itr = ritr.base();
+      }
+      else
+      {
+        --itr;
+      }
+
+      return *this;
+    }
+
+    //***************************************************************************
+    /// Decrement.
+    //***************************************************************************
+    ETL_CONSTEXPR14 circular_iterator operator --(int)
+    {
+      circular_iterator original(*this);
+
+      --(*this);
+
+      return (original);
     }
 
     //***************************************************************************
     /// += operator.
     //***************************************************************************
-    circular_iterator& operator +=(difference_type offset)
+    ETL_CONSTEXPR14 circular_iterator& operator +=(difference_type offset)
     {
+      const difference_type length = difference_type(size());
+      offset %= length;
+
       if (offset != 0)
       {
+        const difference_type distance_from_begin = etl::distance(itr_begin, itr);
+        const difference_type distance_to_end     = etl::distance(itr, itr_end);
+
         if (offset > 0)
         {
-          difference_type distance_to_end = etl::distance(itr, itr_end);
-          offset %= difference_type(size());
-
           if (distance_to_end > offset)
           {
-            etl::advance(itr, offset);
+            offset = distance_from_begin + offset;
           }
           else
-          {            
-            offset -= distance_to_end;
-            itr = itr_begin;
-            etl::advance(itr, offset);
+          {
+            offset = offset - distance_to_end;
           }
         }
         else
         {
-          difference_type distance_to_begin = etl::distance(itr_begin, itr);
-          offset %= difference_type(size());
+          offset = -offset;
 
-          if (distance_to_begin > -offset)
+          if (distance_from_begin >= offset)
           {
-            etl::advance(itr, offset);
+            offset = distance_from_begin - offset;
           }
           else
           {
-            offset += distance_to_begin;
-
-            typename etl::reverse_iterator<TIterator> ritr(itr_end);
-            etl::advance(ritr, -offset);
-            itr = ritr.base();
+            offset = offset - distance_from_begin;
+            offset = length - offset;
           }
         }
+
+        itr = itr_begin + offset;
       }
 
       return *this;
@@ -271,48 +639,28 @@ namespace etl
     //***************************************************************************
     /// -= operator.
     //***************************************************************************
-    circular_iterator& operator -=(typename etl::iterator_traits<TIterator>::difference_type offset)
+    ETL_CONSTEXPR14 circular_iterator& operator -=(typename etl::iterator_traits<TIterator>::difference_type offset)
     {
       return operator +=(-offset);
     }
 
     //***************************************************************************
-    /// Assignment from span.
+    /// Assign from iterator.
     //***************************************************************************
-    circular_iterator& operator =(const etl::span<TIterator>& span_)
+    ETL_CONSTEXPR14 circular_iterator& operator =(TIterator itr_)
     {
-      itr_begin = span_.begin();
-      itr_end   = span_.end();
-      itr       = itr_begin;
+      itr = itr_;
 
       return *this;
     }
-
-    //***************************************************************************
-    /// Assignment from circular_iterator.
-    //***************************************************************************
-    circular_iterator& operator =(circular_iterator other)
-    {
-      itr_begin = other.itr_begin;
-      itr_end   = other.itr_end;
-      itr       = other.itr;
-
-      return *this;
-    }
-
-  private:
-
-    TIterator itr_begin; ///< The underlying begin iterator.
-    TIterator itr_end;   ///< The underlying end iterator.
-    TIterator itr;       ///< The underlying iterator.
   };
 
   //*****************************************************************************
-  /// + difference operator.
+  /// + addition operator.
   //*****************************************************************************
   template <typename TIterator>
-  etl::circular_iterator<TIterator> operator +(etl::circular_iterator<TIterator>& lhs,
-                                               typename etl::iterator_traits<TIterator>::difference_type offset)
+  ETL_CONSTEXPR14 etl::circular_iterator<TIterator> operator +(etl::circular_iterator<TIterator>& lhs,
+                                                               typename etl::iterator_traits<TIterator>::difference_type offset)
   {
     etl::circular_iterator<TIterator> result(lhs);
     result += offset;
@@ -321,11 +669,11 @@ namespace etl
   }
 
   //*****************************************************************************
-  /// - difference operator.
+  /// - offset operator.
   //*****************************************************************************
   template <typename TIterator>
-  etl::circular_iterator<TIterator> operator -(etl::circular_iterator<TIterator>& lhs,
-    typename etl::iterator_traits<TIterator>::difference_type offset)
+  ETL_CONSTEXPR14 etl::circular_iterator<TIterator> operator -(etl::circular_iterator<TIterator>& lhs,
+                                                               typename etl::iterator_traits<TIterator>::difference_type offset)
   {
     etl::circular_iterator<TIterator> result(lhs);
     result -= offset;
@@ -333,22 +681,22 @@ namespace etl
     return result;
   }
 
-  ////*****************************************************************************
-  ///// - circular_iterator operator.
-  ////*****************************************************************************
-  //template <typename TIterator>
-  //typename etl::iterator_traits<TIterator>::difference_type operator -(etl::circular_iterator<TIterator>& lhs,
-  //                                                                    etl::circular_iterator<TIterator>& rhs)
-  //{
-  //  return TIterator(lhs) - TIterator(rhs);
-  //}
+  //*****************************************************************************
+  /// - circular_iterator difference operator.
+  //*****************************************************************************
+  template <typename TIterator>
+  ETL_CONSTEXPR14 typename etl::iterator_traits<TIterator>::difference_type operator -(etl::circular_iterator<TIterator>& lhs,
+                                                                                       etl::circular_iterator<TIterator>& rhs)
+  {
+    return TIterator(lhs) - TIterator(rhs);
+  }
 
   //*****************************************************************************
   /// Equality operator. circular_iterator == circular_iterator.
   //*****************************************************************************
   template <typename TIterator>
-  bool operator ==(const etl::circular_iterator<TIterator>& lhs,
-                   const etl::circular_iterator<TIterator>& rhs)
+  ETL_CONSTEXPR14 bool operator ==(const etl::circular_iterator<TIterator>& lhs,
+                                   const etl::circular_iterator<TIterator>& rhs)
   {
     return TIterator(lhs) == TIterator(rhs);
   }
@@ -357,8 +705,8 @@ namespace etl
   /// Equality operator. circular_iterator == iterator.
   //*****************************************************************************
   template <typename TIterator>
-  bool operator ==(const etl::circular_iterator<TIterator>& lhs,
-                   TIterator rhs)
+  ETL_CONSTEXPR14 bool operator ==(const etl::circular_iterator<TIterator>& lhs,
+                                   TIterator rhs)
   {
     return TIterator(lhs) == rhs;
   }
@@ -367,8 +715,8 @@ namespace etl
   /// Equality operator. iterator == circular_iterator.
   //*****************************************************************************
   template <typename TIterator>
-  bool operator ==(TIterator lhs,
-                   const etl::circular_iterator<TIterator>& rhs)
+  ETL_CONSTEXPR14 bool operator ==(TIterator lhs,
+                                   const etl::circular_iterator<TIterator>& rhs)
   {
     return lhs == TIterator(rhs);
   }
@@ -378,8 +726,8 @@ namespace etl
   /// Inequality operator. circular_iterator == circular_iterator.
   //*****************************************************************************
   template <typename TIterator>
-  bool operator !=(const etl::circular_iterator<TIterator>& lhs,
-                   const etl::circular_iterator<TIterator>& rhs)
+  ETL_CONSTEXPR14 bool operator !=(const etl::circular_iterator<TIterator>& lhs,
+                                   const etl::circular_iterator<TIterator>& rhs)
   {
     return !(lhs == rhs);
   }
@@ -388,8 +736,8 @@ namespace etl
   /// Inequality operator. circular_iterator == iterator.
   //*****************************************************************************
   template <typename TIterator>
-  bool operator !=(const etl::circular_iterator<TIterator>& lhs,
-                   TIterator rhs)
+  ETL_CONSTEXPR14 bool operator !=(const etl::circular_iterator<TIterator>& lhs,
+                                   TIterator rhs)
   {
     return !(lhs == rhs);
   }
@@ -398,8 +746,8 @@ namespace etl
   /// Inequality operator. iterator == circular_iterator.
   //*****************************************************************************
   template <typename TIterator>
-  bool operator !=(TIterator& lhs,
-                   const etl::circular_iterator<TIterator>& rhs)
+  ETL_CONSTEXPR14 bool operator !=(TIterator& lhs,
+                                   const etl::circular_iterator<TIterator>& rhs)
   {
     return !(lhs == rhs);
   }
diff --git a/test/test_circular_iterator.cpp b/test/test_circular_iterator.cpp
index 3e2505fc..3dca046b 100644
--- a/test/test_circular_iterator.cpp
+++ b/test/test_circular_iterator.cpp
@@ -28,6 +28,8 @@ SOFTWARE.
 
 #include "unit_test_framework.h"
 #include <list>
+#include <forward_list>
+#include <array>
 #include <ostream>
 
 #include "etl/circular_iterator.h"
@@ -42,38 +44,61 @@ SOFTWARE.
 
 namespace 
 {		
-  using Data = std::list<int>;
+  using DataE = std::array<int, 10U>;
+  using DataL = std::list<int>;
+  using DataF = std::forward_list<int>;
 
-  SUITE(test_cixed_iterator)
+  using ConstPointer        = const int*;
+  using ConstReversePointer = ETL_OR_STD::reverse_iterator<const int*>;
+
+  SUITE(test_circular_iterator)
   {
     //*************************************************************************
     TEST(test_default_constructor)
     {
-      etl::circular_iterator<const int*> ci;
+      etl::circular_iterator<ConstPointer> ci;
 
       CHECK_EQUAL(0U, size_t(std::distance(ci.begin(), ci.end())));
       CHECK_EQUAL(0U, ci.size());
     }
 
     //*************************************************************************
-    TEST(test_constructor_from_iterators)
+    TEST(test_construct_from_iterators_for_bidirectional_iterator)
     {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-      etl::circular_iterator<Data::const_iterator> ci(std::begin(data), std::end(data));
+      etl::circular_iterator<DataL::const_iterator> ci(std::begin(data), std::end(data));
 
       CHECK(data.begin() == ci.begin());
       CHECK(data.end()   == ci.end());
+      CHECK(data.begin() == ci.current());
       CHECK_EQUAL(data.size(), size_t(std::distance(ci.begin(), ci.end())));
       CHECK_EQUAL(data.size(), ci.size());
     }
 
     //*************************************************************************
-    TEST(test_constructor_from_reverse_iterators)
+    TEST(test_construct_from_start_plus_iterators_for_bidirectional_iterator)
     {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-      etl::circular_iterator<Data::const_reverse_iterator> ci(std::rbegin(data), std::rend(data));
+      DataL::const_iterator start = std::begin(data);
+      start++;
+
+      etl::circular_iterator<DataL::const_iterator> ci(std::begin(data), std::end(data), start);
+
+      CHECK(data.begin() == ci.begin());
+      CHECK(data.end()   == ci.end());
+      CHECK(start        == ci.current());
+      CHECK_EQUAL(data.size(), size_t(std::distance(ci.begin(), ci.end())));
+      CHECK_EQUAL(data.size(), ci.size());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_reverse_iterators)
+    {
+      const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      etl::circular_iterator<DataL::const_reverse_iterator> ci(std::rbegin(data), std::rend(data));
 
       CHECK(data.rbegin() == ci.begin());
       CHECK(data.rend()   == ci.end());
@@ -82,13 +107,30 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_constructor_from_span)
+    TEST(test_construct_from_start_plus_reverse_iterators)
+    {
+      const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      DataL::const_reverse_iterator start = std::rbegin(data);
+      start++;
+
+      etl::circular_iterator<DataL::const_reverse_iterator> ci(std::rbegin(data), std::rend(data), start);
+
+      CHECK(data.rbegin() == ci.begin());
+      CHECK(data.rend()   == ci.end());
+      CHECK(start         == ci.current());
+      CHECK_EQUAL(data.size(), size_t(std::distance(ci.begin(), ci.end())));
+      CHECK_EQUAL(data.size(), ci.size());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_span)
     {
       const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
       const etl::span<const int> sp(std::begin(data), std::end(data));
 
-      etl::circular_iterator<const int*> ci(sp);
+      etl::circular_iterator<ConstPointer> ci(sp);
 
       CHECK(std::begin(data) == ci.begin());
       CHECK(std::end(data)   == ci.end());
@@ -96,13 +138,31 @@ namespace
       CHECK_EQUAL(sp.size(), ci.size());
     }
 
+    //*************************************************************************
+    TEST(test_construct_from_start_plus_span)
+    {
+      const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      ConstPointer start = data + 1;
+
+      const etl::span<const int> sp(std::begin(data), std::end(data));
+
+      etl::circular_iterator<ConstPointer> ci(sp, start);
+
+      CHECK(std::begin(data) == ci.begin());
+      CHECK(std::end(data)   == ci.end());
+      CHECK(start            == ci.current());
+      CHECK_EQUAL(sp.size(), size_t(std::distance(ci.begin(), ci.end())));
+      CHECK_EQUAL(sp.size(), ci.size());
+    }
+
     //*************************************************************************
     TEST(test_copy_constructor)
     {
       int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-      const etl::circular_iterator<const int*> ci1(std::begin(data), std::end(data));
-      etl::circular_iterator<const int*> ci2(ci1);
+      const etl::circular_iterator<ConstPointer> ci1(std::begin(data), std::end(data));
+      etl::circular_iterator<ConstPointer> ci2(ci1);
 
       CHECK(ci1.begin() == ci2.begin());
       CHECK(ci1.end()   == ci2.end());
@@ -112,11 +172,11 @@ namespace
     //*************************************************************************
     TEST(test_assignment_from_circular_iterator)
     {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-      etl::circular_iterator<Data::const_iterator> ci1(std::begin(data), std::end(data));
-      etl::circular_iterator<Data::const_iterator>ci2;
-      ci2 = ci1;
+      etl::circular_iterator<DataL::const_iterator> ci1(std::begin(data), std::end(data));
+      etl::circular_iterator<DataL::const_iterator>ci2;
+      ci2.operator=(ci1);
 
       CHECK(ci1.begin() == ci2.begin());
       CHECK(ci1.end()   == ci2.end());
@@ -130,8 +190,8 @@ namespace
 
       etl::span<const int> sp(std::begin(data), std::end(data));
       
-      etl::circular_iterator<const int*> ci;
-      ci = sp;
+      etl::circular_iterator<ConstPointer> ci;
+      ci.operator=(sp);
 
       CHECK(std::begin(data) == ci.begin());
       CHECK(std::end(data)   == ci.end());
@@ -140,129 +200,343 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_pre_increment)
+    TEST(test_assign_start_for_random_access_iterator)
     {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-      etl::circular_iterator<Data::const_iterator> ci(std::begin(data), std::end(data));
+      ConstPointer start = std::begin(data);
+      start++;
 
-      for (int i = 1; i < 21; ++i)
-      {
-        Data::const_iterator itr = data.begin();
-        std::advance(itr, i % 10);
-        CHECK_EQUAL(*itr, *++ci);
-      }
+      etl::circular_iterator<ConstPointer> ci(std::begin(data), std::end(data));
+
+      ci = start;
+      CHECK(start == ci.current());
     }
 
     //*************************************************************************
-    TEST(test_post_increment)
+    TEST(test_assign_start_for_bidirectional_iterator)
     {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-      etl::circular_iterator<Data::const_iterator> ci(std::begin(data), std::end(data));
+      DataL::const_iterator start = std::begin(data);
+      start++;
+
+      etl::circular_iterator<DataL::const_iterator> ci(std::begin(data), std::end(data));
+
+      ci = start;
+      CHECK(start == ci.current());
+    }
+
+    //*************************************************************************
+    TEST(test_assign_start_for_forward_iterator)
+    {
+      const DataF data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      DataF::const_iterator start = std::begin(data);
+      start++;
+
+      etl::circular_iterator<DataF::const_iterator> ci(std::begin(data), std::end(data));
+
+      ci = start;
+      CHECK(start == ci.current());
+    }
+
+    //*************************************************************************
+    TEST(test_set_start_for_random_access_iterator)
+    {
+      const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      ConstPointer start = std::begin(data);
+      start++;
+
+      etl::circular_iterator<ConstPointer> ci(std::begin(data), std::end(data));
+
+      ci.set(start);
+      CHECK(start == ci.current());
+    }
+
+    //*************************************************************************
+    TEST(test_set_start_for_bidirectional_iterator)
+    {
+      const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      DataL::const_iterator start = std::begin(data);
+      start++;
+
+      etl::circular_iterator<DataL::const_iterator> ci(std::begin(data), std::end(data));
+
+      ci.set(start);
+      CHECK(start == ci.current());
+    }
+
+    //*************************************************************************
+    TEST(test_set_start_for_forward_iterator)
+    {
+      const DataF data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      DataF::const_iterator start = std::begin(data);
+      start++;
+
+      etl::circular_iterator<DataF::const_iterator> ci(std::begin(data), std::end(data));
+
+      ci.set(start);
+      CHECK(start == ci.current());
+    }
+
+    //*************************************************************************
+    TEST(test_pre_increment_for_random_access_iterator)
+    {
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
+
+      etl::circular_iterator<ConstPointer> ci(std::begin(data), std::end(data));
 
       for (int i = 0; i < 20; ++i)
       {
-        Data::const_iterator itr = data.begin();
-        std::advance(itr, i % 10);
-        CHECK_EQUAL(*itr, *ci++);
+        CHECK_EQUAL(expected[i % expected.size()], *++ci);
       }
     }
 
     //*************************************************************************
-    TEST(test_pre_increment_reverse_iterator)
+    TEST(test_pre_increment_for_bidirectional_iterator)
     {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataL data     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 
-      etl::circular_iterator<Data::const_reverse_iterator> ci(std::rbegin(data), std::rend(data));
-
-      for (int i = 1; i < 21; ++i)
-      {
-        Data::const_reverse_iterator itr = data.rbegin();
-        std::advance(itr, i % 10);
-        CHECK_EQUAL(*itr, *++ci);
-      }
-    }
-
-    //*************************************************************************
-    TEST(test_post_increment_reverse_iterator)
-    {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-
-      etl::circular_iterator<Data::const_reverse_iterator> ci(std::rbegin(data), std::rend(data));
+      etl::circular_iterator<DataL::const_iterator> ci(std::begin(data), std::end(data));
 
       for (int i = 0; i < 20; ++i)
       {
-        Data::const_reverse_iterator itr = data.rbegin();
-        std::advance(itr, i % 10);
-        CHECK_EQUAL(*itr, *ci++);
+        CHECK_EQUAL(expected[i % expected.size()], *++ci);
       }
     }
 
     //*************************************************************************
-    TEST(test_pre_decrement)
+    TEST(test_pre_increment_for_forward_iterator)
     {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataF data     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 
-      etl::circular_iterator<Data::const_iterator> ci(std::begin(data), std::end(data));
+      etl::circular_iterator<DataF::const_iterator> ci(std::begin(data), std::end(data));
 
       for (int i = 0; i < 20; ++i)
       {
-        Data::const_reverse_iterator itr = data.rbegin();
-        std::advance(itr, i % 10);
-        CHECK_EQUAL(*itr, *--ci);
+        CHECK_EQUAL(expected[i % expected.size()], *++ci);
       }
     }
 
     //*************************************************************************
-    TEST(test_pre_decrement_reverse_iterator)
+    TEST(test_post_increment_for_random_access_iterator)
     {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-      etl::circular_iterator<Data::const_reverse_iterator> ci(std::rbegin(data), std::rend(data));
+      etl::circular_iterator<ConstPointer> ci(std::begin(data), std::end(data));
 
       for (int i = 0; i < 20; ++i)
       {
-        Data::const_iterator itr = data.begin();
-        std::advance(itr, i % 10);
-        CHECK_EQUAL(*itr, *--ci);
+        CHECK_EQUAL(expected[i % expected.size()], *ci++);
       }
     }
 
     //*************************************************************************
-    TEST(test_post_decrement)
+    TEST(test_post_increment_for_bidirectional_iterator)
     {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataL data     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-      etl::circular_iterator<Data::const_iterator> ci(std::begin(data), std::end(data));
-      ci--;
+      etl::circular_iterator<DataL::const_iterator> ci(std::begin(data), std::end(data));
 
       for (int i = 0; i < 20; ++i)
       {
-        Data::const_reverse_iterator itr = data.rbegin();
-        std::advance(itr, i % 10);
-        CHECK_EQUAL(*itr, *ci--);
+        CHECK_EQUAL(expected[i % expected.size()], *ci++);
       }
     }
 
     //*************************************************************************
-    TEST(test_post_decrement_reverse_iterator)
+    TEST(test_post_increment_for_forward_iterator)
     {
-      const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataF data     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-      etl::circular_iterator<Data::const_reverse_iterator> ci(std::rbegin(data), std::rend(data));
-      ci--;
+      etl::circular_iterator<DataF::const_iterator> ci(std::begin(data), std::end(data));
 
       for (int i = 0; i < 20; ++i)
       {
-        Data::const_iterator itr = data.begin();
-        std::advance(itr, i % 10);
-        CHECK_EQUAL(*itr, *ci--);
+        CHECK_EQUAL(expected[i % expected.size()], *ci++);
       }
     }
 
     //*************************************************************************
-    TEST(test_member_dereference_operator)
+    TEST(test_pre_increment_reverse_iterator_for_random_access_iterator)
+    {
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 8, 7, 6, 5, 4, 3, 2, 1, 0, 9 };
+
+      etl::circular_iterator<ConstReversePointer> ci(std::rbegin(data), std::rend(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *++ci);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_pre_increment_reverse_iterator_for_bidirectional_iterator)
+    {
+      const DataL data     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 8, 7, 6, 5, 4, 3, 2, 1, 0, 9 };
+
+      etl::circular_iterator<DataL::const_reverse_iterator> ci(std::rbegin(data), std::rend(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *++ci);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_post_increment_reverse_iterator_for_random_access_iterator)
+    {
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+
+      etl::circular_iterator<ConstReversePointer> ci(std::rbegin(data), std::rend(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *ci++);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_post_increment_reverse_iterator_for_bidirectional_iterator)
+    {
+      const DataL data     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+
+      etl::circular_iterator<DataL::const_reverse_iterator> ci(std::rbegin(data), std::rend(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *ci++);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_pre_decrement_for_random_access_iterator)
+    {
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+
+      etl::circular_iterator<ConstPointer> ci(std::begin(data), std::end(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *--ci);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_pre_decrement_for_bidirectional_iterator)
+    {
+      const DataL data     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+
+      etl::circular_iterator<DataL::const_iterator> ci(std::begin(data), std::end(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *--ci);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_pre_decrement_reverse_iterator_for_random_access_iterator)
+    {
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      etl::circular_iterator<ConstReversePointer> ci(std::rbegin(data), std::rend(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *--ci);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_pre_decrement_reverse_iterator_for_bidirectional_iterator)
+    {
+      const DataL data     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      etl::circular_iterator<DataL::const_reverse_iterator> ci(std::rbegin(data), std::rend(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *--ci);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_post_decrement_for_random_access_iterator)
+    {
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 0, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+
+      etl::circular_iterator<ConstPointer> ci(std::begin(data), std::end(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *ci--);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_post_decrement_for_bidirectional_iterator)
+    {
+      const DataL data     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 0, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+
+      etl::circular_iterator<DataL::const_iterator> ci(std::begin(data), std::end(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *ci--);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_post_decrement_reverse_iterator_for_random_access_iterator)
+    {
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 9, 0, 1, 2, 3, 4, 5, 6, 7, 8 };
+
+      etl::circular_iterator<ConstReversePointer> ci(std::rbegin(data), std::rend(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *ci--);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_post_decrement_reverse_iterator_for_bidirectional_iterator)
+    {
+      const DataL data     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 9, 0, 1, 2, 3, 4, 5, 6, 7, 8 };
+
+      etl::circular_iterator<DataL::const_reverse_iterator> ci(std::rbegin(data), std::rend(data));
+
+      for (int i = 0; i < 20; ++i)
+      {
+        CHECK_EQUAL(expected[i % expected.size()], *ci--);
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_member_dereference_operator_for_random_access_iterator)
     {
       struct Test
       {
@@ -292,46 +566,141 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_conversion_operator)
+    TEST(test_member_dereference_operator_for_bidirectional_iterator)
     {
-      const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      struct Test
+      {
+        int data;
+        int b;
+      };
 
-      etl::circular_iterator<const int*> ci(std::begin(data), std::end(data));
+      std::list<Test> test = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
+      std::list<Test>::iterator itr = test.begin();
 
-      CHECK_EQUAL(data, ci);
+      etl::circular_iterator<std::list<Test>::iterator> ci(std::begin(test), std::end(test));
 
+      CHECK_EQUAL(itr->b, ci->b);
+
+      *ci = { 7, 8 };
+      CHECK_EQUAL(itr->b, ci->b);
+
+      ++itr;
       ++ci;
-      CHECK_EQUAL(data + 1, ci);
+      CHECK_EQUAL(itr->b, ci->b);
 
+      ++itr;
       ++ci;
-      CHECK_EQUAL(data + 2, ci);
+      CHECK_EQUAL(itr->b, ci->b);
     }
 
     //*************************************************************************
-    TEST(test_operator_plus_equals)
+    TEST(test_member_dereference_operator_for_forward_iterator)
+    {
+      struct Test
+      {
+        int data;
+        int b;
+      };
+
+      std::forward_list<Test> test = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
+      std::forward_list<Test>::iterator itr = test.begin();
+
+      etl::circular_iterator<std::forward_list<Test>::iterator> ci(std::begin(test), std::end(test));
+
+      CHECK_EQUAL(itr->b, ci->b);
+
+      *ci = { 7, 8 };
+      CHECK_EQUAL(itr->b, ci->b);
+
+      ++itr;
+      ++ci;
+      CHECK_EQUAL(itr->b, ci->b);
+
+      ++itr;
+      ++ci;
+      CHECK_EQUAL(itr->b, ci->b);
+    }
+
+    //*************************************************************************
+    TEST(test_conversion_operator_for_random_access_iterator)
     {
       const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
+      etl::circular_iterator<ConstPointer> ci(std::begin(data), std::end(data));
+
+      CHECK_EQUAL(data, ci.current());
+
+      ++ci;
+      CHECK_EQUAL(data + 1, ci.current());
+
+      ++ci;
+      CHECK_EQUAL(data + 2, ci.current());
+    }
+
+    //*************************************************************************
+    TEST(test_conversion_operator_for_bidirectional_iterator)
+    {
+      DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      etl::circular_iterator<DataL::const_iterator> ci(std::begin(data), std::end(data));
+      DataL::const_iterator itr = std::begin(data);
+
+      CHECK(itr == ci.current());
+
+      ++itr;
+      ++ci;
+      CHECK(itr == ci.current());
+
+      ++itr;
+      ++ci;
+      CHECK(itr == ci.current());
+    }
+
+    //*************************************************************************
+    TEST(test_conversion_operator_for_forward_iterator)
+    {
+      DataF data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+      etl::circular_iterator<DataF::const_iterator> ci(std::begin(data), std::end(data));
+      DataF::const_iterator itr = std::begin(data);
+
+      CHECK(itr == ci.current());
+
+      ++itr;
+      ++ci;
+      CHECK(itr == ci.current());
+
+      ++itr;
+      ++ci;
+      CHECK(itr == ci.current());
+    }
+
+    //*************************************************************************
+    TEST(test_operator_plus_equals_for_random_access_iterator)
+    {
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const DataE expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
       for (int step = 1; step < 20; ++step)
       {
-        etl::circular_iterator<const int*> ci(std::begin(data), std::end(data));
+        etl::circular_iterator<ConstPointer> ci(std::begin(data), std::end(data));
 
         for (int i = 0; i < 20; i += step)
         {
-          CHECK_EQUAL(data[i % 10], *ci);
+          CHECK_EQUAL(expected[i % 10], *ci);
           ci += step;
         }
       }
     }
 
     //*************************************************************************
-    TEST(test_operator_plus)
+    TEST(test_operator_plus_for_random_access_iterator)
     {
       const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
       for (int step = 1; step < 20; ++step)
       {
-        etl::circular_iterator<const int*> ci(std::begin(data), std::end(data));
+        etl::circular_iterator<ConstPointer> ci(std::begin(data), std::end(data));
 
         for (int i = 0; i < 20; i += step)
         {
@@ -342,237 +711,62 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_operator_minus_equals)
+    TEST(test_operator_minus_equals_random_access_iterator)
+    {
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const int expected[] = { 0, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+
+      etl::circular_iterator<ConstPointer> initial(std::begin(data), std::end(data));
+      etl::circular_iterator<ConstPointer> ci;
+      int step;
+
+      for (int step = 1; step < 20; ++step)
+      {
+        ci = initial;
+        
+        for (int i = 0; i < 20; i += step)
+        {
+          CHECK_EQUAL(expected[i % std::size(data)], *ci);
+          ci -= step;
+        }
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_operator_minus_random_access_iterator)
+    {
+      const int data[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+      const int expected[] = { 0, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+
+      for (int step = 1; step < 20; ++step)
+      {
+        etl::circular_iterator<ConstPointer> ci(std::begin(data), std::end(data));
+
+        for (int i = 0; i < 20; i += step)
+        {
+          CHECK_EQUAL(expected[i % std::size(data)], *ci);
+          ci = ci - step;
+        }
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_equality)
     {
       const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-      etl::circular_iterator<const int*> initial(std::begin(data), std::end(data));
-      etl::circular_iterator<const int*> ci;
-      int step;
+      etl::circular_iterator<ConstPointer> ci1(std::begin(data), std::end(data));
+      etl::circular_iterator<ConstPointer> ci2(std::begin(data), std::end(data));
+      etl::circular_iterator<ConstPointer> ci3(std::begin(data), std::end(data));
 
-      step = 1;
-      ci = initial;
+      ci1 += 5;
+      ci2 += 5;
+      ci3 += 4;
 
-      for (int i = 0; i < 20; i += step)
-      {
-        CHECK_EQUAL(data[(10 - i) % 10], *ci);
-        ci -= step;
-      }
-
-      //step = 2;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 3;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 4;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 5;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 6;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 7;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 8;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 9;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 10;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 11;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 12;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 13;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 14;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 15;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 16;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 17;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 18;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 19;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
-
-      //step = 20;
-      //ci = initial;
-
-      //for (int i = 0; i < 20; i += step)
-      //{
-      //  CHECK_EQUAL(data[abs(i - step) % 10], *ci);
-      //  ci -= step;
-      //}
+      CHECK(ci1 == ci2);
+      CHECK(ci2 == ci1);
+      CHECK(ci1 != ci3);
+      CHECK(ci3 != ci1);
     }
-
-    ////*************************************************************************
-    //TEST(test_operator_minus)
-    //{
-    //  int compare[] = { 1, 2, 3, 4 };
-
-    //  etl::circular_iterator<const int*> ci = &compare[1];
-
-    //  for (int i = 0; i < 10; ++i)
-    //  {
-    //    CHECK_EQUAL(compare[1], *ci);
-    //    ci = ci - 1;
-    //  }
-    //}
-
-    ////*************************************************************************
-    //TEST(test_assignment)
-    //{
-    //  int data;
-    //  int b;
-
-    //  etl::circular_iterator<int*> ci = &data;
-    //  ci = &b;
-
-    //  CHECK_EQUAL(&b, ci);
-
-    //  ci = &data;
-
-    //  CHECK_EQUAL(&data, ci);
-    //}
-
-    ////*************************************************************************
-    //TEST(test_equality)
-    //{
-    //  int data;
-    //  int b;
-
-    //  etl::circular_iterator<int*> ci1 = &data;
-    //  etl::circular_iterator<int*> ci2 = &data;
-    //  etl::circular_iterator<int*> ci3 = &b;
-
-    //  CHECK(ci1 == ci2);
-    //  CHECK(ci1 != ci3);
-    //}
   };
 }