boostorg/functional
1
0
Fork 1
mirror of https://github.com/boostorg/functional.git synced 2025-08-01 21:44:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

Hash: Safer macro names in tests.

Browse Source 
[SVN r82059]
This commit is contained in:
Daniel James
2012-12-17 23:37:56 +00:00
parent 75ffe88f82
commit cc257de68e
35 changed files with 293 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
hash/test/compile_time.hpp
View File

@@ -11,6 +11,6 @@ template <class T>
void compile_time_tests(T*) void compile_time_tests(T*)
{ {
BOOST_STATIC_ASSERT((boost::is_base_and_derived< BOOST_STATIC_ASSERT((boost::is_base_and_derived<
std::unary_function<T, std::size_t>, HASH_NAMESPACE::hash<T> >::value)); std::unary_function<T, std::size_t>, BOOST_HASH_TEST_NAMESPACE::hash<T> >::value));
} }

10
hash/test/config.hpp
View File

@@ -3,13 +3,13 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying // 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) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#if defined(TEST_STD) #if defined(BOOST_HASH_TEST_STD)
# define TEST_STD_INCLUDES # define BOOST_HASH_TEST_STD_INCLUDES
# define HASH_NAMESPACE std # define BOOST_HASH_TEST_NAMESPACE std
#else #else
# define HASH_NAMESPACE boost # define BOOST_HASH_TEST_NAMESPACE boost
# if !defined(BOOST_HASH_NO_EXTENSIONS) # if !defined(BOOST_HASH_NO_EXTENSIONS)
# define TEST_EXTENSIONS # define BOOST_HASH_TEST_EXTENSIONS
# endif # endif
#endif #endif

30
hash/test/hash_built_in_array_test.cpp
View File

@@ -5,8 +5,8 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -15,7 +15,7 @@
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
void array_int_test() void array_int_test()
{ {
@@ -27,47 +27,47 @@ void array_int_test()
8, -12, 23, 65, 45, 8, -12, 23, 65, 45,
-1, 93, -54, 987, 3 -1, 93, -54, 987, 3
}; };
HASH_NAMESPACE::hash<int[25]> hasher1; BOOST_HASH_TEST_NAMESPACE::hash<int[25]> hasher1;
const int length2 = 1; const int length2 = 1;
int array2[1] = {3}; int array2[1] = {3};
HASH_NAMESPACE::hash<int[1]> hasher2; BOOST_HASH_TEST_NAMESPACE::hash<int[1]> hasher2;
const int length3 = 2; const int length3 = 2;
int array3[2] = {2, 3}; int array3[2] = {2, 3};
HASH_NAMESPACE::hash<int[2]> hasher3; BOOST_HASH_TEST_NAMESPACE::hash<int[2]> hasher3;
BOOST_TEST(hasher1(array1) BOOST_TEST(hasher1(array1)
== HASH_NAMESPACE::hash_range(array1, array1 + length1)); == BOOST_HASH_TEST_NAMESPACE::hash_range(array1, array1 + length1));
BOOST_TEST(hasher2(array2) BOOST_TEST(hasher2(array2)
== HASH_NAMESPACE::hash_range(array2, array2 + length2)); == BOOST_HASH_TEST_NAMESPACE::hash_range(array2, array2 + length2));
BOOST_TEST(hasher3(array3) BOOST_TEST(hasher3(array3)
== HASH_NAMESPACE::hash_range(array3, array3 + length3)); == BOOST_HASH_TEST_NAMESPACE::hash_range(array3, array3 + length3));
} }
void two_dimensional_array_test() void two_dimensional_array_test()
{ {
int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}}; int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}};
HASH_NAMESPACE::hash<int[3][2]> hasher; BOOST_HASH_TEST_NAMESPACE::hash<int[3][2]> hasher;
std::size_t seed1 = 0; std::size_t seed1 = 0;
for(int i = 0; i < 3; ++i) for(int i = 0; i < 3; ++i)
{ {
std::size_t seed2 = 0; std::size_t seed2 = 0;
for(int j = 0; j < 2; ++j) for(int j = 0; j < 2; ++j)
HASH_NAMESPACE::hash_combine(seed2, array[i][j]); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, array[i][j]);
HASH_NAMESPACE::hash_combine(seed1, seed2); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed1, seed2);
} }
BOOST_TEST(hasher(array) == seed1); BOOST_TEST(hasher(array) == seed1);
BOOST_TEST(hasher(array) == HASH_NAMESPACE::hash_range(array, array + 3)); BOOST_TEST(hasher(array) == BOOST_HASH_TEST_NAMESPACE::hash_range(array, array + 3));
} }
#endif // TEST_EXTENSIONS #endif // BOOST_HASH_TEST_EXTENSIONS
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
array_int_test(); array_int_test();
two_dimensional_array_test(); two_dimensional_array_test();
#endif #endif

10
hash/test/hash_complex_test.cpp
View File

@@ -5,13 +5,13 @@
#include "./config.hpp" #include "./config.hpp"
#if !defined(TEST_EXTENSIONS) #if !defined(BOOST_HASH_TEST_EXTENSIONS)
int main() {} int main() {}
#else #else
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -46,11 +46,11 @@ int main() {}
template <class T> template <class T>
void generic_complex_tests(std::complex<T> v) void generic_complex_tests(std::complex<T> v)
{ {
HASH_NAMESPACE::hash<std::complex<T> > complex_hasher; BOOST_HASH_TEST_NAMESPACE::hash<std::complex<T> > complex_hasher;
BOOST_TEST(complex_hasher(v) == complex_hasher(v)); BOOST_TEST(complex_hasher(v) == complex_hasher(v));
HASH_NAMESPACE::hash<T> real_hasher; BOOST_HASH_TEST_NAMESPACE::hash<T> real_hasher;
T real = v.real(); T real = v.real();
T imag = v.imag(); T imag = v.imag();
@@ -107,4 +107,4 @@ int main()
return boost::report_errors(); return boost::report_errors();
} }
#endif // TEST_EXTENSIONS #endif // BOOST_HASH_TEST_EXTENSIONS

28
hash/test/hash_custom_test.cpp
View File

@@ -41,8 +41,8 @@ namespace boost
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -51,7 +51,7 @@ namespace boost
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
#include <vector> #include <vector>
#include <string> #include <string>
@@ -59,13 +59,13 @@ namespace boost
void custom_tests() void custom_tests()
{ {
HASH_NAMESPACE::hash<test::custom> custom_hasher; BOOST_HASH_TEST_NAMESPACE::hash<test::custom> custom_hasher;
BOOST_TEST(custom_hasher(10) == 100u); BOOST_TEST(custom_hasher(10) == 100u);
test::custom x(55); test::custom x(55);
BOOST_TEST(custom_hasher(x) == 550u); BOOST_TEST(custom_hasher(x) == 550u);
{ {
using namespace HASH_NAMESPACE; using namespace BOOST_HASH_TEST_NAMESPACE;
BOOST_TEST(custom_hasher(x) == hash_value(x)); BOOST_TEST(custom_hasher(x) == hash_value(x));
} }
@@ -75,25 +75,25 @@ void custom_tests()
custom_vector.push_back(35); custom_vector.push_back(35);
std::size_t seed = 0; std::size_t seed = 0;
HASH_NAMESPACE::hash_combine(seed, test::custom(5)); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom(5));
HASH_NAMESPACE::hash_combine(seed, test::custom(25)); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom(25));
HASH_NAMESPACE::hash_combine(seed, test::custom(35)); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom(35));
std::size_t seed2 = 0; std::size_t seed2 = 0;
HASH_NAMESPACE::hash_combine(seed2, 50u); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 50u);
HASH_NAMESPACE::hash_combine(seed2, 250u); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 250u);
HASH_NAMESPACE::hash_combine(seed2, 350u); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 350u);
BOOST_TEST(seed == HASH_NAMESPACE::hash_range( BOOST_TEST(seed == BOOST_HASH_TEST_NAMESPACE::hash_range(
custom_vector.begin(), custom_vector.end())); custom_vector.begin(), custom_vector.end()));
BOOST_TEST(seed == seed2); BOOST_TEST(seed == seed2);
} }
#endif // TEST_EXTENSIONS #endif // BOOST_HASH_TEST_EXTENSIONS
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
custom_tests(); custom_tests();
#endif #endif
return boost::report_errors(); return boost::report_errors();

