libs/lexical_cast/test/lexical_cast_no_locale_test.cpp

   1 //  Unit test for boost::lexical_cast.
   2 //
   3 //  See http://www.boost.org for most recent version, including documentation.
   4 //
   5 //  Copyright Antony Polukhin, 2012.
   6 //
   7 //  Distributed under the Boost
   8 //  Software License, Version 1.0. (See accompanying file
   9 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
  10
  11 #include <boost/config.hpp>
  12
  13 #if defined(__INTEL_COMPILER)
  14 #pragma warning(disable: 193 383 488 981 1418 1419)
  15 #elif defined(BOOST_MSVC)
  16 #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
  17 #endif
  18
  19 #include <boost/lexical_cast.hpp>
  20 #include <boost/test/unit_test.hpp>
  21 #include <boost/range/iterator_range.hpp>
  22
  23 using namespace boost;
  24
  25 // Testing compilation and some basic usage with BOOST_NO_STD_LOCALE
  26 // Tests are mainly copyied from lexical_cast_empty_input_test.cpp (something
  27 // new added to test_empty_3)
  28
  29 #ifndef BOOST_NO_STD_LOCALE
  30 #error "This test must be compiled with -DBOOST_NO_STD_LOCALE"
  31 #endif
  32
  33
  34 template <class T>
  35 void do_test_on_empty_input(T& v)
  36 {
  37     BOOST_CHECK_THROW(lexical_cast<int>(v), bad_lexical_cast);
  38     BOOST_CHECK_THROW(lexical_cast<float>(v), bad_lexical_cast);
  39     BOOST_CHECK_THROW(lexical_cast<double>(v), bad_lexical_cast);
  40 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
  41     BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
  42 #endif
  43     BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
  44     BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
  45 #if defined(BOOST_HAS_LONG_LONG)
  46     BOOST_CHECK_THROW(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
  47     BOOST_CHECK_THROW(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
  48 #elif defined(BOOST_HAS_MS_INT64)
  49     BOOST_CHECK_THROW(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
  50     BOOST_CHECK_THROW(lexical_cast<__int64>(v), bad_lexical_cast);
  51 #endif
  52 }
  53
  54 void test_empty_1()
  55 {
  56     boost::iterator_range<char*> v;
  57     do_test_on_empty_input(v);
  58     BOOST_CHECK_EQUAL(lexical_cast<std::string>(v), std::string());
  59     BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
  60     BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
  61     BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
  62
  63     boost::iterator_range<const char*> cv;
  64     do_test_on_empty_input(cv);
  65     BOOST_CHECK_EQUAL(lexical_cast<std::string>(cv), std::string());
  66     BOOST_CHECK_THROW(lexical_cast<char>(cv), bad_lexical_cast);
  67     BOOST_CHECK_THROW(lexical_cast<unsigned char>(cv), bad_lexical_cast);
  68     BOOST_CHECK_THROW(lexical_cast<signed char>(cv), bad_lexical_cast);
  69
  70     const boost::iterator_range<const char*> ccv;
  71     do_test_on_empty_input(ccv);
  72     BOOST_CHECK_EQUAL(lexical_cast<std::string>(ccv), std::string());
  73     BOOST_CHECK_THROW(lexical_cast<char>(ccv), bad_lexical_cast);
  74     BOOST_CHECK_THROW(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
  75     BOOST_CHECK_THROW(lexical_cast<signed char>(ccv), bad_lexical_cast);
  76 }
  77
  78 void test_empty_2()
  79 {
  80     std::string v;
  81     do_test_on_empty_input(v);
  82     BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
  83     BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
  84     BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
  85 }
  86
  87 struct Escape
  88 {
  89     Escape(){}
  90     Escape(const std::string& s)
  91         : str_(s)
  92     {}
  93
  94     std::string str_;
  95 };
  96
  97 inline std::ostream& operator<< (std::ostream& o, const Escape& rhs)
  98 {
  99     return o << rhs.str_;
 100 }
 101
 102 inline std::istream& operator>> (std::istream& i, Escape& rhs)
 103 {
 104     return i >> rhs.str_;
 105 }
 106
 107 void test_empty_3()
 108 {
 109     Escape v("");
 110     do_test_on_empty_input(v);
 111
 112     BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
 113     BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
 114     BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
 115
 116     v = lexical_cast<Escape>(100);
 117     BOOST_CHECK_EQUAL(lexical_cast<int>(v), 100);
 118     BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(v), 100u);
 119
 120     v = lexical_cast<Escape>(0.0);
 121     BOOST_CHECK_EQUAL(lexical_cast<double>(v), 0.0);
 122 }
 123
 124 namespace std {
 125 inline std::ostream & operator<<(std::ostream & out, const std::vector<long> & v)
 126 {
 127     std::ostream_iterator<long> it(out);
 128     std::copy(v.begin(), v.end(), it);
 129     assert(out);
 130     return out;
 131 }
 132 }
 133
 134 void test_empty_4()
 135 {
 136     std::vector<long> v;
 137     do_test_on_empty_input(v);
 138     BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
 139     BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
 140     BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
 141 }
 142
 143
 144 struct my_string {
 145     friend std::ostream &operator<<(std::ostream& sout, my_string const&/* st*/) {
 146             return sout << "";
 147     }
 148 };
 149
 150 void test_empty_5()
 151 {
 152     my_string st;
 153     BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(st), std::string());;
 154 }
 155
 156 unit_test::test_suite *init_unit_test_suite(int, char *[])
 157 {
 158     unit_test::test_suite *suite =
 159         BOOST_TEST_SUITE("lexical_cast. Testing with BOOST_NO_STD_LOCALE");
 160     suite->add(BOOST_TEST_CASE(&test_empty_1));
 161     suite->add(BOOST_TEST_CASE(&test_empty_2));
 162     suite->add(BOOST_TEST_CASE(&test_empty_3));
 163     suite->add(BOOST_TEST_CASE(&test_empty_4));
 164     suite->add(BOOST_TEST_CASE(&test_empty_5));
 165
 166     return suite;
 167 }
 168