145 lines
4.7 KiB
C++
145 lines
4.7 KiB
C++
// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
|
|
//
|
|
// 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)
|
|
//
|
|
|
|
|
|
//
|
|
// NOTE: This file is intended to be used ONLY by the test files
|
|
// from the Numeric Conversions Library
|
|
//
|
|
|
|
// The conversion test is performed using a class whose instances encapsulate
|
|
// a particular specific conversion defnied explicitely.
|
|
// A ConversionInstance object includes the source type, the target type,
|
|
// the source value and the expected result, including possible exceptions.
|
|
//
|
|
|
|
enum PostCondition { c_converted, c_overflow, c_neg_overflow, c_pos_overflow } ;
|
|
|
|
template<class Converter>
|
|
struct ConversionInstance
|
|
{
|
|
typedef Converter converter ;
|
|
|
|
typedef typename Converter::argument_type argument_type ;
|
|
typedef typename Converter::result_type result_type ;
|
|
|
|
typedef typename Converter::traits traits ;
|
|
typedef typename traits::target_type target_type ;
|
|
typedef typename traits::source_type source_type ;
|
|
|
|
ConversionInstance ( result_type a_result, argument_type a_source, PostCondition a_post)
|
|
:
|
|
source(a_source),
|
|
result(a_result),
|
|
post(a_post)
|
|
{}
|
|
|
|
std::string to_string() const
|
|
{
|
|
return std::string("converter<")
|
|
+ typeid(target_type).name()
|
|
+ std::string(",")
|
|
+ typeid(source_type).name()
|
|
+ std::string(">::convert(") ;
|
|
}
|
|
|
|
argument_type source ;
|
|
result_type result ;
|
|
PostCondition post ;
|
|
} ;
|
|
|
|
//
|
|
// Main conversion test point.
|
|
// Exercises a specific conversion described by 'conv'.
|
|
//
|
|
template<class Instance>
|
|
void test_conv_base( Instance const& conv )
|
|
{
|
|
typedef typename Instance::argument_type argument_type ;
|
|
typedef typename Instance::result_type result_type ;
|
|
typedef typename Instance::converter converter ;
|
|
|
|
argument_type source = conv.source ;
|
|
|
|
try
|
|
{
|
|
result_type result = converter::convert(source);
|
|
|
|
if ( conv.post == c_converted )
|
|
{
|
|
BOOST_CHECK_MESSAGE( result == conv.result,
|
|
conv.to_string() << printable(source) << ")= " << printable(result) << ". Expected:" << printable(conv.result)
|
|
) ;
|
|
}
|
|
else
|
|
{
|
|
BOOST_ERROR( conv.to_string() << printable(source) << ") = " << printable(result)
|
|
<< ". Expected:" << ( conv.post == c_neg_overflow ? " negative_overflow" : "positive_overflow" )
|
|
) ;
|
|
}
|
|
}
|
|
catch ( boost::numeric::negative_overflow const& )
|
|
{
|
|
if ( conv.post == c_neg_overflow )
|
|
{
|
|
BOOST_CHECK_MESSAGE( true, conv.to_string() << printable(source) << ") = negative_overflow, as expected" ) ;
|
|
}
|
|
else
|
|
{
|
|
BOOST_ERROR( conv.to_string() << printable(source) << ") = negative_overflow. Expected:" << printable(conv.result) ) ;
|
|
}
|
|
}
|
|
catch ( boost::numeric::positive_overflow const& )
|
|
{
|
|
if ( conv.post == c_pos_overflow )
|
|
{
|
|
BOOST_CHECK_MESSAGE( true, conv.to_string() << printable(source) << ") = positive_overflow, as expected" ) ;
|
|
}
|
|
else
|
|
{
|
|
BOOST_ERROR( conv.to_string() << printable(source) << ") = positive_overflow. Expected:" << printable(conv.result) ) ;
|
|
}
|
|
}
|
|
catch ( boost::numeric::bad_numeric_cast const& )
|
|
{
|
|
if ( conv.post == c_overflow )
|
|
{
|
|
BOOST_CHECK_MESSAGE( true, conv.to_string() << printable(source) << ") = bad_numeric_cast, as expected" ) ;
|
|
}
|
|
else
|
|
{
|
|
BOOST_ERROR( conv.to_string() << printable(source) << ") = bad_numeric_cast. Expected:" << printable(conv.result) ) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#define TEST_SUCCEEDING_CONVERSION(Conv,typeT,typeS,valueT,valueS) \
|
|
test_conv_base( ConversionInstance< Conv >(valueT, valueS, c_converted ) )
|
|
|
|
#define TEST_POS_OVERFLOW_CONVERSION(Conv,typeT,typeS,valueS) \
|
|
test_conv_base( ConversionInstance< Conv >( static_cast< typeT >(0), valueS, c_pos_overflow ) )
|
|
|
|
#define TEST_NEG_OVERFLOW_CONVERSION(Conv,typeT,typeS,valueS) \
|
|
test_conv_base( ConversionInstance< Conv >( static_cast< typeT >(0), valueS, c_neg_overflow ) )
|
|
|
|
#define DEF_CONVERTER(T,S) boost::numeric::converter< T , S >
|
|
|
|
#define TEST_SUCCEEDING_CONVERSION_DEF(typeT,typeS,valueT,valueS) \
|
|
TEST_SUCCEEDING_CONVERSION( DEF_CONVERTER(typeT,typeS), typeT, typeS, valueT, valueS )
|
|
|
|
#define TEST_POS_OVERFLOW_CONVERSION_DEF(typeT,typeS,valueS) \
|
|
TEST_POS_OVERFLOW_CONVERSION( DEF_CONVERTER(typeT,typeS), typeT, typeS, valueS )
|
|
|
|
#define TEST_NEG_OVERFLOW_CONVERSION_DEF(typeT,typeS,valueS) \
|
|
TEST_NEG_OVERFLOW_CONVERSION( DEF_CONVERTER(typeT,typeS), typeT, typeS, valueS )
|
|
|
|
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|