Subject: [Boost-commit] svn:boost r78687 - in trunk: boost/algorithm boost/algorithm/cxx11 boost/algorithm/searching libs/algorithm/test libs/config/test
From: marshall_at_[hidden]
Date: 2012-05-27 11:24:11
Author: marshall
Date: 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
New Revision: 78687
URL: http://svn.boost.org/trac/boost/changeset/78687
Log:
Cleaned up things that the inspect tool found in Boost.Algorithm. No functionality change
Text files modified:
trunk/boost/algorithm/cxx11/all_of.hpp | 2
trunk/boost/algorithm/cxx11/any_of.hpp | 2
trunk/boost/algorithm/cxx11/copy_if.hpp | 2
trunk/boost/algorithm/cxx11/iota.hpp | 2
trunk/boost/algorithm/cxx11/is_partitioned.hpp | 12 ++--
trunk/boost/algorithm/cxx11/is_permutation.hpp | 2
trunk/boost/algorithm/cxx11/is_sorted.hpp | 6 +-
trunk/boost/algorithm/cxx11/none_of.hpp | 2
trunk/boost/algorithm/cxx11/partition_copy.hpp | 2
trunk/boost/algorithm/cxx11/partition_point.hpp | 6 +-
trunk/boost/algorithm/hex.hpp | 2
trunk/boost/algorithm/searching/knuth_morris_pratt.hpp | 2
trunk/libs/algorithm/test/copy_n_test1.cpp | 102 ++++++++++++++++++++--------------------
trunk/libs/algorithm/test/find_if_not_test1.cpp | 26 +++++-----
trunk/libs/algorithm/test/hex_fail1.cpp | 2
trunk/libs/algorithm/test/hex_test3.cpp | 16 +++---
trunk/libs/algorithm/test/iota_test1.cpp | 82 ++++++++++++++++----------------
trunk/libs/algorithm/test/is_partitioned_test1.cpp | 18 +++---
trunk/libs/algorithm/test/ordered_test.cpp | 26 +++++-----
trunk/libs/algorithm/test/partition_point_test1.cpp | 26 +++++-----
trunk/libs/config/test/boost_no_cxx_hdr_functional.ipp | 19 +++++++
21 files changed, 189 insertions(+), 170 deletions(-)
Modified: trunk/boost/algorithm/cxx11/all_of.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/all_of.hpp (original)
+++ trunk/boost/algorithm/cxx11/all_of.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_ALL_OF_HPP
#define BOOST_ALGORITHM_ALL_OF_HPP
-#include <algorithm> // for std::all_of, if available
+#include <algorithm> // for std::all_of, if available
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
Modified: trunk/boost/algorithm/cxx11/any_of.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/any_of.hpp (original)
+++ trunk/boost/algorithm/cxx11/any_of.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -14,7 +14,7 @@
#ifndef BOOST_ALGORITHM_ANY_OF_HPP
#define BOOST_ALGORITHM_ANY_OF_HPP
-#include <algorithm> // for std::any_of, if available
+#include <algorithm> // for std::any_of, if available
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
Modified: trunk/boost/algorithm/cxx11/copy_if.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/copy_if.hpp (original)
+++ trunk/boost/algorithm/cxx11/copy_if.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_COPY_IF_HPP
#define BOOST_ALGORITHM_COPY_IF_HPP
-#include <algorithm> // for std::copy_if, if available
+#include <algorithm> // for std::copy_if, if available
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
Modified: trunk/boost/algorithm/cxx11/iota.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/iota.hpp (original)
+++ trunk/boost/algorithm/cxx11/iota.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -71,4 +71,4 @@
}}
-#endif // BOOST_ALGORITHM_IOTA_HPP
\ No newline at end of file
+#endif // BOOST_ALGORITHM_IOTA_HPP
Modified: trunk/boost/algorithm/cxx11/is_partitioned.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/is_partitioned.hpp (original)
+++ trunk/boost/algorithm/cxx11/is_partitioned.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP
#define BOOST_ALGORITHM_IS_PARTITIONED_HPP
-#include <algorithm> // for std::is_partitioned, if available
+#include <algorithm> // for std::is_partitioned, if available
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
@@ -35,14 +35,14 @@
template <typename InputIterator, typename UnaryPredicate>
bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
{
-// Run through the part that satisfy the predicate
+// Run through the part that satisfy the predicate
for ( ; first != last; ++first )
if ( !p (*first))
- break;
-// Now the part that does not satisfy the predicate
+ break;
+// Now the part that does not satisfy the predicate
for ( ; first != last; ++first )
if ( p (*first))
- return false;
+ return false;
return true;
}
#endif
@@ -62,4 +62,4 @@
}}
-#endif // BOOST_ALGORITHM_IS_PARTITIONED_HPP
\ No newline at end of file
+#endif // BOOST_ALGORITHM_IS_PARTITIONED_HPP
Modified: trunk/boost/algorithm/cxx11/is_permutation.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/is_permutation.hpp (original)
+++ trunk/boost/algorithm/cxx11/is_permutation.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -136,4 +136,4 @@
}}
-#endif // BOOST_ALGORITHM_IS_PERMUTATION_HPP
\ No newline at end of file
+#endif // BOOST_ALGORITHM_IS_PERMUTATION_HPP
Modified: trunk/boost/algorithm/cxx11/is_sorted.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/is_sorted.hpp (original)
+++ trunk/boost/algorithm/cxx11/is_sorted.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -94,7 +94,7 @@
#endif
///
-/// -- Range based versions of the C++11 functions
+/// -- Range based versions of the C++11 functions
///
/// \fn is_sorted_until ( const R &range, Pred p )
@@ -126,7 +126,7 @@
}
namespace detail {
- typedef struct { typedef bool type; } bool_;
+ typedef struct { typedef bool type; } bool_;
};
/// \fn is_sorted ( const R &range, Pred p )
@@ -157,7 +157,7 @@
///
-/// -- Range based versions of the C++11 functions
+/// -- Range based versions of the C++11 functions
///
/// \fn is_increasing ( ForwardIterator first, ForwardIterator last )
Modified: trunk/boost/algorithm/cxx11/none_of.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/none_of.hpp (original)
+++ trunk/boost/algorithm/cxx11/none_of.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_NONE_OF_HPP
#define BOOST_ALGORITHM_NONE_OF_HPP
-#include <algorithm> // for std::none_of, if available
+#include <algorithm> // for std::none_of, if available
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
Modified: trunk/boost/algorithm/cxx11/partition_copy.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/partition_copy.hpp (original)
+++ trunk/boost/algorithm/cxx11/partition_copy.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_PARTITION_COPY_HPP
#define BOOST_ALGORITHM_PARTITION_COPY_HPP
-#include <algorithm> // for std::partition_copy, if available
+#include <algorithm> // for std::partition_copy, if available
#include <utility> // for make_pair
#include <boost/range/begin.hpp>
Modified: trunk/boost/algorithm/cxx11/partition_point.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/partition_point.hpp (original)
+++ trunk/boost/algorithm/cxx11/partition_point.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_PARTITION_POINT_HPP
#define BOOST_ALGORITHM_PARTITION_POINT_HPP
-#include <algorithm> // for std::partition_point, if available
+#include <algorithm> // for std::partition_point, if available
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
@@ -25,7 +25,7 @@
#else
/// \fn partition_point ( ForwardIterator first, ForwardIterator last, Predicate p )
/// \brief Given a partitioned range, returns the partition point, i.e, the first element
-/// that does not satisfy p
+/// that does not satisfy p
///
/// \param first The start of the input sequence
/// \param last One past the end of the input sequence
@@ -69,4 +69,4 @@
}}
-#endif // BOOST_ALGORITHM_PARTITION_POINT_HPP
\ No newline at end of file
+#endif // BOOST_ALGORITHM_PARTITION_POINT_HPP
Modified: trunk/boost/algorithm/hex.hpp
==============================================================================
--- trunk/boost/algorithm/hex.hpp (original)
+++ trunk/boost/algorithm/hex.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -45,7 +45,7 @@
\struct non_hex_input
\brief Thrown when a non-hex value (0-9, A-F) encountered when decoding.
- Contains the offending character
+ Contains the offending character
\struct not_enough_input
\brief Thrown when the input sequence unexpectedly ends
Modified: trunk/boost/algorithm/searching/knuth_morris_pratt.hpp
==============================================================================
--- trunk/boost/algorithm/searching/knuth_morris_pratt.hpp (original)
+++ trunk/boost/algorithm/searching/knuth_morris_pratt.hpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -32,7 +32,7 @@
* Random-access iterators
* The two iterator types (I1 and I2) must "point to" the same underlying type.
- http://en.wikipedia.org/wiki/Knuth%e2%80%93Morris%e2%80%93Pratt_algorithm
+ http://en.wikipedia.org/wiki/Knuth-Morris-Pratt_algorithm
http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm
*/
Modified: trunk/libs/algorithm/test/copy_n_test1.cpp
==============================================================================
--- trunk/libs/algorithm/test/copy_n_test1.cpp (original)
+++ trunk/libs/algorithm/test/copy_n_test1.cpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -22,60 +22,60 @@
template <typename Container>
void test_sequence ( Container const &c ) {
- typedef typename Container::value_type value_type;
- std::vector<value_type> v;
-
-// Copy zero elements
- v.clear ();
- ba::copy_n ( c.begin (), 0, back_inserter ( v ));
- BOOST_CHECK ( v.size () == 0 );
- ba::copy_n ( c.begin (), 0U, back_inserter ( v ));
- BOOST_CHECK ( v.size () == 0 );
-
- if ( c.size () > 0 ) {
- // Just one element
- v.clear ();
- ba::copy_n ( c.begin (), 1, back_inserter ( v ));
- BOOST_CHECK ( v.size () == 1 );
- BOOST_CHECK ( v[0] == *c.begin ());
-
- v.clear ();
- ba::copy_n ( c.begin (), 1U, back_inserter ( v ));
- BOOST_CHECK ( v.size () == 1 );
- BOOST_CHECK ( v[0] == *c.begin ());
-
- // Half the elements
- v.clear ();
- ba::copy_n ( c.begin (), c.size () / 2, back_inserter ( v ));
- BOOST_CHECK ( v.size () == c.size () / 2);
- BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
-
- // Half the elements + 1
- v.clear ();
- ba::copy_n ( c.begin (), c.size () / 2 + 1, back_inserter ( v ));
- BOOST_CHECK ( v.size () == c.size () / 2 + 1 );
- BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
-
- // All the elements
- v.clear ();
- ba::copy_n ( c.begin (), c.size (), back_inserter ( v ));
- BOOST_CHECK ( v.size () == c.size ());
- BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
- }
- }
+ typedef typename Container::value_type value_type;
+ std::vector<value_type> v;
+
+// Copy zero elements
+ v.clear ();
+ ba::copy_n ( c.begin (), 0, back_inserter ( v ));
+ BOOST_CHECK ( v.size () == 0 );
+ ba::copy_n ( c.begin (), 0U, back_inserter ( v ));
+ BOOST_CHECK ( v.size () == 0 );
+
+ if ( c.size () > 0 ) {
+ // Just one element
+ v.clear ();
+ ba::copy_n ( c.begin (), 1, back_inserter ( v ));
+ BOOST_CHECK ( v.size () == 1 );
+ BOOST_CHECK ( v[0] == *c.begin ());
+
+ v.clear ();
+ ba::copy_n ( c.begin (), 1U, back_inserter ( v ));
+ BOOST_CHECK ( v.size () == 1 );
+ BOOST_CHECK ( v[0] == *c.begin ());
+
+ // Half the elements
+ v.clear ();
+ ba::copy_n ( c.begin (), c.size () / 2, back_inserter ( v ));
+ BOOST_CHECK ( v.size () == c.size () / 2);
+ BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+ // Half the elements + 1
+ v.clear ();
+ ba::copy_n ( c.begin (), c.size () / 2 + 1, back_inserter ( v ));
+ BOOST_CHECK ( v.size () == c.size () / 2 + 1 );
+ BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+ // All the elements
+ v.clear ();
+ ba::copy_n ( c.begin (), c.size (), back_inserter ( v ));
+ BOOST_CHECK ( v.size () == c.size ());
+ BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+ }
+ }
void test_sequence1 () {
- std::vector<int> v;
- for ( int i = 5; i < 15; ++i )
- v.push_back ( i );
- test_sequence ( v );
-
- std::list<int> l;
- for ( int i = 25; i > 15; --i )
- l.push_back ( i );
- test_sequence ( l );
- }
+ std::vector<int> v;
+ for ( int i = 5; i < 15; ++i )
+ v.push_back ( i );
+ test_sequence ( v );
+
+ std::list<int> l;
+ for ( int i = 25; i > 15; --i )
+ l.push_back ( i );
+ test_sequence ( l );
+ }
int test_main( int , char* [] )
Modified: trunk/libs/algorithm/test/find_if_not_test1.cpp
==============================================================================
--- trunk/libs/algorithm/test/find_if_not_test1.cpp (original)
+++ trunk/libs/algorithm/test/find_if_not_test1.cpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -22,18 +22,18 @@
template <typename Container>
typename Container::iterator offset_to_iter ( Container &v, int offset ) {
- typename Container::iterator retval;
-
- if ( offset >= 0 ) {
- retval = v.begin ();
- std::advance ( retval, offset );
- }
- else {
- retval = v.end ();
- std::advance ( retval, offset + 1 );
- }
- return retval;
- }
+ typename Container::iterator retval;
+
+ if ( offset >= 0 ) {
+ retval = v.begin ();
+ std::advance ( retval, offset );
+ }
+ else {
+ retval = v.end ();
+ std::advance ( retval, offset + 1 );
+ }
+ return retval;
+ }
template <typename Container, typename Predicate>
void test_sequence ( Container &v, Predicate comp, int expected ) {
@@ -71,7 +71,7 @@
test_sequence ( v, less_than<int>(10), 5 );
test_sequence ( v, less_than<int>(99), -1 ); // all elements satisfy
-// With bidirectional iterators.
+// With bidirectional iterators.
std::list<int> l;
for ( int i = 5; i < 15; ++i )
l.push_back ( i );
Modified: trunk/libs/algorithm/test/hex_fail1.cpp
==============================================================================
--- trunk/libs/algorithm/test/hex_fail1.cpp (original)
+++ trunk/libs/algorithm/test/hex_fail1.cpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -15,7 +15,7 @@
#include <iostream>
#include <vector>
-// should not compile: vector is not an integral type
+// should not compile: vector is not an integral type
int test_main( int , char* [] )
{
std::vector<float> v;
Modified: trunk/libs/algorithm/test/hex_test3.cpp
==============================================================================
--- trunk/libs/algorithm/test/hex_test3.cpp (original)
+++ trunk/libs/algorithm/test/hex_test3.cpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -21,12 +21,12 @@
template <typename char_type>
void test_to_hex ( const char_type ** tests ) {
- typedef std::basic_string<char_type> String;
- typedef std::basic_ostringstream<char_type> Stream;
- typedef std::ostream_iterator<char_type, char_type> Iter;
+ typedef std::basic_string<char_type> String;
+ typedef std::basic_ostringstream<char_type> Stream;
+ typedef std::ostream_iterator<char_type, char_type> Iter;
for ( const char_type **p = tests; *p; p++ ) {
- String arg, argh;
+ String arg, argh;
Stream one, two, three;
arg.assign ( *p );
boost::algorithm::hex ( *p, Iter ( one ));
@@ -49,12 +49,12 @@
template <typename char_type>
void test_from_hex_success ( const char_type ** tests ) {
- typedef std::basic_string<char_type> String;
- typedef std::basic_ostringstream<char_type> Stream;
- typedef std::ostream_iterator<char_type, char_type> Iter;
+ typedef std::basic_string<char_type> String;
+ typedef std::basic_ostringstream<char_type> Stream;
+ typedef std::ostream_iterator<char_type, char_type> Iter;
for ( const char_type **p = tests; *p; p++ ) {
- String arg, argh;
+ String arg, argh;
Stream one, two, three;
arg.assign ( *p );
boost::algorithm::unhex ( *p, Iter ( one ));
Modified: trunk/libs/algorithm/test/iota_test1.cpp
==============================================================================
--- trunk/libs/algorithm/test/iota_test1.cpp (original)
+++ trunk/libs/algorithm/test/iota_test1.cpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -16,60 +16,60 @@
#include <vector>
#include <list>
-// Test to make sure a sequence is "correctly formed"; i.e, ascending by one
+// Test to make sure a sequence is "correctly formed"; i.e, ascending by one
template <typename Iterator, typename T>
bool test_iota_results ( Iterator first, Iterator last, T initial_value ) {
- if ( first == last ) return true;
- if ( initial_value != *first ) return false;
- Iterator prev = first;
- while ( ++first != last ) {
- if (( *first - *prev ) != 1 )
- return false;
- prev = first;
- }
- return true;
- }
+ if ( first == last ) return true;
+ if ( initial_value != *first ) return false;
+ Iterator prev = first;
+ while ( ++first != last ) {
+ if (( *first - *prev ) != 1 )
+ return false;
+ prev = first;
+ }
+ return true;
+ }
template <typename Range, typename T>
bool test_iota_results ( const Range &r, T initial_value ) {
- return test_iota_results (boost::begin (r), boost::end (r), initial_value );
+ return test_iota_results (boost::begin (r), boost::end (r), initial_value );
}
void test_ints () {
- std::vector<int> v;
- std::list<int> l;
+ std::vector<int> v;
+ std::list<int> l;
- v.clear (); v.reserve ( 10 );
- boost::algorithm::iota ( v.begin (), v.end (), 23 );
- BOOST_CHECK ( test_iota_results ( v.begin (), v.end (), 23 ));
-
- v.clear (); v.reserve ( 19 );
- boost::algorithm::iota ( v, 18 );
- BOOST_CHECK ( test_iota_results ( v, 18 ));
-
- v.clear ();
- boost::algorithm::iota_n ( std::back_inserter(v), 99, 20 );
- BOOST_CHECK ( test_iota_results ( v, 99 ));
-
+ v.clear (); v.reserve ( 10 );
+ boost::algorithm::iota ( v.begin (), v.end (), 23 );
+ BOOST_CHECK ( test_iota_results ( v.begin (), v.end (), 23 ));
+
+ v.clear (); v.reserve ( 19 );
+ boost::algorithm::iota ( v, 18 );
+ BOOST_CHECK ( test_iota_results ( v, 18 ));
+
+ v.clear ();
+ boost::algorithm::iota_n ( std::back_inserter(v), 99, 20 );
+ BOOST_CHECK ( test_iota_results ( v, 99 ));
+
/*
- l.clear (); l.reserve ( 5 );
- boost::algorithm::iota ( l.begin (), l.end (), 123 );
- BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 123 ));
-
- l.clear (); l.reserve ( 9 );
- boost::algorithm::iota ( l.begin (), l.end (), 87 );
- BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 87 ));
+ l.clear (); l.reserve ( 5 );
+ boost::algorithm::iota ( l.begin (), l.end (), 123 );
+ BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 123 ));
+
+ l.clear (); l.reserve ( 9 );
+ boost::algorithm::iota ( l.begin (), l.end (), 87 );
+ BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 87 ));
*/
- l.clear ();
- boost::algorithm::iota_n ( std::back_inserter(l), 99, 20 );
- BOOST_CHECK ( test_iota_results ( l, 99 ));
-
- l.clear ();
- boost::algorithm::iota_n ( std::front_inserter(l), 123, 20 );
- BOOST_CHECK ( test_iota_results ( l.rbegin (), l.rend (), 123 ));
- }
+ l.clear ();
+ boost::algorithm::iota_n ( std::back_inserter(l), 99, 20 );
+ BOOST_CHECK ( test_iota_results ( l, 99 ));
+
+ l.clear ();
+ boost::algorithm::iota_n ( std::front_inserter(l), 123, 20 );
+ BOOST_CHECK ( test_iota_results ( l.rbegin (), l.rend (), 123 ));
+ }
int test_main( int , char* [] )
Modified: trunk/libs/algorithm/test/is_partitioned_test1.cpp
==============================================================================
--- trunk/libs/algorithm/test/is_partitioned_test1.cpp (original)
+++ trunk/libs/algorithm/test/is_partitioned_test1.cpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -40,19 +40,19 @@
v.clear ();
for ( int i = 5; i < 15; ++i )
v.push_back ( i );
- BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(3))); // no elements
- BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(6))); // only the first element
- BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(10))); // in the middle somewhere
- BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(99))); // all elements satisfy
+ BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(3))); // no elements
+ BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(6))); // only the first element
+ BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(10))); // in the middle somewhere
+ BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(99))); // all elements satisfy
-// With bidirectional iterators.
+// With bidirectional iterators.
std::list<int> l;
for ( int i = 5; i < 15; ++i )
l.push_back ( i );
- BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(3))); // no elements
- BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(6))); // only the first element
- BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(10))); // in the middle somewhere
- BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(99))); // all elements satisfy
+ BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(3))); // no elements
+ BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(6))); // only the first element
+ BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(10))); // in the middle somewhere
+ BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(99))); // all elements satisfy
}
Modified: trunk/libs/algorithm/test/ordered_test.cpp
==============================================================================
--- trunk/libs/algorithm/test/ordered_test.cpp (original)
+++ trunk/libs/algorithm/test/ordered_test.cpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -36,24 +36,24 @@
int nonConstantArray[] = { 1, 2, 2, 2, 5 };
const int inOrderUntilTheEnd [] = { 0, 1, 2, 3, 4, 5, 6, 7, 6 };
-// Begin/end checks
- BOOST_CHECK ( ba::is_sorted (b_e(strictlyIncreasingValues)));
- BOOST_CHECK ( !ba::is_sorted (b_e(randomValues)));
- BOOST_CHECK ( ba::is_sorted (b_e(strictlyIncreasingValues), std::less<int>()));
- BOOST_CHECK ( !ba::is_sorted (b_e(strictlyIncreasingValues), std::greater<int>()));
-
-// Range checks
- BOOST_CHECK ( ba::is_sorted (a_range(strictlyIncreasingValues)));
- BOOST_CHECK ( !ba::is_sorted (a_range(randomValues)));
- BOOST_CHECK ( ba::is_sorted (a_range(strictlyIncreasingValues), std::less<int>()));
- BOOST_CHECK ( !ba::is_sorted (a_range(strictlyIncreasingValues), std::greater<int>()));
+// Begin/end checks
+ BOOST_CHECK ( ba::is_sorted (b_e(strictlyIncreasingValues)));
+ BOOST_CHECK ( !ba::is_sorted (b_e(randomValues)));
+ BOOST_CHECK ( ba::is_sorted (b_e(strictlyIncreasingValues), std::less<int>()));
+ BOOST_CHECK ( !ba::is_sorted (b_e(strictlyIncreasingValues), std::greater<int>()));
+
+// Range checks
+ BOOST_CHECK ( ba::is_sorted (a_range(strictlyIncreasingValues)));
+ BOOST_CHECK ( !ba::is_sorted (a_range(randomValues)));
+ BOOST_CHECK ( ba::is_sorted (a_range(strictlyIncreasingValues), std::less<int>()));
+ BOOST_CHECK ( !ba::is_sorted (a_range(strictlyIncreasingValues), std::greater<int>()));
BOOST_CHECK ( ba::is_sorted_until ( b_e(strictlyIncreasingValues)) == a_end(strictlyIncreasingValues));
BOOST_CHECK ( ba::is_sorted_until ( b_e(strictlyIncreasingValues), std::less<int>()) == a_end(strictlyIncreasingValues));
BOOST_CHECK ( ba::is_sorted_until ( a_range(strictlyIncreasingValues)) == boost::end(strictlyIncreasingValues));
BOOST_CHECK ( ba::is_sorted_until ( a_range(strictlyIncreasingValues), std::less<int>()) == boost::end(strictlyIncreasingValues));
-// Check for const and non-const arrays
+// Check for const and non-const arrays
BOOST_CHECK ( ba::is_sorted_until ( b_e(constantValues), std::less<int>()) != a_end(constantValues));
BOOST_CHECK ( ba::is_sorted_until ( a_range(constantValues), std::less<int>()) != boost::end(constantValues));
BOOST_CHECK ( ba::is_sorted_until ( b_e(nonConstantArray), std::less<int>()) != a_end(nonConstantArray));
@@ -149,6 +149,6 @@
int test_main( int, char * [] )
{
test_ordered ();
- test_increasing_decreasing ();
+ test_increasing_decreasing ();
return 0;
}
Modified: trunk/libs/algorithm/test/partition_point_test1.cpp
==============================================================================
--- trunk/libs/algorithm/test/partition_point_test1.cpp (original)
+++ trunk/libs/algorithm/test/partition_point_test1.cpp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -22,18 +22,18 @@
template <typename Container>
typename Container::iterator offset_to_iter ( Container &v, int offset ) {
- typename Container::iterator retval;
-
- if ( offset >= 0 ) {
- retval = v.begin ();
- std::advance ( retval, offset );
- }
- else {
- retval = v.end ();
- std::advance ( retval, offset + 1 );
- }
- return retval;
- }
+ typename Container::iterator retval;
+
+ if ( offset >= 0 ) {
+ retval = v.begin ();
+ std::advance ( retval, offset );
+ }
+ else {
+ retval = v.end ();
+ std::advance ( retval, offset + 1 );
+ }
+ return retval;
+ }
template <typename Container, typename Predicate>
void test_sequence ( Container &v, Predicate comp, int expected ) {
@@ -79,7 +79,7 @@
test_sequence ( v, less_than<int>(10), 5 );
test_sequence ( v, less_than<int>(99), -1 ); // all elements satisfy
-// With bidirectional iterators.
+// With bidirectional iterators.
std::list<int> l;
for ( int i = 5; i < 15; ++i )
l.push_back ( i );
Modified: trunk/libs/config/test/boost_no_cxx_hdr_functional.ipp
==============================================================================
--- trunk/libs/config/test/boost_no_cxx_hdr_functional.ipp (original)
+++ trunk/libs/config/test/boost_no_cxx_hdr_functional.ipp 2012-05-27 11:24:09 EDT (Sun, 27 May 2012)
@@ -14,6 +14,8 @@
void f(int, float){}
+bool is_true ( int ) { return true; }
+
namespace boost_no_cxx11_hdr_functional {
int test()
@@ -36,6 +38,23 @@
std::bind(f, std::placeholders::_1, 0.0f);
std::function<void(int, float)> fun(f);
+
+// make sure the C++11 functions are there too
+ int arr [5];
+
+ std::all_of ( arr, arr+5, 1 );
+ std::any_of ( arr, arr+5, 1 );
+ std::copy_if ( arr, arr+5, arr, is_true );
+ std::copy_n ( arr, 3, arr );
+ std::find_if_not ( arr, arr+5, is_true );
+ std::iota ( arr, arr+5, 0 );
+ std::is_partitioned ( arr, arr + 5, is_true );
+ std::is_permutation ( arr, arr + 5, is_true );
+ std::is_sorted ( arr, arr+5 );
+ std::is_sorted_until ( arr, arr+5 );
+ std::none_of ( arr, arr+5, 1 );
+ std::partition_copy ( arr, arr+5, arr, arr, is_true );
+ std::partition_point ( arr, arr + 5, is_true );
return 0;
}