10
hash/test/hash_deque_test.cpp
View File

@@ -5,8 +5,8 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -15,7 +15,7 @@
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
#include <deque> #include <deque>
@@ -23,11 +23,11 @@ using std::deque;
#define CONTAINER_TYPE deque #define CONTAINER_TYPE deque
#include "./hash_sequence_test.hpp" #include "./hash_sequence_test.hpp"
#endif // TEST_EXTENSIONS #endif // BOOST_HASH_TEST_EXTENSIONS
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
deque_tests::deque_hash_integer_tests(); deque_tests::deque_hash_integer_tests();
#endif #endif

12
hash/test/hash_enum_test.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -31,10 +31,10 @@ int main() {
compile_time_tests((test::enum4*) 0); compile_time_tests((test::enum4*) 0);
compile_time_tests((test::enum_override*) 0); compile_time_tests((test::enum_override*) 0);
HASH_NAMESPACE::hash<test::enum1> hash1; BOOST_HASH_TEST_NAMESPACE::hash<test::enum1> hash1;
HASH_NAMESPACE::hash<test::enum2> hash2; BOOST_HASH_TEST_NAMESPACE::hash<test::enum2> hash2;
HASH_NAMESPACE::hash<test::enum3> hash3; BOOST_HASH_TEST_NAMESPACE::hash<test::enum3> hash3;
HASH_NAMESPACE::hash<test::enum4> hash4; BOOST_HASH_TEST_NAMESPACE::hash<test::enum4> hash4;
BOOST_TEST(hash1(test::enum1a) == hash1(test::enum1a)); BOOST_TEST(hash1(test::enum1a) == hash1(test::enum1a));
@@ -50,7 +50,7 @@ int main() {
BOOST_TEST(hash4(test::enum4a) != hash4(test::enum4b)); BOOST_TEST(hash4(test::enum4a) != hash4(test::enum4b));
BOOST_TEST(hash4(test::enum4b) == hash4(test::enum4b)); BOOST_TEST(hash4(test::enum4b) == hash4(test::enum4b));
HASH_NAMESPACE::hash<test::enum_override> hash_override; BOOST_HASH_TEST_NAMESPACE::hash<test::enum_override> hash_override;
BOOST_TEST(hash_override(test::enum_override1) == BOOST_TEST(hash_override(test::enum_override1) ==
hash_override(test::enum_override1)); hash_override(test::enum_override1));

48
hash/test/hash_float_test.hpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -43,7 +43,7 @@ void float_tests(char const* name, T* = 0)
{ {
std::cerr std::cerr
<< "\n" << "\n"
<< "Testing " BOOST_STRINGIZE(HASH_NAMESPACE) "::hash<" << "Testing " BOOST_STRINGIZE(BOOST_HASH_TEST_NAMESPACE) "::hash<"
<< name << name
<< ">\n" << ">\n"
<< "\n" << "\n"
@@ -70,7 +70,7 @@ void float_tests(char const* name, T* = 0)
<< "\n" << "\n"
; ;
HASH_NAMESPACE::hash<T> x1; BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
T zero = 0; T zero = 0;
T minus_zero = (T) -1 * zero; T minus_zero = (T) -1 * zero;
@@ -78,9 +78,9 @@ void float_tests(char const* name, T* = 0)
BOOST_TEST(zero == minus_zero); BOOST_TEST(zero == minus_zero);
BOOST_TEST(x1(zero) == x1(minus_zero)); BOOST_TEST(x1(zero) == x1(minus_zero));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(x1(zero) == HASH_NAMESPACE::hash_value(zero)); BOOST_TEST(x1(zero) == BOOST_HASH_TEST_NAMESPACE::hash_value(zero));
BOOST_TEST(x1(minus_zero) == HASH_NAMESPACE::hash_value(minus_zero)); BOOST_TEST(x1(minus_zero) == BOOST_HASH_TEST_NAMESPACE::hash_value(minus_zero));
#endif #endif
BOOST_TEST(x1(zero) != x1(0.5)); BOOST_TEST(x1(zero) != x1(0.5));
@@ -106,10 +106,10 @@ void float_tests(char const* name, T* = 0)
T minus_infinity2 = (T) -1. / zero; T minus_infinity2 = (T) -1. / zero;
T minus_infinity3 = (T) 1. / minus_zero; T minus_infinity3 = (T) 1. / minus_zero;
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(x1(infinity) == HASH_NAMESPACE::hash_value(infinity)); BOOST_TEST(x1(infinity) == BOOST_HASH_TEST_NAMESPACE::hash_value(infinity));
BOOST_TEST(x1(minus_infinity) BOOST_TEST(x1(minus_infinity)
== HASH_NAMESPACE::hash_value(minus_infinity)); == BOOST_HASH_TEST_NAMESPACE::hash_value(minus_infinity));
#endif #endif
if(infinity == infinity2) if(infinity == infinity2)
@@ -191,12 +191,12 @@ void float_tests(char const* name, T* = 0)
BOOST_TEST(three_quarter_max != -three_quarter_max); BOOST_TEST(three_quarter_max != -three_quarter_max);
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(x1(max) == HASH_NAMESPACE::hash_value(max)); BOOST_TEST(x1(max) == BOOST_HASH_TEST_NAMESPACE::hash_value(max));
BOOST_TEST(x1(half_max) == HASH_NAMESPACE::hash_value(half_max)); BOOST_TEST(x1(half_max) == BOOST_HASH_TEST_NAMESPACE::hash_value(half_max));
BOOST_TEST(x1(quarter_max) == HASH_NAMESPACE::hash_value(quarter_max)); BOOST_TEST(x1(quarter_max) == BOOST_HASH_TEST_NAMESPACE::hash_value(quarter_max));
BOOST_TEST(x1(three_quarter_max) == BOOST_TEST(x1(three_quarter_max) ==
HASH_NAMESPACE::hash_value(three_quarter_max)); BOOST_HASH_TEST_NAMESPACE::hash_value(three_quarter_max));
#endif #endif
// The '!=' tests could legitimately fail, but with my hash it indicates a // The '!=' tests could legitimately fail, but with my hash it indicates a
@@ -227,16 +227,16 @@ void float_tests(char const* name, T* = 0)
if(v1 == v2) if(v1 == v2)
BOOST_TEST(x1(v1) == x1(v2)); BOOST_TEST(x1(v1) == x1(v2));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(x1(v1) == HASH_NAMESPACE::hash_value(v1)); BOOST_TEST(x1(v1) == BOOST_HASH_TEST_NAMESPACE::hash_value(v1));
BOOST_TEST(x1(v2) == HASH_NAMESPACE::hash_value(v2)); BOOST_TEST(x1(v2) == BOOST_HASH_TEST_NAMESPACE::hash_value(v2));
#endif #endif
#endif #endif
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(x1(boost::hash_detail::limits<T>::epsilon()) == BOOST_TEST(x1(boost::hash_detail::limits<T>::epsilon()) ==
HASH_NAMESPACE::hash_value( BOOST_HASH_TEST_NAMESPACE::hash_value(
boost::hash_detail::limits<T>::epsilon())); boost::hash_detail::limits<T>::epsilon()));
#endif #endif
@@ -269,12 +269,12 @@ void float_tests(char const* name, T* = 0)
if(x1(boost::hash_detail::limits<T>::denorm_min()) == x1(zero)) { if(x1(boost::hash_detail::limits<T>::denorm_min()) == x1(zero)) {
std::cerr<<"x1(denorm_min) == x1(zero) == "<<x1(zero)<<"\n"; std::cerr<<"x1(denorm_min) == x1(zero) == "<<x1(zero)<<"\n";
} }
#if !BOOST_WORKAROUND(__DECCXX_VER,<70190006) && defined(TEST_EXTENSIONS) #if !BOOST_WORKAROUND(__DECCXX_VER,<70190006) && defined(BOOST_HASH_TEST_EXTENSIONS)
// The Tru64/CXX standard library prior to 7.1 contains a bug in the // The Tru64/CXX standard library prior to 7.1 contains a bug in the
// specialization of boost::hash_detail::limits::denorm_min() for long // specialization of boost::hash_detail::limits::denorm_min() for long
// doubles which causes this test to fail. // doubles which causes this test to fail.
if(x1(boost::hash_detail::limits<T>::denorm_min()) != if(x1(boost::hash_detail::limits<T>::denorm_min()) !=
HASH_NAMESPACE::hash_value( BOOST_HASH_TEST_NAMESPACE::hash_value(
boost::hash_detail::limits<T>::denorm_min())) boost::hash_detail::limits<T>::denorm_min()))
{ {
std::cerr std::cerr
@@ -282,7 +282,7 @@ void float_tests(char const* name, T* = 0)
<< x1(boost::hash_detail::limits<T>::denorm_min()) << x1(boost::hash_detail::limits<T>::denorm_min())
<< "\nhash_value(boost::hash_detail::limits<T>::denorm_min())" << "\nhash_value(boost::hash_detail::limits<T>::denorm_min())"
" = " " = "
<< HASH_NAMESPACE::hash_value( << BOOST_HASH_TEST_NAMESPACE::hash_value(
boost::hash_detail::limits<T>::denorm_min()) boost::hash_detail::limits<T>::denorm_min())
<< "\nx1(0) = " << "\nx1(0) = "
<< x1(0) << x1(0)
@@ -292,13 +292,13 @@ void float_tests(char const* name, T* = 0)
} }
// NaN also causes borland to crash. // NaN also causes borland to crash.
#if !defined(__BORLANDC__) && defined(TEST_EXTENSIONS) #if !defined(__BORLANDC__) && defined(BOOST_HASH_TEST_EXTENSIONS)
if(boost::hash_detail::limits<T>::has_quiet_NaN) { if(boost::hash_detail::limits<T>::has_quiet_NaN) {
if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(1.0)) { if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(1.0)) {
std::cerr<<"x1(quiet_NaN) == x1(1.0) == "<<x1(1.0)<<"\n"; std::cerr<<"x1(quiet_NaN) == x1(1.0) == "<<x1(1.0)<<"\n";
} }
BOOST_TEST(x1(boost::hash_detail::limits<T>::quiet_NaN()) == BOOST_TEST(x1(boost::hash_detail::limits<T>::quiet_NaN()) ==
HASH_NAMESPACE::hash_value( BOOST_HASH_TEST_NAMESPACE::hash_value(
boost::hash_detail::limits<T>::quiet_NaN())); boost::hash_detail::limits<T>::quiet_NaN()));
} }
#endif #endif

28
hash/test/hash_friend_test.cpp
View File

@@ -44,8 +44,8 @@ namespace boost
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -54,7 +54,7 @@ namespace boost
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
#include <vector> #include <vector>
#include <string> #include <string>
@@ -62,13 +62,13 @@ namespace boost
void custom_tests() void custom_tests()
{ {
HASH_NAMESPACE::hash<test::custom<int> > custom_hasher; BOOST_HASH_TEST_NAMESPACE::hash<test::custom<int> > custom_hasher;
BOOST_TEST(custom_hasher(10) == 100u); BOOST_TEST(custom_hasher(10) == 100u);
test::custom<int> x(55); test::custom<int> x(55);
BOOST_TEST(custom_hasher(x) == 550u); BOOST_TEST(custom_hasher(x) == 550u);
{ {
using namespace HASH_NAMESPACE; using namespace BOOST_HASH_TEST_NAMESPACE;
BOOST_TEST(custom_hasher(x) == hash_value(x)); BOOST_TEST(custom_hasher(x) == hash_value(x));
} }
@@ -78,25 +78,25 @@ void custom_tests()
custom_vector.push_back(35); custom_vector.push_back(35);
std::size_t seed = 0; std::size_t seed = 0;
HASH_NAMESPACE::hash_combine(seed, test::custom<int>(5)); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom<int>(5));
HASH_NAMESPACE::hash_combine(seed, test::custom<int>(25)); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom<int>(25));
HASH_NAMESPACE::hash_combine(seed, test::custom<int>(35)); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, test::custom<int>(35));
std::size_t seed2 = 0; std::size_t seed2 = 0;
HASH_NAMESPACE::hash_combine(seed2, 50u); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 50u);
HASH_NAMESPACE::hash_combine(seed2, 250u); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 250u);
HASH_NAMESPACE::hash_combine(seed2, 350u); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 350u);
BOOST_TEST(seed == HASH_NAMESPACE::hash_range( BOOST_TEST(seed == BOOST_HASH_TEST_NAMESPACE::hash_range(
custom_vector.begin(), custom_vector.end())); custom_vector.begin(), custom_vector.end()));
BOOST_TEST(seed == seed2); BOOST_TEST(seed == seed2);
} }
#endif // TEST_EXTENSIONS #endif // BOOST_HASH_TEST_EXTENSIONS
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
custom_tests(); custom_tests();
#endif #endif
return boost::report_errors(); return boost::report_errors();

