Merge bug fixes to master for 1.71

Merge pull request #49 from Ben10do/feature/forwarding-references
Use forwarding references in string/split.hpp
2019-07-10 15:14:08 -07:00 · 2019-07-03 07:54:40 -07:00 · 2019-07-03 07:44:25 -07:00 · 2019-04-29 11:58:43 -04:00 · 2019-04-23 13:48:19 +02:00 · 2018-08-02 22:18:54 +01:00
9 changed files with 114 additions and 61 deletions
--- a/include/boost/algorithm/find_backward.hpp
+++ b/include/boost/algorithm/find_backward.hpp
@ -2,7 +2,7 @@
   Copyright (c) T. Zachary Laine 2018.

   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALGORITHM_FIND_BACKWARD_HPP
 #define BOOST_ALGORITHM_FIND_BACKWARD_HPP
--- a/include/boost/algorithm/find_not.hpp
+++ b/include/boost/algorithm/find_not.hpp
@ -2,7 +2,7 @@
   Copyright (c) T. Zachary Laine 2018.

   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALGORITHM_FIND_NOT_HPP
 #define BOOST_ALGORITHM_FIND_NOT_HPP
--- a/include/boost/algorithm/string/iter_find.hpp
+++ b/include/boost/algorithm/string/iter_find.hpp
@ -71,7 +71,11 @@ namespace boost {
        inline SequenceSequenceT&
        iter_find(
            SequenceSequenceT& Result,
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            RangeT&& Input,
+#else
            RangeT& Input,
+#endif
            FinderT Finder )
        {
            BOOST_CONCEPT_ASSERT((
@ -142,7 +146,11 @@ namespace boost {
        inline SequenceSequenceT&
        iter_split(
            SequenceSequenceT& Result,
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            RangeT&& Input,
+#else
            RangeT& Input,
+#endif
            FinderT Finder )
        {
            BOOST_CONCEPT_ASSERT((
--- a/include/boost/algorithm/string/split.hpp
+++ b/include/boost/algorithm/string/split.hpp
@ -61,7 +61,11 @@ namespace boost {
        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
        inline SequenceSequenceT& find_all(
            SequenceSequenceT& Result,
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            Range1T&& Input,
+#else
            Range1T& Input,
+#endif
            const Range2T& Search)
        {
            return ::boost::algorithm::iter_find(
@ -96,7 +100,11 @@ namespace boost {
        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
        inline SequenceSequenceT& ifind_all(
            SequenceSequenceT& Result,
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            Range1T&& Input,
+#else
            Range1T& Input,
+#endif
            const Range2T& Search,
            const std::locale& Loc=std::locale() )
        {
@ -139,7 +147,11 @@ namespace boost {
        template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
        inline SequenceSequenceT& split(
            SequenceSequenceT& Result,
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            RangeT&& Input,
+#else
            RangeT& Input,
+#endif
            PredicateT Pred,
            token_compress_mode_type eCompress=token_compress_off )
        {
--- a/minmax/doc/minmax_synopsis.html
+++ b/minmax/doc/minmax_synopsis.html
@ -24,7 +24,7 @@ namespace boost {
  tuple&lt;T const&amp;, T const&amp;> >
  minmax(const T&amp; a, const T&amp; b);

-  template &lt;class T, class <a href="http://www.sgi.com/tech/stl/  BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class T, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  tuple&lt;T const&amp;, T const&amp;> >
  minmax(const T&amp; a, const T&amp; b, BinaryPredicate comp);

@ -38,77 +38,77 @@ Synopsis of <tt>&lt;boost/algorithm/minmax_element.hpp></tt></h3>

 namespace boost {

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  minmax_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  minmax_element(ForwardIterator first, ForwardIterator last,
                 BinaryPredicate comp);

  // Variants

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
  ForwardIterator first_min_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  ForwardIterator first_min_element(ForwardIterator first, ForwardIterator last,
                                    BinaryPredicate comp);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
  ForwardIterator last_min_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  ForwardIterator last_min_element(ForwardIterator first, ForwardIterator last,
                                   BinaryPredicate comp);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
  ForwardIterator first_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  ForwardIterator first_max_element(ForwardIterator first, ForwardIterator last,
                                    BinaryPredicate comp);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
  ForwardIterator last_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  ForwardIterator last_max_element(ForwardIterator first, ForwardIterator last,
                                   BinaryPredicate comp);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  first_min_first_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  first_min_first_max_element(ForwardIterator first, ForwardIterator last,
                             BinaryPredicate comp);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  first_min_last_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  first_min_last_max_element(ForwardIterator first, ForwardIterator last,
                             BinaryPredicate comp);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  last_min_first_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  last_min_first_max_element(ForwardIterator first, ForwardIterator last,
                             BinaryPredicate comp);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  last_min_last_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  last_min_last_max_element(ForwardIterator first, ForwardIterator last,
                            BinaryPredicate comp);
--- a/minmax/index.html
+++ b/minmax/index.html
@ -95,7 +95,7 @@ namespace boost {
  tuple&lt;T const&amp;, T const&amp;>
  minmax(const T&amp; a, const T&amp; b);

-  template &lt;class T, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class T, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  tuple&lt;T const&amp;, T const&amp;>
  minmax(const T&amp; a, const T&amp; b, BinaryPredicate comp);

@ -109,11 +109,11 @@ Synopsis of <tt>&lt;boost/algorithm/minmax_element.hpp></tt></h3>

 namespace boost {

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  minmax_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  minmax_element(ForwardIterator first, ForwardIterator last,
                 BinaryPredicate comp);
@ -190,26 +190,26 @@ in <a href="../../../boost/algorithm/minmax_element.hpp">minmax_element.hpp</a>.
 <a name="reqs">
 <h3>
 Requirements on types</h3>
-For minmax, <tt>T</tt> must be a model of <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
+For minmax, <tt>T</tt> must be a model of <a href="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThan
 Comparable</a>.
 <p>For all the other function templates, versions with two template parameters:
 <ul>
 <li>
-<tt>ForwardIterator</tt> is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+<tt>ForwardIterator</tt> is a model of <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">Forward
 Iterator</a>.</li>

 <li>
-<tt>ForwardIterator</tt>'s value type is <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
+<tt>ForwardIterator</tt>'s value type is <a href="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThan
 Comparable</a>.</li>
 </ul>
 For the versions with three template parameters:
 <ul>
 <li>
-<tt>ForwardIterator</tt> is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+<tt>ForwardIterator</tt> is a model of <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">Forward
 Iterator</a>.</li>

 <li>
-<tt>BinaryPredicate</tt> is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary
+<tt>BinaryPredicate</tt> is a model of <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">Binary
 Predicate</a>.</li>

 <li>
@ -285,8 +285,8 @@ the library under
  assert( result1.get<0>() == 0 );
  assert( result1.get<1>() == 1 );

-  <a href="http://www.sgi.com/tech/stl/List.html">list</a>&lt;int> L;
-  <a href="http://www.sgi.com/tech/stl/generate_n.html">generate_n</a>(<a href="http://www.sgi.com/tech/stl/front_insert_iterator.html">front_inserter</a>(L), 1000, rand);
+  <a href="https://www.boost.org/sgi/stl/List.html">list</a>&lt;int> L;
+  <a href="https://www.boost.org/sgi/stl/generate_n.html">generate_n</a>(<a href="https://www.boost.org/sgi/stl/front_insert_iterator.html">front_inserter</a>(L), 1000, rand);

  typedef list&lt;int>::const_iterator iterator;
  pair&lt; iterator, iterator > result2 = boost::minmax_element(L.begin(), L.end());
@ -512,13 +512,13 @@ release, Eric Niebler noted the bad behavior of <tt>std::pair</tt> for
 All my thanks for the excellent advice and reviews from all.
 <h3>
 See also</h3>
-<tt><a href="http://www.sgi.com/tech/stl/min.html">min</a></tt>, <tt><a href="http://www.sgi.com/tech/stl/max.html">max</a></tt>,
-<tt><a href="http://www.sgi.com/tech/stl/min_element.html">min_element</a></tt>,
-<tt><a href="http://www.sgi.com/tech/stl/max_element.html">max_element</a></tt>,
-<tt><a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
+<tt><a href="https://www.boost.org/sgi/stl/min.html">min</a></tt>, <tt><a href="https://www.boost.org/sgi/stl/max.html">max</a></tt>,
+<tt><a href="https://www.boost.org/sgi/stl/min_element.html">min_element</a></tt>,
+<tt><a href="https://www.boost.org/sgi/stl/max_element.html">max_element</a></tt>,
+<tt><a href="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThan
 Comparable</a></tt>,
-<tt><a href="http://www.sgi.com/tech/stl/sort.html">sort</a></tt>,
-<tt><a href="http://www.sgi.com/tech/stl/nth_element.html">nth_element</a></tt>
+<tt><a href="https://www.boost.org/sgi/stl/sort.html">sort</a></tt>,
+<tt><a href="https://www.boost.org/sgi/stl/nth_element.html">nth_element</a></tt>
 .
 <hr SIZE="6">
 <br>Last modified 2012-12-10
--- a/string/doc/external_concepts.html
+++ b/string/doc/external_concepts.html
@ -31,7 +31,7 @@
               typedef <i>implementation defined </i> foo_type;</code><p  >The corresponding external concept is the ExternalFooConcept.</p><p  >A type <code>T</code> fullfills the ExternalFooConcept if these
            free-standing functions and type-generators exists:</p><code>void foo( const T&, int ); <br>
                int bar( T& ); <br>
-             foo_type_of< T >::type;</code> <br> <br><hr size="1" ><h3  >Literature</h3><ul  ><li  > <a href="http://www.boost.org/more/generic_programming.html#type_generator" target="_self" >Type Generators</a> </li><li  > <a href="http://www.boost.org/more/generic_programming.html#concept" target="_self" >Concepts</a> </li><li  > <a href="http://www.sgi.com/tech/stl/stl_introduction.html" target="_self" >Concepts and SGI STL</a> </li></ul><hr size="1" ><p  >&copy; Thorsten Ottosen 2003-2004 (nesotto_AT_cs.auc.dk).
+             foo_type_of< T >::type;</code> <br> <br><hr size="1" ><h3  >Literature</h3><ul  ><li  > <a href="http://www.boost.org/more/generic_programming.html#type_generator" target="_self" >Type Generators</a> </li><li  > <a href="http://www.boost.org/more/generic_programming.html#concept" target="_self" >Concepts</a> </li><li  > <a href="https://www.boost.org/sgi/stl/stl_introduction.html" target="_self" >Concepts and SGI STL</a> </li></ul><hr size="1" ><p  >&copy; Thorsten Ottosen 2003-2004 (nesotto_AT_cs.auc.dk).
 <br>Use, modification and distribution is subject to the Boost
 Software License, Version 1.0. (See accompanying file
 <code class="filename">LICENSE_1_0.txt</code> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
--- a/string/test/split_test.cpp
+++ b/string/test/split_test.cpp
@ -7,6 +7,8 @@

 //  See http://www.boost.org for updates, documentation, and revision history.

+#include <boost/algorithm/string/config.hpp>
+
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
 // equals predicate is used for result comparison
@ -82,6 +84,28 @@ void iterator_test()
        string("xx") );
    deep_compare( tokens, vtokens );

+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    // If using a compiler that supports forwarding references, we should be able to use rvalues, too
+    find_all(
+        tokens,
+        string("xx-abc--xx-abb"),
+        "xx" );
+
+    BOOST_REQUIRE( tokens.size()==2 );
+    BOOST_CHECK( tokens[0]==string("xx") );
+    BOOST_CHECK( tokens[1]==string("xx") );
+
+    ifind_all(
+        tokens,
+        string("Xx-abc--xX-abb-xx"),
+        "xx" );
+
+    BOOST_REQUIRE( tokens.size()==3 );
+    BOOST_CHECK( tokens[0]==string("Xx") );
+    BOOST_CHECK( tokens[1]==string("xX") );
+    BOOST_CHECK( tokens[2]==string("xx") );
+#endif
+
    // split tests
    split(
        tokens,
@ -144,6 +168,21 @@ void iterator_test()
    BOOST_REQUIRE( tokens.size()==1 );
    BOOST_CHECK( tokens[0]==string("") );

+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    // If using a compiler that supports forwarding references, we should be able to use rvalues, too
+    split(
+        tokens,
+        string("Xx-abc--xX-abb-xx"),
+        is_any_of("xX"),
+        token_compress_on );
+
+    BOOST_REQUIRE( tokens.size()==4 );
+    BOOST_CHECK( tokens[0]==string("") );
+    BOOST_CHECK( tokens[1]==string("-abc--") );
+    BOOST_CHECK( tokens[2]==string("-abb-") );
+    BOOST_CHECK( tokens[3]==string("") );
+#endif
+

    find_iterator<string::iterator> fiter=make_find_iterator(str1, first_finder("xx"));
    find_iterator<string::iterator> fiter2;
--- a/test/apply_permutation_test.cpp
+++ b/test/apply_permutation_test.cpp
@ -14,19 +14,19 @@

 #define BOOST_TEST_MAIN

-#include <boost/test/unit_test.hpp>
+#include <boost/test/included/unit_test.hpp>

 namespace ba = boost::algorithm;


-void test_apply_permutation()
+BOOST_AUTO_TEST_CASE(test_apply_permutation)
 {
    //Empty
    {
        std::vector<int> vec, order, result;
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //1 element
    {
@ -36,7 +36,7 @@ void test_apply_permutation()
        result = vec;
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //2 elements, no changes
    {
@ -46,7 +46,7 @@ void test_apply_permutation()
        result = vec;
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //2 elements, changed
    {
@ -56,7 +56,7 @@ void test_apply_permutation()
        result.push_back(2); result.push_back(1);
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //Multiple elements, no changes
    {
@ -66,7 +66,7 @@ void test_apply_permutation()
        result = vec;
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //Multiple elements, changed
    {
@ -76,7 +76,7 @@ void test_apply_permutation()
        result.push_back(5); result.push_back(4); result.push_back(3); result.push_back(2); result.push_back(1);
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //Just test range interface
    {
@ -86,18 +86,18 @@ void test_apply_permutation()
        result = vec;
        
        ba::apply_permutation(vec, order);
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
 }

-void test_apply_reverse_permutation()
+BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
 {
    //Empty
    {
        std::vector<int> vec, order, result;
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //1 element
    {
@ -107,7 +107,7 @@ void test_apply_reverse_permutation()
        result = vec;
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //2 elements, no changes
    {
@ -117,7 +117,7 @@ void test_apply_reverse_permutation()
        result = vec;
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //2 elements, changed
    {
@ -127,7 +127,7 @@ void test_apply_reverse_permutation()
        result.push_back(2); result.push_back(1);
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //Multiple elements, no changes
    {
@ -137,7 +137,7 @@ void test_apply_reverse_permutation()
        result = vec;
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //Multiple elements, changed
    {
@ -147,7 +147,7 @@ void test_apply_reverse_permutation()
        result.push_back(5); result.push_back(4); result.push_back(3); result.push_back(2); result.push_back(1);
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
    //Just test range interface
    {
@ -157,12 +157,6 @@ void test_apply_reverse_permutation()
        result = vec;
        
        ba::apply_reverse_permutation(vec, order);
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
    }
 }
-
-BOOST_AUTO_TEST_CASE(test_main)
-{
-    test_apply_permutation();
-    test_apply_reverse_permutation();
-}
Author	SHA1	Message	Date
Marshall Clow	1b65b8de02	Merge bug fixes to master for 1.71	2019-07-10 15:14:08 -07:00
Marshall Clow	77bbc6ce43	Merge pull request #49 from Ben10do/feature/forwarding-references Use forwarding references in string/split.hpp	2019-07-03 07:54:40 -07:00
Marshall Clow	0a57ec30a2	Update the apply_permutation tests to use the BOOST_CHECK_EQUAL_COLLECTIONS facilities. Based on https://github.com/boostorg/algorithm/pull/42 Thanks to Jeremy for the patch	2019-07-03 07:44:25 -07:00
Marshall Clow	9477cd8be0	Merge pull request #59 from tinko92/develop Replace broken links (mostly in minmax) documentation	2019-04-29 11:58:43 -04:00
Tinko Bartels	f39107f228	Replace broken links.	2019-04-23 13:48:19 +02:00
Ben10do	45baad2431	Correct lvalue/rvalue nomenclature I accidentally referred to the additional tests as using lvalues as inputs, when they’re actually using rvalues. This commit corrects the relevant comments.	2018-08-02 22:18:54 +01:00
Ben10do	5408a17020	Add tests with lvalue inputs If the compiler supports forwarding references, we now test if lvalues can be used as input strings for split(), find_all(), and ifind_all(). Note that MSVC (without its recent /permissive- flag) may pass these tests without the forwarding references changes that I made, due to its non-standard binding of lvalues to rvalues.	2018-08-01 22:42:18 +01:00
Ben10do	c6f784cb70	Use forwarding references in string/split.hpp On compilers that support C++11, this allows both lvalues and rvalues to be used as inputs to the split(), find_all(), and ifind_all() functions. For example, given a function get_string() that returns a std::string, this allows you to write: boost::split(result, get_string(), boost::is_any_of(" "))	2018-08-01 20:54:17 +01:00