truncation_test_unittest_.h

新版本TR1的stl

// Updated: 14th January 2007

#if !defined(STLSOFT_INCL_STLSOFT_CONVERSION_HPP_TRUNCATION_TEST)
# error This file cannot be directly included, and should only be included within stlsoft/conversion/truncation_test.hpp
#endif /* !STLSOFT_INCL_STLSOFT_CONVERSION_HPP_TRUNCATION_TEST */

#if !defined(STLSOFT_UNITTEST)
# error This file cannot be included when not unit-testing STLSoft
#endif /* !STLSOFT_UNITTEST */

#if !defined(STLSOFT_COMPILER_IS_BORLAND)	// Borland has an ICE with the amount of tests here.

namespace unittest
{
	namespace
	{
#if defined(STLSOFT_COMPILER_IS_BORLAND)
# define STLSOFT_CONV_TRUNCATION_TEST_CASE(fromType, toType, fromValue) stlsoft_ns_qual(truncation_test)<toType>(static_cast<fromType>(fromValue))
#elif defined(STLSOFT_COMPILER_IS_MSVC) && \
      _MSC_VER < 1200
# define STLSOFT_CONV_TRUNCATION_TEST_CASE(fromType, toType, fromValue) stlsoft_ns_qual(truncation_test)<toType>(static_cast<fromType>(fromValue), toType())
#else /* ? compiler */
# define STLSOFT_CONV_TRUNCATION_TEST_CASE(fromType, toType, fromValue) stlsoft_ns_qual(truncation_test)<toType, fromType>(static_cast<fromType>(fromValue))
#endif /* compiler */

		// To:		char
		//
		// From:
		//			char
		//
		//			unsigned char
		//			signed char
		//			unsigned long
		//			signed long