12
hash/test/hash_function_pointer_test.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -24,8 +24,8 @@ void function_pointer_tests()
compile_time_tests((void(**)()) 0); compile_time_tests((void(**)()) 0);
compile_time_tests((int(**)(int)) 0); compile_time_tests((int(**)(int)) 0);
HASH_NAMESPACE::hash<void(*)()> hasher_void; BOOST_HASH_TEST_NAMESPACE::hash<void(*)()> hasher_void;
HASH_NAMESPACE::hash<int(*)(int)> hasher_int; BOOST_HASH_TEST_NAMESPACE::hash<int(*)(int)> hasher_int;
BOOST_TEST(&void_func1 != &void_func2); BOOST_TEST(&void_func1 != &void_func2);
BOOST_TEST(&int_func1 != &int_func2); BOOST_TEST(&int_func1 != &int_func2);
@@ -38,11 +38,11 @@ void function_pointer_tests()
BOOST_TEST(hasher_int(&int_func1) == hasher_int(&int_func1)); BOOST_TEST(hasher_int(&int_func1) == hasher_int(&int_func1));
BOOST_TEST(hasher_int(&int_func1) != hasher_int(&int_func2)); BOOST_TEST(hasher_int(&int_func1) != hasher_int(&int_func2));
BOOST_TEST(hasher_int(&int_func1) != hasher_int(0)); BOOST_TEST(hasher_int(&int_func1) != hasher_int(0));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(hasher_void(&void_func1) BOOST_TEST(hasher_void(&void_func1)
== HASH_NAMESPACE::hash_value(&void_func1)); == BOOST_HASH_TEST_NAMESPACE::hash_value(&void_func1));
BOOST_TEST(hasher_int(&int_func1) BOOST_TEST(hasher_int(&int_func1)
== HASH_NAMESPACE::hash_value(&int_func1)); == BOOST_HASH_TEST_NAMESPACE::hash_value(&int_func1));
// This isn't specified in Peter's proposal: // This isn't specified in Peter's proposal:
BOOST_TEST(hasher_void(0) == 0); BOOST_TEST(hasher_void(0) == 0);

