Ticket #6888: unique_fix.diff

boost/range/algorithm/unique.hpp

@@ -89 +89 @@
 unique( ForwardRange& rng, BinaryPredicate pred )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    return ::boost::range::unique<return_begin_found>(rng);
+    return ::boost::range::unique<return_begin_found>(rng, pred);
 }
 /// \overload
 template< class ForwardRange, class BinaryPredicate >
-inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type
 unique( const ForwardRange& rng, BinaryPredicate pred )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));

libs/range/test/test_driver/range_overload_test_driver.hpp

@@ +1 @@
+//  Copyright Neil Groves 2009. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#ifndef BOOST_RANGE_TEST_TEST_DRIVER_RANGE_OVERLOAD_TEST_DRIVER_HPP_INCLUDED
+#define BOOST_RANGE_TEST_TEST_DRIVER_RANGE_OVERLOAD_TEST_DRIVER_HPP_INCLUDED
+
+#include "range_return_test_driver.hpp"
+#include <boost/assert.hpp>
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+namespace boost
+{
+    namespace range_test
+    {
+        
+        // A test driver to exercise a test through range_return_test_driver
+        // plus the overload that determines the return_type by overload
+        //
+        // The test driver also contains the code required to check the
+        // return value correctness.
+        //
+        // The TestPolicy needs to implement all those required by 
+        // range_return_test_driver, and additionally
+        //
+        // - perform the boost range version of the algorithm that determines
+        //   the return_type by overload
+        class range_overload_test_driver : range_return_test_driver
+        {
+        public:
+            template< class Container,
+                      class TestPolicy >
+            void operator()(Container& cont, TestPolicy policy)
+            {
+                range_return_test_driver::operator()(cont, policy);
+                test_range_overload<Container, TestPolicy>()(cont, policy);
+            }
+
+        private:
+            template< class Container, class TestPolicy >
+            struct test_range_overload
+            {
+                void operator()(Container& cont, TestPolicy policy)
+                {
+                    typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iterator_t;
+                    typedef BOOST_DEDUCED_TYPENAME TestPolicy::template test_range_overload<Container> test_range_overload_t;
+                    const range_return_value result_type = test_range_overload_t::result_type; 
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container, result_type>::type range_return_t;
+
+                    Container reference(cont);
+                    Container test_cont(cont);
+
+                    test_range_overload_t test_range_overload_fn;
+                    range_return_t range_result = test_range_overload_fn(policy, test_cont);
+
+                    iterator_t reference_it = policy.reference(reference);
+
+                    check_results<result_type>::test(test_cont, reference,
+                                                     range_result, reference_it);
+                }
+            };
+        };
+    }
+}
+
+#endif // include guard

libs/range/test/algorithm_test/unique.cpp

@@ -9 +9 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 #include <boost/range/algorithm/unique.hpp>
+#include <boost/range/detail/range_return.hpp>
 
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <boost/assign.hpp>
 #include <boost/bind.hpp>
-#include "../test_driver/range_return_test_driver.hpp"
+#include <boost/config.hpp>
+#include "../test_driver/range_overload_test_driver.hpp"
 #include <algorithm>
 #include <functional>
 #include <list>
@@ -61 +63 @@
         };
 
         template< class Container >
+        struct test_range_overload
+        {
+            BOOST_STATIC_CONSTANT(::boost::range_return_value, result_type = ::boost::return_begin_found);
+
+            template< class Policy >
+            BOOST_DEDUCED_TYPENAME boost::range_return<Container,result_type>::type
+            operator()(Policy& policy, Container& cont)
+            {
+                typedef BOOST_DEDUCED_TYPENAME boost::range_return<Container,result_type>::type result_t;
+
+                Container cont2(cont);
+
+                result_t result = boost::unique(cont);
+
+                boost::unique(boost::make_iterator_range(cont2));
+
+                BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                               cont2.begin(), cont2.end() );
+
+                return result;
+            }
+        };
+
+        template< class Container >
         BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type
         reference(Container& cont)
         {
@@ -107 +133 @@
         };
 
         template< class Container >
+        struct test_range_overload
+        {
+            BOOST_STATIC_CONSTANT(::boost::range_return_value, result_type = ::boost::return_begin_found);
+
+            template< class Policy >
+            BOOST_DEDUCED_TYPENAME boost::range_return<Container,result_type>::type
+            operator()(Policy& policy, Container& cont)
+            {
+                typedef BOOST_DEDUCED_TYPENAME boost::range_return<Container,result_type>::type result_t;
+
+                Container cont2(cont);
+
+                result_t result = boost::unique(cont, policy.pred());
+
+                boost::unique(boost::make_iterator_range(cont2), policy.pred());
+
+                BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                               cont2.begin(), cont2.end() );
+
+                return result;
+            }
+        };
+
+        template< class Container >
         BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type
         reference(Container& cont)
         {
@@ -121 +171 @@
 
         typedef BOOST_DEDUCED_TYPENAME Container::value_type value_t;
 
-        boost::range_test::range_return_test_driver test_driver;
+        boost::range_test::range_overload_test_driver test_driver;
 
         Container cont;
 
@@ -146 +196 @@
         test_driver(cont, policy);
     }
 
+    template <class T>
+    struct greater_by_two
+    {
+        bool operator()(const T& left, const T& right) const
+        {
+            return left / 2 == right / 2;
+        }
+    };
+
     template<class Container>
     void test_unique_impl()
     {
@@ -155 +214 @@
             );
 
         test_unique_impl<Container>(
-            unique_pred_test_policy<std::less<int> >(),
+            unique_pred_test_policy<std::equal_to<int> >(),
             std::less<int>()
             );
-
         test_unique_impl<Container>(
-            unique_pred_test_policy<std::greater<int> >(),
+            unique_pred_test_policy<std::equal_to<int> >(),
             std::greater<int>()
             );
+
+        test_unique_impl<Container>(
+            unique_pred_test_policy<greater_by_two<int> >(),
+            std::less<int>()
+            );
     }
 
     void test_unique()