feedc0de/boost_conversion
1
0
Fork 0
forked from boostorg/conversion
Code Pull Requests Activity

Separate test for round-tripping of floating point types.

Browse Source 
[SVN r35771]
This commit is contained in:
Alexander Nasonov
2006-10-28 19:33:32 +00:00
parent c004fb5fc6
commit 67968d9b33
4 changed files with 102 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
lexical_cast_test.cpp
View File

@@ -67,9 +67,6 @@ void test_conversion_from_ulong();
void test_conversion_from_longlong();
void test_conversion_from_ulonglong();
#endif
void test_round_conversion_float();
void test_round_conversion_double();
void test_round_conversion_long_double();
unit_test::test_suite *init_unit_test_suite(int, char *[])
{
@@ -100,9 +97,6 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
suite->add(BOOST_TEST_CASE(&test_conversion_from_longlong));
suite->add(BOOST_TEST_CASE(&test_conversion_from_ulonglong));
#endif
suite->add(BOOST_TEST_CASE(&test_round_conversion_float));
suite->add(BOOST_TEST_CASE(&test_round_conversion_double));
suite->add(BOOST_TEST_CASE(&test_round_conversion_long_double));
return suite;
}
@@ -612,51 +606,3 @@ void test_conversion_from_ulonglong()
#endif
template<class T>
void test_round_conversion(bool use_min_max_values = true)
{
T v1 = std::numeric_limits<T>::epsilon();
std::string s1 = boost::lexical_cast<std::string>(v1);
BOOST_CHECK(v1 == lexical_cast<T>(s1));
if(use_min_max_values)
{
T v2 = (std::numeric_limits<T>::max)();
std::string s2 = boost::lexical_cast<std::string>(v2);
BOOST_CHECK(v2 == lexical_cast<T>(s2));
T v3 = (std::numeric_limits<T>::min)();
std::string s3 = boost::lexical_cast<std::string>(v3);
BOOST_CHECK(v3 == lexical_cast<T>(s3));
T v4 = v2 / 137;
std::string s4 = boost::lexical_cast<std::string>(v4);
BOOST_CHECK(v4 == lexical_cast<T>(s4));
}
T v5 = v1 * 137;
std::string s5 = boost::lexical_cast<std::string>(v5);
BOOST_CHECK(v5 == lexical_cast<T>(s5));
}
void test_round_conversion_float()
{
test_round_conversion<float>();
}
void test_round_conversion_double()
{
test_round_conversion<double>();
}
void test_round_conversion_long_double()
{
#if defined(BOOST_NO_STDLIB_CONFIG)
test_round_conversion<long double>();
#elif defined(__i386__) && defined(__OpenBSD__)
test_round_conversion<long double>(false);
#elif !defined(__i386__) || !defined(__FreeBSD__)
test_round_conversion<long double>();
#endif
}

3
test/Jamfile
View File

@@ -27,8 +27,9 @@ DEPENDS all : test ;
: [ run implicit_cast.cpp ]
[ compile-fail implicit_cast_fail.cpp ]
[ run ../cast_test.cpp ]
[ run ../numeric_cast_test.cpp ]
[ run ../numeric_cast_test.cpp ]
[ run ../lexical_cast_test.cpp <lib>../../test/build/boost_unit_test_framework ]
[ run lexical_cast_loopback_test.cpp <lib>../../test/build/boost_unit_test_framework ]
;
}

3
test/Jamfile.v2
View File

@@ -21,6 +21,7 @@ test-suite conversion
[ run ../cast_test.cpp ]
[ run ../numeric_cast_test.cpp ]
[ run ../lexical_cast_test.cpp ../../test/build//boost_unit_test_framework ]
[ run lexical_cast_loopback_test.cpp ../../test/build//boost_unit_test_framework ]
;

98
test/lexical_cast_loopback_test.cpp Normal file
View File

@@ -0,0 +1,98 @@
// Unit test for boost::lexical_cast.
//
// See http://www.boost.org for most recent version, including documentation.
//
// Copyright Alexander Nasonov, 2006.
//
// 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).
//
// Test round-tripping conversion FPT -> string -> FPT,
// where FPT is Floating Point Type.
#include <boost/config.hpp>
#if defined(__INTEL_COMPILER)
#pragma warning(disable: 193 383 488 981 1418 1419)
#elif defined(BOOST_MSVC)
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
#endif
#include <boost/lexical_cast.hpp>
#include <boost/test/unit_test.hpp>
using namespace boost;
void test_round_conversion_float();
void test_round_conversion_double();
void test_round_conversion_long_double();
unit_test::test_suite *init_unit_test_suite(int, char *[])
{
unit_test_framework::test_suite *suite =
BOOST_TEST_SUITE("lexical_cast unit test");
suite->add(BOOST_TEST_CASE(&test_round_conversion_float));
suite->add(BOOST_TEST_CASE(&test_round_conversion_double));
suite->add(BOOST_TEST_CASE(&test_round_conversion_long_double));
return suite;
}
template<class T>
void test_round_conversion()
{
T epsilon = std::numeric_limits<T>::epsilon();
std::string const epsilon_s = boost::lexical_cast<std::string>(epsilon);
BOOST_CHECK(epsilon == lexical_cast<T>(epsilon_s));
T max_ = (std::numeric_limits<T>::max)();
std::string const max_s = boost::lexical_cast<std::string>(max_);
BOOST_CHECK(max_ == lexical_cast<T>(max_s));
T min_ = (std::numeric_limits<T>::min)();
std::string const min_s = boost::lexical_cast<std::string>(min_);
BOOST_CHECK(min_ == lexical_cast<T>(min_s));
T max_div137 = max_ / 137;
std::string max_div137_s = boost::lexical_cast<std::string>(max_div137);
BOOST_CHECK(max_div137 == lexical_cast<T>(max_div137_s));
T epsilon_mult137 = epsilon * 137;
std::string epsilon_mult137_s(lexical_cast<std::string>(epsilon_mult137));
BOOST_CHECK(epsilon_mult137 == lexical_cast<T>(epsilon_mult137_s));
}
#if defined(BOOST_MSVC)
// See bug http://tinyurl.com/vhpvo
template<class T>
void test_msvc_magic_values()
{
T magic_msvc = 0.00010000433948393407;
std::string magic_msvc_s = boost::lexical_cast<std::string>(magic_msvc);
BOOST_CHECK(magic_msvc == lexical_cast<T>(magic_msvc_s));
}
#endif
void test_round_conversion_float()
{
test_round_conversion<float>();
}
void test_round_conversion_double()
{
test_round_conversion<double>();
#if defined(BOOST_MSVC)
test_msvc_magic_values<double>();
#endif
}
void test_round_conversion_long_double()
{
test_round_conversion<long double>();
#if defined(BOOST_MSVC)
test_msvc_magic_values<long double>();
#endif
}