22
hash/test/hash_fwd_test.hpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#if defined(TEST_EXTENSIONS) && !defined(TEST_STD_INCLUDES) #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES)
#include <boost/functional/hash_fwd.hpp> #include <boost/functional/hash_fwd.hpp>
#include <boost/config.hpp> #include <boost/config.hpp>
@@ -25,7 +25,7 @@ namespace test {
template <class T> template <class T>
std::size_t hash_value(test_type1<T> const& x) std::size_t hash_value(test_type1<T> const& x)
{ {
HASH_NAMESPACE::hash<T> hasher; BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
return hasher(x.value); return hasher(x.value);
} }
#endif #endif
@@ -42,8 +42,8 @@ namespace test {
std::size_t hash_value(test_type2<T> const& x) std::size_t hash_value(test_type2<T> const& x)
{ {
std::size_t seed = 0; std::size_t seed = 0;
HASH_NAMESPACE::hash_combine(seed, x.value1); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, x.value1);
HASH_NAMESPACE::hash_combine(seed, x.value2); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, x.value2);
return seed; return seed;
} }
#endif #endif
@@ -61,8 +61,8 @@ namespace test {
std::size_t hash_value(test_type3<T> const& x) std::size_t hash_value(test_type3<T> const& x)
{ {
std::size_t seed = std::size_t seed =
HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(x.values.begin(), x.values.end());
HASH_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end());
return seed; return seed;
} }
#endif #endif
@@ -76,7 +76,7 @@ namespace boost
template <class T> template <class T>
std::size_t hash_value(test::test_type1<T> const& x) std::size_t hash_value(test::test_type1<T> const& x)
{ {
HASH_NAMESPACE::hash<T> hasher; BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
return hasher(x.value); return hasher(x.value);
} }
@@ -84,8 +84,8 @@ namespace boost
std::size_t hash_value(test::test_type2<T> const& x) std::size_t hash_value(test::test_type2<T> const& x)
{ {
std::size_t seed = 0; std::size_t seed = 0;
HASH_NAMESPACE::hash_combine(seed, x.value1); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, x.value1);
HASH_NAMESPACE::hash_combine(seed, x.value2); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, x.value2);
return seed; return seed;
} }
@@ -93,8 +93,8 @@ namespace boost
std::size_t hash_value(test::test_type3<T> const& x) std::size_t hash_value(test::test_type3<T> const& x)
{ {
std::size_t seed = std::size_t seed =
HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(x.values.begin(), x.values.end());
HASH_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end());
return seed; return seed;
} }
} }

36
hash/test/hash_fwd_test_1.cpp
View File

@@ -11,7 +11,7 @@
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#if defined(TEST_EXTENSIONS) && !defined(TEST_STD_INCLUDES) #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES)
#include <boost/functional/hash.hpp> #include <boost/functional/hash.hpp>
#include <string> #include <string>
@@ -21,10 +21,10 @@ void fwd_test1()
test::test_type1<int> x(5); test::test_type1<int> x(5);
test::test_type1<std::string> y("Test"); test::test_type1<std::string> y("Test");
HASH_NAMESPACE::hash<int> hasher_int; BOOST_HASH_TEST_NAMESPACE::hash<int> hasher_int;
HASH_NAMESPACE::hash<std::string> hasher_string; BOOST_HASH_TEST_NAMESPACE::hash<std::string> hasher_string;
HASH_NAMESPACE::hash<test::test_type1<int> > hasher_test_int; BOOST_HASH_TEST_NAMESPACE::hash<test::test_type1<int> > hasher_test_int;
HASH_NAMESPACE::hash<test::test_type1<std::string> > hasher_test_string; BOOST_HASH_TEST_NAMESPACE::hash<test::test_type1<std::string> > hasher_test_string;
BOOST_TEST(hasher_int(5) == hasher_test_int(x)); BOOST_TEST(hasher_int(5) == hasher_test_int(x));
BOOST_TEST(hasher_string("Test") == hasher_test_string(y)); BOOST_TEST(hasher_string("Test") == hasher_test_string(y));
@@ -36,15 +36,15 @@ void fwd_test2()
test::test_type2<std::string> y("Test1", "Test2"); test::test_type2<std::string> y("Test1", "Test2");
std::size_t seed1 = 0; std::size_t seed1 = 0;
HASH_NAMESPACE::hash_combine(seed1, 5); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed1, 5);
HASH_NAMESPACE::hash_combine(seed1, 10); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed1, 10);
std::size_t seed2 = 0; std::size_t seed2 = 0;
HASH_NAMESPACE::hash_combine(seed2, std::string("Test1")); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, std::string("Test1"));
HASH_NAMESPACE::hash_combine(seed2, std::string("Test2")); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, std::string("Test2"));
HASH_NAMESPACE::hash<test::test_type2<int> > hasher_test_int; BOOST_HASH_TEST_NAMESPACE::hash<test::test_type2<int> > hasher_test_int;
HASH_NAMESPACE::hash<test::test_type2<std::string> > hasher_test_string; BOOST_HASH_TEST_NAMESPACE::hash<test::test_type2<std::string> > hasher_test_string;
BOOST_TEST(seed1 == hasher_test_int(x)); BOOST_TEST(seed1 == hasher_test_int(x));
BOOST_TEST(seed2 == hasher_test_string(y)); BOOST_TEST(seed2 == hasher_test_string(y));
@@ -69,15 +69,15 @@ void fwd_test3()
test::test_type3<std::string> y(values2.begin(), values2.end()); test::test_type3<std::string> y(values2.begin(), values2.end());
std::size_t seed1 = std::size_t seed1 =
HASH_NAMESPACE::hash_range(values1.begin(), values1.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(values1.begin(), values1.end());
HASH_NAMESPACE::hash_range(seed1, values1.begin(), values1.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(seed1, values1.begin(), values1.end());
std::size_t seed2 = std::size_t seed2 =
HASH_NAMESPACE::hash_range(values2.begin(), values2.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(values2.begin(), values2.end());
HASH_NAMESPACE::hash_range(seed2, values2.begin(), values2.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(seed2, values2.begin(), values2.end());
HASH_NAMESPACE::hash<test::test_type3<int> > hasher_test_int; BOOST_HASH_TEST_NAMESPACE::hash<test::test_type3<int> > hasher_test_int;
HASH_NAMESPACE::hash<test::test_type3<std::string> > hasher_test_string; BOOST_HASH_TEST_NAMESPACE::hash<test::test_type3<std::string> > hasher_test_string;
BOOST_TEST(seed1 == hasher_test_int(x)); BOOST_TEST(seed1 == hasher_test_int(x));
BOOST_TEST(seed2 == hasher_test_string(y)); BOOST_TEST(seed2 == hasher_test_string(y));
@@ -87,7 +87,7 @@ void fwd_test3()
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
fwd_test1(); fwd_test1();
fwd_test2(); fwd_test2();
fwd_test3(); fwd_test3();

4
hash/test/hash_fwd_test_2.cpp
View File

@@ -8,7 +8,7 @@
#include "./config.hpp" #include "./config.hpp"
#if !defined(TEST_EXTENSIONS) || defined(TEST_STD_INCLUDES) #if !defined(BOOST_HASH_TEST_EXTENSIONS) || defined(BOOST_HASH_TEST_STD_INCLUDES)
int main() {} int main() {}
@@ -44,4 +44,4 @@ int main()
return boost::report_errors(); return boost::report_errors();
} }
#endif // defined(TEST_EXTENSIONS) && !defined(TEST_STD_INCLUDES) #endif // defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES)

28
hash/test/hash_global_namespace_test.cpp
View File

@@ -42,8 +42,8 @@ namespace boost
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -52,7 +52,7 @@ namespace boost
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
#include <vector> #include <vector>
#include <string> #include <string>
@@ -60,13 +60,13 @@ namespace boost
void custom_tests() void custom_tests()
{ {
HASH_NAMESPACE::hash<custom> custom_hasher; BOOST_HASH_TEST_NAMESPACE::hash<custom> custom_hasher;
BOOST_TEST(custom_hasher(10) == 100u); BOOST_TEST(custom_hasher(10) == 100u);
custom x(55); custom x(55);
BOOST_TEST(custom_hasher(x) == 550u); BOOST_TEST(custom_hasher(x) == 550u);
{ {
using namespace HASH_NAMESPACE; using namespace BOOST_HASH_TEST_NAMESPACE;
BOOST_TEST(custom_hasher(x) == hash_value(x)); BOOST_TEST(custom_hasher(x) == hash_value(x));
} }
@@ -76,26 +76,26 @@ void custom_tests()
custom_vector.push_back(35); custom_vector.push_back(35);
std::size_t seed = 0; std::size_t seed = 0;
HASH_NAMESPACE::hash_combine(seed, custom(5)); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, custom(5));
HASH_NAMESPACE::hash_combine(seed, custom(25)); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, custom(25));
HASH_NAMESPACE::hash_combine(seed, custom(35)); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed, custom(35));
std::size_t seed2 = 0; std::size_t seed2 = 0;
HASH_NAMESPACE::hash_combine(seed2, 50u); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 50u);
HASH_NAMESPACE::hash_combine(seed2, 250u); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 250u);
HASH_NAMESPACE::hash_combine(seed2, 350u); BOOST_HASH_TEST_NAMESPACE::hash_combine(seed2, 350u);
BOOST_TEST(seed == HASH_NAMESPACE::hash_range( BOOST_TEST(seed == BOOST_HASH_TEST_NAMESPACE::hash_range(
custom_vector.begin(), custom_vector.end())); custom_vector.begin(), custom_vector.end()));
BOOST_TEST(seed == seed2); BOOST_TEST(seed == seed2);
} }
#endif // TEST_EXTENSIONS #endif // BOOST_HASH_TEST_EXTENSIONS
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
custom_tests(); custom_tests();
#endif #endif
return boost::report_errors(); return boost::report_errors();

