feedc0de/boost_detail
1
0
Fork 0
forked from boostorg/detail
Code Pull Requests Activity

Detail: Merge tests + disable container_fwd on libc++.

Browse Source 
[SVN r70719]
This commit is contained in:
Daniel James
2011-03-29 21:58:48 +00:00
parent e2ed5892c2 9f938bf39b
commit 799953dd55
5 changed files with 279 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/boost/detail/container_fwd.hpp
View File

@@ -18,7 +18,8 @@
&& (defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL))) \
|| BOOST_WORKAROUND(__BORLANDC__, > 0x551) \
|| BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x842)) \
|| (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
|| (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) \
|| (defined(_LIBCPP_VERSION))
#include <deque>
#include <list>

21
test/Jamfile Normal file
View File

@@ -0,0 +1,21 @@
################################################################*# Jam #*#######
# Copyright (C) 2010 Bryce Lelbach
#
# Distributed under 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)
################################################################################
project detail/test
: requirements
<toolset>clang:<cxxflags>-Wno-unused
<toolset>clang:<cxxflags>-Wno-tautological-compare
<toolset>clang:<cxxflags>-ftemplate-depth-300
<toolset>gcc:<cxxflags>-ftemplate-depth-300
<toolset>darwin:<cxxflags>-ftemplate-depth-300
;
for tests in [ glob *.cpp ] {
run $(tests) : : : : $(tests:B) ;
}

112
test/container_fwd_test.cpp Normal file
View File

@@ -0,0 +1,112 @@
// Copyright 2005-2009 Daniel James.
// Distributed under 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)
#include <boost/functional/detail/container_fwd.hpp>
#if BOOST_WORKAROUND(__GNUC__, < 3) && \
!defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
template <class charT, class Allocator>
static void test(
std::basic_string<charT, std::string_char_traits<charT>, Allocator> const&)
{
}
#else
template <class charT, class Allocator>
static void test(
std::basic_string<charT, std::char_traits<charT>, Allocator> const&)
{
}
#endif
template <class T, class Allocator>
static void test(std::deque<T, Allocator> const&)
{
}
template <class T, class Allocator>
static void test(std::list<T, Allocator> const&)
{
}
template <class T, class Allocator>
static void test(std::vector<T, Allocator> const&)
{
}
template <class Key, class T, class Compare, class Allocator>
static void test(std::map<Key, T, Compare, Allocator> const&)
{
}
template <class Key, class T, class Compare, class Allocator>
static void test(std::multimap<Key, T, Compare, Allocator> const&)
{
}
template <class Key, class Compare, class Allocator>
static void test(std::set<Key, Compare, Allocator> const&)
{
}
template <class Key, class Compare, class Allocator>
static void test(std::multiset<Key, Compare, Allocator> const&)
{
}
template <std::size_t N>
static void test(std::bitset<N> const&)
{
}
template <class T>
static void test(std::complex<T> const&)
{
}
template <class X, class Y>
static void test(std::pair<X, Y> const&)
{
}
#include <deque>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <bitset>
#include <string>
#include <complex>
#include <utility>
int main()
{
std::deque<int> x1;
std::list<std::string> x2;
std::vector<float> x3;
std::vector<bool> x4;
std::map<int, int> x5;
std::multimap<float, int*> x6;
std::set<std::string> x7;
std::multiset<std::vector<int> > x8;
std::bitset<10> x9;
std::string x10;
std::complex<double> x11;
std::pair<std::list<int>, char***> x12;
test(x1);
test(x2);
test(x3);
test(x4);
test(x5);
test(x6);
test(x7);
test(x8);
test(x9);
test(x10);
test(x11);
test(x12);
return 0;
}

14
test/container_no_fwd_test.cpp Normal file
View File

@@ -0,0 +1,14 @@
// Copyright 2010 Daniel James.
// Distributed under 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)
#define BOOST_DETAIL_NO_CONTAINER_FWD
#include <boost/detail/container_fwd.hpp>
int main()
{
std::set<int> x;
std::vector<std::string> y;
}

130
test/is_sorted_test.cpp Normal file
View File

@@ -0,0 +1,130 @@
/*==============================================================================
Copyright (c) 2010-2011 Bryce Lelbach
Distributed under 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)
==============================================================================*/
#include <ios>
#include <boost/config.hpp>
#include <boost/array.hpp>
#include <boost/detail/is_sorted.hpp>
#include <boost/detail/lightweight_test.hpp>
template<class T>
struct tracking_less: std::binary_function <T, T, bool> {
typedef bool result_type;
#if defined(__PATHSCALE__)
tracking_less (void) { }
~tracking_less (void) { }
#endif
bool operator() (T const& x, T const& y) const {
std::cout << x << " < " << y << " == " << (x < y) << "\n";
return x < y;
}
};
template<class T>
struct tracking_less_equal: std::binary_function <T, T, bool> {
typedef bool result_type;
#if defined(__PATHSCALE__)
tracking_less_equal (void) { }
~tracking_less_equal (void) { }
#endif
bool operator() (T const& x, T const& y) const {
std::cout << x << " <= " << y << " == " << (x <= y) << "\n";
return x <= y;
}
};
template<class T>
struct tracking_greater: std::binary_function <T, T, bool> {
typedef bool result_type;
#if defined(__PATHSCALE__)
tracking_greater (void) { }
~tracking_greater (void) { }
#endif
bool operator() (T const& x, T const& y) const {
std::cout << x << " > " << y << " == " << (x > y) << "\n";
return x > y;
}
};
template<class T>
struct tracking_greater_equal: std::binary_function <T, T, bool> {
typedef bool result_type;
#if defined(__PATHSCALE__)
tracking_greater_equal (void) { }
~tracking_greater_equal (void) { }
#endif
bool operator() (T const& x, T const& y) const {
std::cout << x << " >= " << y << " == " << (x >= y) << "\n";
return x >= y;
}
};
int main (void) {
#define IS_SORTED ::boost::detail::is_sorted
#define IS_SORTED_UNTIL ::boost::detail::is_sorted_until
using boost::array;
using boost::report_errors;
std::cout << std::boolalpha;
array<int, 10> a = { { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } };
array<int, 10> b = { { 0, 1, 1, 2, 5, 8, 13, 34, 55, 89 } };
array<int, 10> c = { { 0, 1, -1, 2, -3, 5, -8, 13, -21, 34 } };
tracking_less<int> lt;
tracking_less_equal<int> lte;
tracking_greater<int> gt;
tracking_greater_equal<int> gte;
BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end()), a.end());
BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end(), lt), a.end());
BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end(), lte), a.end());
BOOST_TEST_EQ(*IS_SORTED_UNTIL(a.rbegin(), a.rend(), gt), *a.rend());
BOOST_TEST_EQ(*IS_SORTED_UNTIL(a.rbegin(), a.rend(), gte), *a.rend());
BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end()), true);
BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end(), lt), true);
BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end(), lte), true);
BOOST_TEST_EQ(IS_SORTED(a.rbegin(), a.rend(), gt), true);
BOOST_TEST_EQ(IS_SORTED(a.rbegin(), a.rend(), gte), true);
BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end()), b.end());
BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end(), lt), b.end());
BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end(), lte), &b[2]);
BOOST_TEST_EQ(*IS_SORTED_UNTIL(b.rbegin(), b.rend(), gt), *b.rend());
BOOST_TEST_EQ(*IS_SORTED_UNTIL(b.rbegin(), b.rend(), gte), b[2]);
BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end()), true);
BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end(), lt), true);
BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end(), lte), false);
BOOST_TEST_EQ(IS_SORTED(b.rbegin(), b.rend(), gt), true);
BOOST_TEST_EQ(IS_SORTED(b.rbegin(), b.rend(), gte), false);
BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end()), &c[2]);
BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end(), lt), &c[2]);
BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end(), lte), &c[2]);
BOOST_TEST_EQ(*IS_SORTED_UNTIL(c.rbegin(), c.rend(), gt), c[7]);
BOOST_TEST_EQ(*IS_SORTED_UNTIL(c.rbegin(), c.rend(), gte), c[7]);
BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end()), false);
BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end(), lt), false);
BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end(), lte), false);
BOOST_TEST_EQ(IS_SORTED(c.rbegin(), c.rend(), gt), false);
BOOST_TEST_EQ(IS_SORTED(c.rbegin(), c.rend(), gte), false);
return report_errors();
}