Create a 'comma_iterator' class that overloads operator, and asserts when it's called. Add tests to mismatch to make sure it can't be blindsided by such an evil iterator. More tests for other algorithms forthcoming. Thanks to STL for pointing this out at CppCon and Yakov Galka for opening LWG issue #2133
llvm-svn: 217902
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
index 5bd6df7..5e86f34 100644
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -284,6 +284,108 @@
return x.base() - y.base();
}
+template <class It>
+class comma_iterator
+{
+ It it_;
+
+ template <class U> friend class comma_iterator;
+public:
+ typedef std::random_access_iterator_tag iterator_category;
+ typedef typename std::iterator_traits<It>::value_type value_type;
+ typedef typename std::iterator_traits<It>::difference_type difference_type;
+ typedef It pointer;
+ typedef typename std::iterator_traits<It>::reference reference;
+
+ It base() const {return it_;}
+
+ comma_iterator() : it_() {}
+ explicit comma_iterator(It it) : it_(it) {}
+ template <class U>
+ comma_iterator(const comma_iterator<U>& u) :it_(u.it_) {}
+
+ reference operator*() const {return *it_;}
+ pointer operator->() const {return it_;}
+
+ comma_iterator& operator++() {++it_; return *this;}
+ comma_iterator operator++(int)
+ {comma_iterator tmp(*this); ++(*this); return tmp;}
+
+ comma_iterator& operator--() {--it_; return *this;}
+ comma_iterator operator--(int)
+ {comma_iterator tmp(*this); --(*this); return tmp;}
+
+ comma_iterator& operator+=(difference_type n) {it_ += n; return *this;}
+ comma_iterator operator+(difference_type n) const
+ {comma_iterator tmp(*this); tmp += n; return tmp;}
+ friend comma_iterator operator+(difference_type n, comma_iterator x)
+ {x += n; return x;}
+ comma_iterator& operator-=(difference_type n) {return *this += -n;}
+ comma_iterator operator-(difference_type n) const
+ {comma_iterator tmp(*this); tmp -= n; return tmp;}
+
+ reference operator[](difference_type n) const {return it_[n];}
+ template <typename T>
+ void operator,(const T &) { assert(false); }
+};
+
+template <class T, class U>
+inline
+bool
+operator==(const comma_iterator<T>& x, const comma_iterator<U>& y)
+{
+ return x.base() == y.base();
+}
+
+template <class T, class U>
+inline
+bool
+operator!=(const comma_iterator<T>& x, const comma_iterator<U>& y)
+{
+ return !(x == y);
+}
+
+template <class T, class U>
+inline
+bool
+operator<(const comma_iterator<T>& x, const comma_iterator<U>& y)
+{
+ return x.base() < y.base();
+}
+
+template <class T, class U>
+inline
+bool
+operator<=(const comma_iterator<T>& x, const comma_iterator<U>& y)
+{
+ return !(y < x);
+}
+
+template <class T, class U>
+inline
+bool
+operator>(const comma_iterator<T>& x, const comma_iterator<U>& y)
+{
+ return y < x;
+}
+
+template <class T, class U>
+inline
+bool
+operator>=(const comma_iterator<T>& x, const comma_iterator<U>& y)
+{
+ return !(x < y);
+}
+
+template <class T, class U>
+inline
+typename std::iterator_traits<T>::difference_type
+operator-(const comma_iterator<T>& x, const comma_iterator<U>& y)
+{
+ return x.base() - y.base();
+}
+
+
template <class Iter>
inline Iter base(output_iterator<Iter> i) { return i.base(); }
@@ -299,6 +401,9 @@
template <class Iter>
inline Iter base(random_access_iterator<Iter> i) { return i.base(); }
+template <class Iter>
+inline Iter base(comma_iterator<Iter> i) { return i.base(); }
+
template <class Iter> // everything else
inline Iter base(Iter i) { return i; }