10
hash/test/hash_list_test.cpp
View File

@@ -5,8 +5,8 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -15,7 +15,7 @@
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
#include <list> #include <list>
@@ -23,11 +23,11 @@ using std::list;
#define CONTAINER_TYPE list #define CONTAINER_TYPE list
#include "./hash_sequence_test.hpp" #include "./hash_sequence_test.hpp"
#endif // TEST_EXTENSIONS #endif // BOOST_HASH_TEST_EXTENSIONS
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
list_tests::list_hash_integer_tests(); list_tests::list_hash_integer_tests();
#endif #endif

10
hash/test/hash_map_test.cpp
View File

@@ -5,8 +5,8 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -17,7 +17,7 @@
#include <map> #include <map>
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
using std::map; using std::map;
#define CONTAINER_TYPE map #define CONTAINER_TYPE map
@@ -27,11 +27,11 @@ using std::multimap;
#define CONTAINER_TYPE multimap #define CONTAINER_TYPE multimap
#include "./hash_map_test.hpp" #include "./hash_map_test.hpp"
#endif // TEST_EXTENSIONS #endif // BOOST_HASH_TEST_EXTENSIONS
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
map_tests::map_hash_integer_tests(); map_tests::map_hash_integer_tests();
multimap_tests::multimap_hash_integer_tests(); multimap_tests::multimap_hash_integer_tests();
#endif #endif

6
hash/test/hash_map_test.hpp
View File