		ss_bool_t test_stlsoft_conversion_truncation_test_to_char(unittest_reporter *r)
		{
			ss_bool_t				bSuccess	=	true;

			// char => char

			{ for(char i = CHAR_MIN; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(char, char, i))
				{
					r->report("truncation_test<char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(CHAR_MAX == i)
				{
					break;
				}
			}}

			// unsigned char => char

			{ for(unsigned char i = 0; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned char, char, i))
				{
					r->report("truncation_test<char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(CHAR_MAX == i)
				{
					break;
				}
			}}
#ifdef STLSOFT_CF_CHAR_IS_UNSIGNED
			if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned char, char, UCHAR_MAX))
#else /* ? STLSOFT_CF_CHAR_IS_UNSIGNED */
			if(STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned char, char, UCHAR_MAX))
#endif /* STLSOFT_CF_CHAR_IS_UNSIGNED */
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}

			// signed long => char

			{ for(signed long i = CHAR_MIN; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(signed long, char, i))
				{
					r->report("truncation_test<char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(CHAR_MAX == i)
				{
					break;
				}
			}}
			if( STLSOFT_CONV_TRUNCATION_TEST_CASE(signed long, char, CHAR_MIN - 1) ||
				STLSOFT_CONV_TRUNCATION_TEST_CASE(signed long, char, CHAR_MAX + 1))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}

			// unsigned long => char

			{ for(unsigned long i = 0; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned long, char, i))
				{
					r->report("truncation_test<char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(CHAR_MAX == i)
				{
					break;
				}
			}}
			if(STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned long, signed char, CHAR_MAX + 1))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}

			return bSuccess;
		}

		// To:		signed char
		//
		// From:
		//			unsigned char
		//
		//			unsigned char
		//			signed short
		//			unsigned short
		//			signed int
		//			signed long
		//			signed long long

		ss_bool_t test_stlsoft_conversion_truncation_test_to_signed_char(unittest_reporter *r)
		{
			ss_bool_t				bSuccess	=	true;

			// signed char => signed char

			{ for(signed char i = SCHAR_MIN; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(signed char, signed char, i))
				{
					r->report("truncation_test<signed char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(SCHAR_MAX == i)
				{
					break;
				}
			}}

			// unsigned char => signed char

			{ for(unsigned char i = 0; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned char, signed char, i))
				{
					r->report("truncation_test<signed char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(SCHAR_MAX == i)
				{
					break;
				}
			}}
			if( STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned short, signed char, SCHAR_MAX + 1) ||
				STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned short, signed char, UCHAR_MAX))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}

			// signed short => signed char

			{ for(signed short i = SCHAR_MIN; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(signed short, signed char, i))
				{
					r->report("truncation_test<signed char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(SCHAR_MAX == i)
				{
					break;
				}
			}}
			if( STLSOFT_CONV_TRUNCATION_TEST_CASE(signed short, signed char, SCHAR_MIN - 1) ||
				STLSOFT_CONV_TRUNCATION_TEST_CASE(signed short, signed char, SCHAR_MAX + 1))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}
			if( STLSOFT_CONV_TRUNCATION_TEST_CASE(signed short, signed char, SHRT_MIN) ||
				STLSOFT_CONV_TRUNCATION_TEST_CASE(signed short, signed char, SHRT_MAX))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}

			// unsigned short => signed char

			{ for(unsigned short i = 0; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned short, signed char, i))
				{
					r->report("truncation_test<signed char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(SCHAR_MAX == i)
				{
					break;
				}
			}}
			if(STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned short, signed char, SCHAR_MAX + 1))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}
			if(STLSOFT_CONV_TRUNCATION_TEST_CASE(unsigned short, signed char, SHRT_MAX))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}

			// signed int => signed char

			{ for(signed int i = SCHAR_MIN; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(signed int, signed char, i))
				{
					r->report("truncation_test<signed char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(SCHAR_MAX == i)
				{
					break;
				}
			}}
			if( STLSOFT_CONV_TRUNCATION_TEST_CASE(signed int, signed char, SCHAR_MIN - 1) ||
				STLSOFT_CONV_TRUNCATION_TEST_CASE(signed int, signed char, SCHAR_MAX + 1))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}
			if( STLSOFT_CONV_TRUNCATION_TEST_CASE(signed int, signed char, INT_MIN) ||
				STLSOFT_CONV_TRUNCATION_TEST_CASE(signed int, signed char, INT_MAX))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}

			// signed long => signed char

			{ for(signed long i = SCHAR_MIN; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(signed long, signed char, i))
				{
					r->report("truncation_test<signed char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(SCHAR_MAX == i)
				{
					break;
				}
			}}
			if( STLSOFT_CONV_TRUNCATION_TEST_CASE(signed long, signed char, SCHAR_MIN - 1) ||
				STLSOFT_CONV_TRUNCATION_TEST_CASE(signed long, signed char, SCHAR_MAX + 1))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}
			if( STLSOFT_CONV_TRUNCATION_TEST_CASE(signed long, signed char, LONG_MIN) ||
				STLSOFT_CONV_TRUNCATION_TEST_CASE(signed long, signed char, LONG_MAX))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}

			// signed ss_sint64_t => signed char

			{ for(ss_sint64_t i = SCHAR_MIN; ; ++i)
			{
				if(!STLSOFT_CONV_TRUNCATION_TEST_CASE(ss_sint64_t, signed char, i))
				{
					r->report("truncation_test<signed char>() failed ", __LINE__);
					bSuccess = false;
				}

				if(SCHAR_MAX == i)
				{
					break;
				}
			}}
			if( STLSOFT_CONV_TRUNCATION_TEST_CASE(ss_sint64_t, signed char, SCHAR_MIN - 1) ||
				STLSOFT_CONV_TRUNCATION_TEST_CASE(ss_sint64_t, signed char, SCHAR_MAX + 1))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}
			if( STLSOFT_CONV_TRUNCATION_TEST_CASE(signed long, signed char, LONG_MIN) ||
				STLSOFT_CONV_TRUNCATION_TEST_CASE(signed long, signed char, LONG_MAX))
			{
				r->report("truncation_test<signed char>() failed ", __LINE__);
				bSuccess = false;
			}