@@ -38,16 +38,16 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
containers[9].insert(pair(key(-1),value(3))); containers[9].insert(pair(key(-1),value(3)));
containers[9].insert(pair(key(-1),value(3))); containers[9].insert(pair(key(-1),value(3)));
HASH_NAMESPACE::hash<T> hasher; BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
for(int i2 = 0; i2 < number_of_containers; ++i2) { for(int i2 = 0; i2 < number_of_containers; ++i2) {
BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2])); BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
BOOST_TEST(hasher(containers[i2]) == BOOST_TEST(hasher(containers[i2]) ==
HASH_NAMESPACE::hash_value(containers[i2])); BOOST_HASH_TEST_NAMESPACE::hash_value(containers[i2]));
BOOST_TEST(hasher(containers[i2]) BOOST_TEST(hasher(containers[i2])
== HASH_NAMESPACE::hash_range( == BOOST_HASH_TEST_NAMESPACE::hash_range(
containers[i2].begin(), containers[i2].end())); containers[i2].begin(), containers[i2].end()));
for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) { for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {

4
hash/test/hash_no_ext_fail_test.cpp
View File

@@ -11,7 +11,7 @@
# define BOOST_HASH_NO_EXTENSIONS # define BOOST_HASH_NO_EXTENSIONS
#endif #endif
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -21,7 +21,7 @@ template <class T> void ignore(T const&) {}
int main() int main()
{ {
HASH_NAMESPACE::hash< int[10] > hasher; BOOST_HASH_TEST_NAMESPACE::hash< int[10] > hasher;
ignore(hasher); ignore(hasher);
return 0; return 0;

8
hash/test/hash_no_ext_macro_1.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
// Include header without BOOST_HASH_NO_EXTENSIONS defined // Include header without BOOST_HASH_NO_EXTENSIONS defined
# if defined(BOOST_HASH_NO_EXTENSIONS) # if defined(BOOST_HASH_NO_EXTENSIONS)
@@ -23,14 +23,14 @@
int main() int main()
{ {
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
std::deque<int> x; std::deque<int> x;
x.push_back(1); x.push_back(1);
x.push_back(2); x.push_back(2);
HASH_NAMESPACE::hash<std::deque<int> > hasher; BOOST_HASH_TEST_NAMESPACE::hash<std::deque<int> > hasher;
BOOST_TEST(hasher(x) == HASH_NAMESPACE::hash_value(x)); BOOST_TEST(hasher(x) == BOOST_HASH_TEST_NAMESPACE::hash_value(x));
#endif #endif
return boost::report_errors(); return boost::report_errors();

8
hash/test/hash_no_ext_macro_2.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
// Include header with BOOST_HASH_NO_EXTENSIONS defined // Include header with BOOST_HASH_NO_EXTENSIONS defined
# if !defined(BOOST_HASH_NO_EXTENSIONS) # if !defined(BOOST_HASH_NO_EXTENSIONS)
@@ -23,14 +23,14 @@
int main() int main()
{ {
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
std::map<int, int> x; std::map<int, int> x;
x.insert(std::map<int, int>::value_type(53, -42)); x.insert(std::map<int, int>::value_type(53, -42));
x.insert(std::map<int, int>::value_type(14, -75)); x.insert(std::map<int, int>::value_type(14, -75));
HASH_NAMESPACE::hash<std::map<int, int> > hasher; BOOST_HASH_TEST_NAMESPACE::hash<std::map<int, int> > hasher;
BOOST_TEST(hasher(x) == HASH_NAMESPACE::hash_value(x)); BOOST_TEST(hasher(x) == BOOST_HASH_TEST_NAMESPACE::hash_value(x));
#endif #endif
return boost::report_errors(); return boost::report_errors();

46
hash/test/hash_number_test.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -41,11 +41,11 @@ void numeric_extra_tests(typename
if(limits::is_signed || if(limits::is_signed ||
limits::digits <= boost::hash_detail::limits<std::size_t>::digits) limits::digits <= boost::hash_detail::limits<std::size_t>::digits)
{ {
BOOST_TEST(HASH_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5)); BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5));
} }
BOOST_TEST(HASH_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u)); BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u));
BOOST_TEST(HASH_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u)); BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u));
BOOST_TEST(HASH_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u)); BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u));
} }
template <class T> template <class T>
@@ -62,8 +62,8 @@ void numeric_test(T*)
compile_time_tests((T*) 0); compile_time_tests((T*) 0);
HASH_NAMESPACE::hash<T> x1; BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
HASH_NAMESPACE::hash<T> x2; BOOST_HASH_TEST_NAMESPACE::hash<T> x2;
T v1 = (T) -5; T v1 = (T) -5;
BOOST_TEST(x1(v1) == x2(v1)); BOOST_TEST(x1(v1) == x2(v1));
@@ -74,11 +74,11 @@ void numeric_test(T*)
BOOST_TEST(x1(T(5) - T(5)) == x2(T(0))); BOOST_TEST(x1(T(5) - T(5)) == x2(T(0)));
BOOST_TEST(x1(T(6) + T(4)) == x2(T(10))); BOOST_TEST(x1(T(6) + T(4)) == x2(T(10)));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(x1(T(-5)) == HASH_NAMESPACE::hash_value(T(-5))); BOOST_TEST(x1(T(-5)) == BOOST_HASH_TEST_NAMESPACE::hash_value(T(-5)));
BOOST_TEST(x1(T(0)) == HASH_NAMESPACE::hash_value(T(0))); BOOST_TEST(x1(T(0)) == BOOST_HASH_TEST_NAMESPACE::hash_value(T(0)));
BOOST_TEST(x1(T(10)) == HASH_NAMESPACE::hash_value(T(10))); BOOST_TEST(x1(T(10)) == BOOST_HASH_TEST_NAMESPACE::hash_value(T(10)));
BOOST_TEST(x1(T(25)) == HASH_NAMESPACE::hash_value(T(25))); BOOST_TEST(x1(T(25)) == BOOST_HASH_TEST_NAMESPACE::hash_value(T(25)));
numeric_extra_tests<T>(); numeric_extra_tests<T>();
#endif #endif
@@ -91,8 +91,8 @@ void limits_test(T*)
if(limits::is_specialized) if(limits::is_specialized)
{ {
HASH_NAMESPACE::hash<T> x1; BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
HASH_NAMESPACE::hash<T> x2; BOOST_HASH_TEST_NAMESPACE::hash<T> x2;
T min_value = (limits::min)(); T min_value = (limits::min)();
T max_value = (limits::max)(); T max_value = (limits::max)();
@@ -100,15 +100,15 @@ void limits_test(T*)
BOOST_TEST(x1(min_value) == x2((limits::min)())); BOOST_TEST(x1(min_value) == x2((limits::min)()));
BOOST_TEST(x1(max_value) == x2((limits::max)())); BOOST_TEST(x1(max_value) == x2((limits::max)()));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(x1(min_value) == HASH_NAMESPACE::hash_value(min_value)); BOOST_TEST(x1(min_value) == BOOST_HASH_TEST_NAMESPACE::hash_value(min_value));
BOOST_TEST(x1(max_value) == HASH_NAMESPACE::hash_value(max_value)); BOOST_TEST(x1(max_value) == BOOST_HASH_TEST_NAMESPACE::hash_value(max_value));
if (limits::is_integer) if (limits::is_integer)
{ {
BOOST_TEST(HASH_NAMESPACE::hash_value(min_value) BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(min_value)
== std::size_t(min_value)); == std::size_t(min_value));
BOOST_TEST(HASH_NAMESPACE::hash_value(max_value) BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(max_value)
== std::size_t(max_value)); == std::size_t(max_value));
} }
#endif #endif
@@ -120,8 +120,8 @@ void poor_quality_tests(T*)
{ {
typedef boost::hash_detail::limits<T> limits; typedef boost::hash_detail::limits<T> limits;
HASH_NAMESPACE::hash<T> x1; BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
HASH_NAMESPACE::hash<T> x2; BOOST_HASH_TEST_NAMESPACE::hash<T> x2;
// A hash function can legally fail these tests, but it'll not be a good // A hash function can legally fail these tests, but it'll not be a good
// sign. // sign.
@@ -136,8 +136,8 @@ void poor_quality_tests(T*)
void bool_test() void bool_test()
{ {
HASH_NAMESPACE::hash<bool> x1; BOOST_HASH_TEST_NAMESPACE::hash<bool> x1;
HASH_NAMESPACE::hash<bool> x2; BOOST_HASH_TEST_NAMESPACE::hash<bool> x2;
BOOST_TEST(x1(true) == x2(true)); BOOST_TEST(x1(true) == x2(true));
BOOST_TEST(x1(false) == x2(false)); BOOST_TEST(x1(false) == x2(false));

12
hash/test/hash_pointer_test.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -20,8 +20,8 @@ void pointer_tests()
compile_time_tests((int**) 0); compile_time_tests((int**) 0);
compile_time_tests((void**) 0); compile_time_tests((void**) 0);
HASH_NAMESPACE::hash<int*> x1; BOOST_HASH_TEST_NAMESPACE::hash<int*> x1;
HASH_NAMESPACE::hash<int*> x2; BOOST_HASH_TEST_NAMESPACE::hash<int*> x2;
int int1; int int1;
int int2; int int2;
@@ -29,9 +29,9 @@ void pointer_tests()
BOOST_TEST(x1(0) == x2(0)); BOOST_TEST(x1(0) == x2(0));
BOOST_TEST(x1(&int1) == x2(&int1)); BOOST_TEST(x1(&int1) == x2(&int1));
BOOST_TEST(x1(&int2) == x2(&int2)); BOOST_TEST(x1(&int2) == x2(&int2));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(x1(&int1) == HASH_NAMESPACE::hash_value(&int1)); BOOST_TEST(x1(&int1) == BOOST_HASH_TEST_NAMESPACE::hash_value(&int1));
BOOST_TEST(x1(&int2) == HASH_NAMESPACE::hash_value(&int2)); BOOST_TEST(x1(&int2) == BOOST_HASH_TEST_NAMESPACE::hash_value(&int2));
// This isn't specified in Peter's proposal: // This isn't specified in Peter's proposal:
BOOST_TEST(x1(0) == 0); BOOST_TEST(x1(0) == 0);

50
hash/test/hash_range_test.cpp
View File

@@ -5,13 +5,13 @@
#include "./config.hpp" #include "./config.hpp"
#if !defined(TEST_EXTENSIONS) #if !defined(BOOST_HASH_TEST_EXTENSIONS)
int main() {} int main() {}
#else #else
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -40,39 +40,39 @@ void hash_range_tests()
std::vector<int> x; std::vector<int> x;
std::size_t x_seed = 0; std::size_t x_seed = 0;
BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end())); BOOST_TEST(x_seed == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end()) BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(empty.begin(), empty.end())
== HASH_NAMESPACE::hash_range(x.begin(), x.end())); == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end()) BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(empty.begin(), empty.end())
!= HASH_NAMESPACE::hash_range(values1.begin(), values1.end())); != BOOST_HASH_TEST_NAMESPACE::hash_range(values1.begin(), values1.end()));
x.push_back(10); x.push_back(10);
HASH_NAMESPACE::hash_combine(x_seed, 10); BOOST_HASH_TEST_NAMESPACE::hash_combine(x_seed, 10);
BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end())); BOOST_TEST(x_seed == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end()) BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(empty.begin(), empty.end())
!= HASH_NAMESPACE::hash_range(x.begin(), x.end())); != BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
BOOST_TEST(HASH_NAMESPACE::hash_range(values2.begin(), values2.end()) BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(values2.begin(), values2.end())
== HASH_NAMESPACE::hash_range(x.begin(), x.end())); == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
x.push_back(20); x.push_back(20);
HASH_NAMESPACE::hash_combine(x_seed, 20); BOOST_HASH_TEST_NAMESPACE::hash_combine(x_seed, 20);
BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end())); BOOST_TEST(x_seed == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end()) BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(empty.begin(), empty.end())
!= HASH_NAMESPACE::hash_range(x.begin(), x.end())); != BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
BOOST_TEST(HASH_NAMESPACE::hash_range(values2.begin(), values2.end()) BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(values2.begin(), values2.end())
!= HASH_NAMESPACE::hash_range(x.begin(), x.end())); != BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
BOOST_TEST(HASH_NAMESPACE::hash_range(values3.begin(), values3.end()) BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_range(values3.begin(), values3.end())
== HASH_NAMESPACE::hash_range(x.begin(), x.end())); == BOOST_HASH_TEST_NAMESPACE::hash_range(x.begin(), x.end()));
std::size_t seed = std::size_t seed =
HASH_NAMESPACE::hash_range(values3.begin(), values3.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(values3.begin(), values3.end());
HASH_NAMESPACE::hash_range(seed, values4.begin(), values4.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(seed, values4.begin(), values4.end());
HASH_NAMESPACE::hash_range(seed, x.begin(), x.end()); BOOST_HASH_TEST_NAMESPACE::hash_range(seed, x.begin(), x.end());
BOOST_TEST(seed == BOOST_TEST(seed ==
HASH_NAMESPACE::hash_range(values5.begin(), values5.end())); BOOST_HASH_TEST_NAMESPACE::hash_range(values5.begin(), values5.end()));
} }
int main() int main()

6
hash/test/hash_sequence_test.hpp
View File

@@ -38,16 +38,16 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
containers[10].push_back(-1); containers[10].push_back(-1);
containers[10].push_back(1); containers[10].push_back(1);
HASH_NAMESPACE::hash<T> hasher; BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
for(int i2 = 0; i2 < number_of_containers; ++i2) { for(int i2 = 0; i2 < number_of_containers; ++i2) {
BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2])); BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
BOOST_TEST(hasher(containers[i2]) == BOOST_TEST(hasher(containers[i2]) ==
HASH_NAMESPACE::hash_value(containers[i2])); BOOST_HASH_TEST_NAMESPACE::hash_value(containers[i2]));
BOOST_TEST(hasher(containers[i2]) BOOST_TEST(hasher(containers[i2])
== HASH_NAMESPACE::hash_range( == BOOST_HASH_TEST_NAMESPACE::hash_range(
containers[i2].begin(), containers[i2].end())); containers[i2].begin(), containers[i2].end()));
for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) { for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {

8
hash/test/hash_set_test.cpp
View File

@@ -5,8 +5,8 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -15,7 +15,7 @@
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
#include <set> #include <set>
@@ -31,7 +31,7 @@ using std::multiset;
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
set_tests::set_hash_integer_tests(); set_tests::set_hash_integer_tests();
multiset_tests::multiset_hash_integer_tests(); multiset_tests::multiset_hash_integer_tests();
#endif #endif

6
hash/test/hash_set_test.hpp
View File

@@ -41,16 +41,16 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
containers[11].insert(4); containers[11].insert(4);
containers[11].insert(5); containers[11].insert(5);
HASH_NAMESPACE::hash<T> hasher; BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
for(int i2 = 0; i2 < number_of_containers; ++i2) { for(int i2 = 0; i2 < number_of_containers; ++i2) {
BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2])); BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
BOOST_TEST(hasher(containers[i2]) == BOOST_TEST(hasher(containers[i2]) ==
HASH_NAMESPACE::hash_value(containers[i2])); BOOST_HASH_TEST_NAMESPACE::hash_value(containers[i2]));
BOOST_TEST(hasher(containers[i2]) BOOST_TEST(hasher(containers[i2])
== HASH_NAMESPACE::hash_range( == BOOST_HASH_TEST_NAMESPACE::hash_range(
containers[i2].begin(), containers[i2].end())); containers[i2].begin(), containers[i2].end()));
for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) { for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {

6
hash/test/hash_std_array_test.cpp
View File

@@ -5,8 +5,8 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -16,7 +16,7 @@
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#if defined(TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_ARRAY) #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_ARRAY)
#define TEST_ARRAY #define TEST_ARRAY
#include <array> #include <array>
#include <vector> #include <vector>

22
hash/test/hash_std_smart_ptr_test.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -14,7 +14,7 @@
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#include "./compile_time.hpp" #include "./compile_time.hpp"
#if defined(TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_SMART_PTR) #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_SMART_PTR)
#define TEST_SMART_PTRS #define TEST_SMART_PTRS
#include <memory> #include <memory>
#endif #endif
@@ -26,8 +26,8 @@ void shared_ptr_tests()
std::shared_ptr<int> x; std::shared_ptr<int> x;
compile_time_tests(&x); compile_time_tests(&x);
HASH_NAMESPACE::hash<std::shared_ptr<int> > x1; BOOST_HASH_TEST_NAMESPACE::hash<std::shared_ptr<int> > x1;
HASH_NAMESPACE::hash<std::shared_ptr<int> > x2; BOOST_HASH_TEST_NAMESPACE::hash<std::shared_ptr<int> > x2;
std::shared_ptr<int> ptr1(new int(10)); std::shared_ptr<int> ptr1(new int(10));
std::shared_ptr<int> ptr2; std::shared_ptr<int> ptr2;
@@ -39,9 +39,9 @@ void shared_ptr_tests()
BOOST_TEST(x1(ptr1) != x2(ptr2)); BOOST_TEST(x1(ptr1) != x2(ptr2));
ptr2 = ptr1; ptr2 = ptr1;
BOOST_TEST(x1(ptr1) == x2(ptr2)); BOOST_TEST(x1(ptr1) == x2(ptr2));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(x1(x) == HASH_NAMESPACE::hash_value(x)); BOOST_TEST(x1(x) == BOOST_HASH_TEST_NAMESPACE::hash_value(x));
BOOST_TEST(x1(ptr1) == HASH_NAMESPACE::hash_value(ptr2)); BOOST_TEST(x1(ptr1) == BOOST_HASH_TEST_NAMESPACE::hash_value(ptr2));
#endif #endif
} }
@@ -50,8 +50,8 @@ void unique_ptr_tests()
std::unique_ptr<int> x; std::unique_ptr<int> x;
compile_time_tests(&x); compile_time_tests(&x);
HASH_NAMESPACE::hash<std::unique_ptr<int> > x1; BOOST_HASH_TEST_NAMESPACE::hash<std::unique_ptr<int> > x1;
HASH_NAMESPACE::hash<std::unique_ptr<int> > x2; BOOST_HASH_TEST_NAMESPACE::hash<std::unique_ptr<int> > x2;
std::unique_ptr<int> ptr1(new int(10)); std::unique_ptr<int> ptr1(new int(10));
std::unique_ptr<int> ptr2; std::unique_ptr<int> ptr2;
@@ -62,8 +62,8 @@ void unique_ptr_tests()
BOOST_TEST(x1(ptr1) == x2(ptr1)); BOOST_TEST(x1(ptr1) == x2(ptr1));
BOOST_TEST(x1(ptr1) != x2(ptr2)); BOOST_TEST(x1(ptr1) != x2(ptr2));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
BOOST_TEST(x1(x) == HASH_NAMESPACE::hash_value(x)); BOOST_TEST(x1(x) == BOOST_HASH_TEST_NAMESPACE::hash_value(x));
#endif #endif
} }

6
hash/test/hash_std_tuple_test.cpp
View File

@@ -5,8 +5,8 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -16,7 +16,7 @@
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#if defined(TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_TUPLE) #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
#define TEST_TUPLE #define TEST_TUPLE
#include <tuple> #include <tuple>
#include <vector> #include <vector>

38
hash/test/hash_string_test.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -19,22 +19,22 @@ void string_tests()
{ {
compile_time_tests((std::string*) 0); compile_time_tests((std::string*) 0);
HASH_NAMESPACE::hash<std::string> x1; BOOST_HASH_TEST_NAMESPACE::hash<std::string> x1;
HASH_NAMESPACE::hash<std::string> x2; BOOST_HASH_TEST_NAMESPACE::hash<std::string> x2;
BOOST_TEST(x1("Hello") == x2(std::string("Hel") + "lo")); BOOST_TEST(x1("Hello") == x2(std::string("Hel") + "lo"));
BOOST_TEST(x1("") == x2(std::string())); BOOST_TEST(x1("") == x2(std::string()));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
std::string value1; std::string value1;
std::string value2("Hello"); std::string value2("Hello");
BOOST_TEST(x1(value1) == HASH_NAMESPACE::hash_value(value1)); BOOST_TEST(x1(value1) == BOOST_HASH_TEST_NAMESPACE::hash_value(value1));
BOOST_TEST(x1(value2) == HASH_NAMESPACE::hash_value(value2)); BOOST_TEST(x1(value2) == BOOST_HASH_TEST_NAMESPACE::hash_value(value2));
BOOST_TEST(HASH_NAMESPACE::hash_value(value1) == BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value1) ==
HASH_NAMESPACE::hash_range(value1.begin(), value1.end())); BOOST_HASH_TEST_NAMESPACE::hash_range(value1.begin(), value1.end()));
BOOST_TEST(HASH_NAMESPACE::hash_value(value2) == BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value2) ==
HASH_NAMESPACE::hash_range(value2.begin(), value2.end())); BOOST_HASH_TEST_NAMESPACE::hash_range(value2.begin(), value2.end()));
#endif #endif
} }
@@ -43,22 +43,22 @@ void wstring_tests()
{ {
compile_time_tests((std::wstring*) 0); compile_time_tests((std::wstring*) 0);
HASH_NAMESPACE::hash<std::wstring> x1; BOOST_HASH_TEST_NAMESPACE::hash<std::wstring> x1;
HASH_NAMESPACE::hash<std::wstring> x2; BOOST_HASH_TEST_NAMESPACE::hash<std::wstring> x2;
BOOST_TEST(x1(L"Hello") == x2(std::wstring(L"Hel") + L"lo")); BOOST_TEST(x1(L"Hello") == x2(std::wstring(L"Hel") + L"lo"));
BOOST_TEST(x1(L"") == x2(std::wstring())); BOOST_TEST(x1(L"") == x2(std::wstring()));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
std::wstring value1; std::wstring value1;
std::wstring value2(L"Hello"); std::wstring value2(L"Hello");
BOOST_TEST(x1(value1) == HASH_NAMESPACE::hash_value(value1)); BOOST_TEST(x1(value1) == BOOST_HASH_TEST_NAMESPACE::hash_value(value1));
BOOST_TEST(x1(value2) == HASH_NAMESPACE::hash_value(value2)); BOOST_TEST(x1(value2) == BOOST_HASH_TEST_NAMESPACE::hash_value(value2));
BOOST_TEST(HASH_NAMESPACE::hash_value(value1) == BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value1) ==
HASH_NAMESPACE::hash_range(value1.begin(), value1.end())); BOOST_HASH_TEST_NAMESPACE::hash_range(value1.begin(), value1.end()));
BOOST_TEST(HASH_NAMESPACE::hash_value(value2) == BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value2) ==
HASH_NAMESPACE::hash_range(value2.begin(), value2.end())); BOOST_HASH_TEST_NAMESPACE::hash_range(value2.begin(), value2.end()));
#endif #endif
} }
#endif #endif

10
hash/test/hash_type_index_test.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -18,7 +18,7 @@
#include <typeindex> #include <typeindex>
void test_type_index() { void test_type_index() {
HASH_NAMESPACE::hash<std::type_index> hasher; BOOST_HASH_TEST_NAMESPACE::hash<std::type_index> hasher;
#if defined(BOOST_NO_TYPEID) #if defined(BOOST_NO_TYPEID)
std::cout<<"Unable to test std::type_index, as typeid isn't available" std::cout<<"Unable to test std::type_index, as typeid isn't available"
@@ -31,9 +31,9 @@ void test_type_index() {
BOOST_TEST(hasher(int_index) == int_index.hash_code()); BOOST_TEST(hasher(int_index) == int_index.hash_code());
BOOST_TEST(hasher(int_index) == int2_index.hash_code()); BOOST_TEST(hasher(int_index) == int2_index.hash_code());
BOOST_TEST(hasher(char_index) == char_index.hash_code()); BOOST_TEST(hasher(char_index) == char_index.hash_code());
BOOST_TEST(HASH_NAMESPACE::hash_value(int_index) == int_index.hash_code()); BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(int_index) == int_index.hash_code());
BOOST_TEST(HASH_NAMESPACE::hash_value(int_index) == int2_index.hash_code()); BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(int_index) == int2_index.hash_code());
BOOST_TEST(HASH_NAMESPACE::hash_value(char_index) == char_index.hash_code()); BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(char_index) == char_index.hash_code());
BOOST_TEST(hasher(int_index) == hasher(int2_index)); BOOST_TEST(hasher(int_index) == hasher(int2_index));
BOOST_TEST(hasher(int_index) != hasher(char_index)); BOOST_TEST(hasher(int_index) != hasher(char_index));

24
hash/test/hash_value_array_test.cpp
View File

@@ -8,8 +8,8 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -18,7 +18,7 @@
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
void array_int_test() void array_int_test()
{ {
@@ -29,32 +29,32 @@ void array_int_test()
8, -12, 23, 65, 45, 8, -12, 23, 65, 45,
-1, 93, -54, 987, 3 -1, 93, -54, 987, 3
}; };
HASH_NAMESPACE::hash<int[25]> hasher1; BOOST_HASH_TEST_NAMESPACE::hash<int[25]> hasher1;
int array2[1] = {3}; int array2[1] = {3};
HASH_NAMESPACE::hash<int[1]> hasher2; BOOST_HASH_TEST_NAMESPACE::hash<int[1]> hasher2;
int array3[2] = {2, 3}; int array3[2] = {2, 3};
HASH_NAMESPACE::hash<int[2]> hasher3; BOOST_HASH_TEST_NAMESPACE::hash<int[2]> hasher3;
BOOST_TEST(hasher1(array1) == HASH_NAMESPACE::hash_value(array1)); BOOST_TEST(hasher1(array1) == BOOST_HASH_TEST_NAMESPACE::hash_value(array1));
BOOST_TEST(hasher2(array2) == HASH_NAMESPACE::hash_value(array2)); BOOST_TEST(hasher2(array2) == BOOST_HASH_TEST_NAMESPACE::hash_value(array2));
BOOST_TEST(hasher3(array3) == HASH_NAMESPACE::hash_value(array3)); BOOST_TEST(hasher3(array3) == BOOST_HASH_TEST_NAMESPACE::hash_value(array3));
} }
void two_dimensional_array_test() void two_dimensional_array_test()
{ {
int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}}; int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}};
HASH_NAMESPACE::hash<int[3][2]> hasher; BOOST_HASH_TEST_NAMESPACE::hash<int[3][2]> hasher;
BOOST_TEST(hasher(array) == HASH_NAMESPACE::hash_value(array)); BOOST_TEST(hasher(array) == BOOST_HASH_TEST_NAMESPACE::hash_value(array));
} }
#endif #endif
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
array_int_test(); array_int_test();
two_dimensional_array_test(); two_dimensional_array_test();
#endif #endif

10
hash/test/hash_vector_test.cpp
View File

@@ -5,8 +5,8 @@
#include "./config.hpp" #include "./config.hpp"
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
# ifdef TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/functional/hash.hpp>
@@ -15,7 +15,7 @@
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
#include <vector> #include <vector>
@@ -23,11 +23,11 @@ using std::vector;
#define CONTAINER_TYPE vector #define CONTAINER_TYPE vector
#include "./hash_sequence_test.hpp" #include "./hash_sequence_test.hpp"
#endif // TEST_EXTENSIONS #endif // BOOST_HASH_TEST_EXTENSIONS
int main() int main()
{ {
#ifdef TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS
vector_tests::vector_hash_integer_tests(); vector_tests::vector_hash_integer_tests();
#endif #endif

12
hash/test/link_ext_test.cpp
View File

@@ -5,24 +5,24 @@
#include "./config.hpp" #include "./config.hpp"
#define HASH_NAMESPACE boost #define BOOST_HASH_TEST_NAMESPACE boost
#include <boost/functional/hash.hpp> #include <boost/functional/hash.hpp>
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#include <vector> #include <vector>
int f(std::size_t hash1, int* x1) { int f(std::size_t hash1, int* x1) {
// Check that HASH_NAMESPACE::hash<int*> works in both files. // Check that BOOST_HASH_TEST_NAMESPACE::hash<int*> works in both files.
HASH_NAMESPACE::hash<int*> ptr_hasher; BOOST_HASH_TEST_NAMESPACE::hash<int*> ptr_hasher;
BOOST_TEST(hash1 == ptr_hasher(x1)); BOOST_TEST(hash1 == ptr_hasher(x1));
#if defined(TEST_EXTENSIONS) #if defined(BOOST_HASH_TEST_EXTENSIONS)
// Check that std::vector<std::size_t> is avaiable in this file. // Check that std::vector<std::size_t> is avaiable in this file.
std::vector<std::size_t> x; std::vector<std::size_t> x;
x.push_back(*x1); x.push_back(*x1);
HASH_NAMESPACE::hash<std::vector<std::size_t> > vector_hasher; BOOST_HASH_TEST_NAMESPACE::hash<std::vector<std::size_t> > vector_hasher;
return vector_hasher(x) != HASH_NAMESPACE::hash_value(x); return vector_hasher(x) != BOOST_HASH_TEST_NAMESPACE::hash_value(x);
#else #else

4
hash/test/link_no_ext_test.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#define HASH_NAMESPACE boost #define BOOST_HASH_TEST_NAMESPACE boost
#define BOOST_HASH_NO_EXTENSIONS #define BOOST_HASH_NO_EXTENSIONS
#include <boost/functional/hash.hpp> #include <boost/functional/hash.hpp>
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
@@ -13,7 +13,7 @@
extern int f(std::size_t, int*); extern int f(std::size_t, int*);
int main() { int main() {
HASH_NAMESPACE::hash<int*> ptr_hasher; BOOST_HASH_TEST_NAMESPACE::hash<int*> ptr_hasher;
int x = 55; int x = 55;
BOOST_TEST(!f(ptr_hasher(&x), &x)); BOOST_TEST(!f(ptr_hasher(&x), &x));
return boost::report_errors(); return boost::report_errors();