diff --git a/doc/lexical_cast.qbk b/doc/lexical_cast.qbk
index 4715803..4ad8336 100644
--- a/doc/lexical_cast.qbk
+++ b/doc/lexical_cast.qbk
@@ -3,7 +3,7 @@
     [version 1.0]
     [copyright 2000-2005 Kevlin Henney]
     [copyright 2006-2010 Alexander Nasonov]
-    [copyright 2011 Antony Polukhin]
+    [copyright 2011-2012 Antony Polukhin]
     [category String and text processing]
     [category Miscellaneous]
     [license
@@ -167,9 +167,22 @@ if a negative number is read, no errors will arise and the result will be the tw
 `boost::lexical_cast` sees single `wchar_t` character as `unsigned short`. It is not a `boost::lexical_cast` mistake, but a 
 limitation of compiler options that you use.
 
+[pre
+]
+
+* [*Question:]    Why `boost::lexical_cast<double>("-1.#IND");` throws `boost::bad_lexical_cast`?
+  * [*Answer:]      `"-1.#IND"` is a compiler extension, that violates standard. You shall input `"-nan"`, `"nan"`, `"inf"`
+, `"-inf"` (case insensitive) strings to get NaN and Inf values. `boost::lexical_cast<string>` outputs `"-nan"`, `"nan"`, 
+`"inf"`, `"-inf"` strings, when has NaN or Inf input values.
+
 [endsect]
 
 [section Changes]
+* [*boost 1.50.0 :]
+  
+    * `boost::bad_lexical_cast` exception is now globaly visible and can be catched even if code is compiled with -fvisibility=hidden.
+    * Now it is possible to compile library with disabled exceptions.
+    
 * [*boost 1.49.0 :]
   
     * Restored work with typedefed wchar_t (compilation flag /Zc:wchar_t- for Visual Studio). 
diff --git a/include/boost/lexical_cast.hpp b/include/boost/lexical_cast.hpp
index cd7d512..b73c741 100644
--- a/include/boost/lexical_cast.hpp
+++ b/include/boost/lexical_cast.hpp
@@ -72,7 +72,9 @@ _CRTIMP int __cdecl vswprintf(wchar_t * __restrict__ , const wchar_t * __restric
 #include <boost/static_assert.hpp>
 #include <boost/detail/lcast_precision.hpp>
 #include <boost/detail/workaround.hpp>
+#if !defined(__SUNPRO_CC)
 #include <boost/container/container_fwd.hpp>
+#endif // !defined(__SUNPRO_CC)
 #ifndef BOOST_NO_CWCHAR
 #   include <cwchar>
 #endif
@@ -102,7 +104,7 @@ _CRTIMP int __cdecl vswprintf(wchar_t * __restrict__ , const wchar_t * __restric
 namespace boost
 {
     // exception used to indicate runtime lexical_cast failure
-    class bad_lexical_cast :
+    class BOOST_SYMBOL_VISIBLE bad_lexical_cast :
     // workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0 
 #if defined(BOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS 
         public std::exception 
@@ -170,11 +172,13 @@ namespace boost
         typedef CharT type;
     };
 
+#if !defined(__SUNPRO_CC)
     template<class CharT, class Traits, class Alloc>
     struct stream_char< ::boost::container::basic_string<CharT,Traits,Alloc> >
     {
         typedef CharT type;
     };
+#endif // !defined(__SUNPRO_CC)
 #endif
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
@@ -289,6 +293,7 @@ namespace boost
             typedef Traits type;
         };
 
+#if !defined(__SUNPRO_CC)
         template<class CharT, class Traits, class Alloc, class Source>
         struct deduce_char_traits< CharT
                                  , ::boost::container::basic_string<CharT,Traits,Alloc>
@@ -324,6 +329,25 @@ namespace boost
         {
             typedef Traits type;
         };
+
+        template<class CharT, class Traits, class Alloc1, class Alloc2>
+        struct deduce_char_traits< CharT
+                                 , ::boost::container::basic_string<CharT,Traits,Alloc1>
+                                 , std::basic_string<CharT,Traits,Alloc2>
+                                 >
+        {
+            typedef Traits type;
+        };
+
+        template<class CharT, class Traits, class Alloc1, class Alloc2>
+        struct deduce_char_traits< CharT
+                                 , std::basic_string<CharT,Traits,Alloc1>
+                                 , ::boost::container::basic_string<CharT,Traits,Alloc2>
+                                 >
+        {
+            typedef Traits type;
+        };
+#endif // !defined(__SUNPRO_CC)
 #endif
     }
 
@@ -708,6 +732,15 @@ namespace boost
 
     namespace detail
     {
+        template <class CharT>
+        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) {
+            for( unsigned int i=0; i < len; ++i ) {
+                if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
+            }
+
+            return true;
+        }
+
         /* Returns true and sets the correct value if found NaN or Inf. */
         template <class CharT, class T>
         inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
@@ -731,7 +764,7 @@ namespace boost
             else if( *begin == plus ) ++begin;
 
             if( end-begin < 3 ) return false;
-            if( !memcmp(begin, lc_nan, 3*sizeof(CharT)) || !memcmp(begin, lc_NAN, 3*sizeof(CharT)) )
+            if( lc_iequal(begin, lc_nan, lc_NAN, 3) )
             {
                 begin += 3;
                 if (end != begin) /* It is 'nan(...)' or some bad input*/
@@ -748,13 +781,13 @@ namespace boost
             if (( /* 'INF' or 'inf' */
                   end-begin==3
                   &&
-                  (!memcmp(begin, lc_infinity, 3*sizeof(CharT)) || !memcmp(begin, lc_INFINITY, 3*sizeof(CharT)))
+                  lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
                 )
                 ||
                 ( /* 'INFINITY' or 'infinity' */
                   end-begin==inifinity_size
                   &&
-                  (!memcmp(begin, lc_infinity, inifinity_size)|| !memcmp(begin, lc_INFINITY, inifinity_size))
+                  lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
                 )
              )
             {
@@ -766,6 +799,41 @@ namespace boost
             return false;
         }
 
+        template <class CharT, class T>
+        bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
+                         , const CharT* lc_nan
+                         , const CharT* lc_infinity)
+        {
+            using namespace std;
+            const CharT minus = lcast_char_constants<CharT>::minus;
+            if ( (boost::math::isnan)(value) )
+            {
+                if ( (boost::math::signbit)(value) )
+                {
+                    *begin = minus;
+                    ++ begin;
+                }
+
+                memcpy(begin, lc_nan, 3 * sizeof(CharT));
+                end = begin + 3;
+                return true;
+            } else if ( (boost::math::isinf)(value) )
+            {
+                if ( (boost::math::signbit)(value) )
+                {
+                    *begin = minus;
+                    ++ begin;
+                }
+
+                memcpy(begin, lc_infinity, 3 * sizeof(CharT));
+                end = begin + 3;
+                return true;
+            }
+
+            return false;
+        }
+
+
 #ifndef BOOST_LCAST_NO_WCHAR_T
         template <class T>
         bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value)
@@ -775,6 +843,13 @@ namespace boost
                                , L"INFINITY", L"infinity"
                                , L'(', L')');
         }
+
+        template <class T>
+        bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value)
+        {
+            return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
+        }
+
 #endif
 #ifndef BOOST_NO_CHAR16_T
         template <class T>
@@ -785,6 +860,12 @@ namespace boost
                                , u"INFINITY", u"infinity"
                                , u'(', u')');
         }
+
+        template <class T>
+        bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value)
+        {
+            return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
+        }
 #endif
 #ifndef BOOST_NO_CHAR32_T
         template <class T>
@@ -795,6 +876,12 @@ namespace boost
                                , U"INFINITY", U"infinity"
                                , U'(', U')');
         }
+
+        template <class T>
+        bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value)
+        {
+            return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
+        }
 #endif
 
         template <class CharT, class T>
@@ -805,73 +892,12 @@ namespace boost
                                , "INFINITY", "infinity"
                                , '(', ')');
         }
-#ifndef BOOST_LCAST_NO_WCHAR_T
-        template <class T>
-        bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value)
-        {
-            using namespace std;
-            if ( (boost::math::isnan)(value) )
-            {
-                if ( (boost::math::signbit)(value) )
-                {
-                    memcpy(begin,L"-nan", sizeof(L"-nan"));
-                    end = begin + 4;
-                } else
-                {
-                    memcpy(begin,L"nan", sizeof(L"nan"));
-                    end = begin + 3;
-                }
-                return true;
-            } else if ( (boost::math::isinf)(value) )
-            {
-                if ( (boost::math::signbit)(value) )
-                {
-                    memcpy(begin,L"-inf", sizeof(L"-inf"));
-                    end = begin + 4;
-                } else
-                {
-                    memcpy(begin,L"inf", sizeof(L"inf"));
-                    end = begin + 3;
-                }
-                return true;
-            }
 
-            return false;
-        }
-#endif
         template <class CharT, class T>
         bool put_inf_nan(CharT* begin, CharT*& end, const T& value)
         {
-            using namespace std;
-            if ( (boost::math::isnan)(value) )
-            {
-                if ( (boost::math::signbit)(value) )
-                {
-                    memcpy(begin,"-nan", sizeof("-nan"));
-                    end = begin + 4;
-                } else
-                {
-                    memcpy(begin,"nan", sizeof("nan"));
-                    end = begin + 3;
-                }
-                return true;
-            } else if ( (boost::math::isinf)(value) )
-            {
-                if ( (boost::math::signbit)(value) )
-                {
-                    memcpy(begin,"-inf", sizeof("-inf"));
-                    end = begin + 4;
-                } else
-                {
-                    memcpy(begin,"inf", sizeof("inf"));
-                    end = begin + 3;
-                }
-                return true;
-            }
-
-            return false;
+            return put_inf_nan_impl(begin, end, value, "nan", "infinity");
         }
-
     }
 
 
@@ -927,7 +953,7 @@ namespace boost
             CharT const capital_e = lcast_char_constants<CharT>::capital_e;
             CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
 
-            value = 0.0;
+            value = static_cast<T>(0);
 
             if (parse_inf_nan(begin, end, value)) return true;
 
@@ -1141,7 +1167,7 @@ namespace boost
 
     namespace detail
     {
-        struct do_not_construct_stringbuffer_t{};
+        struct do_not_construct_out_stream_t{};
     }
 
     namespace detail // optimized stream wrapper
@@ -1153,25 +1179,27 @@ namespace boost
                 >
         class lexical_stream_limited_src
         {
-            typedef stl_buf_unlocker<std::basic_streambuf<CharT, Traits>, CharT > local_streambuffer_t;
 
 #if defined(BOOST_NO_STRINGSTREAM)
-            typedef stl_buf_unlocker<std::strstream, CharT > local_stringbuffer_t;
+            typedef std::ostrstream                         out_stream_t;
+            typedef stl_buf_unlocker<std::strstreambuf, char>  unlocked_but_t;
 #elif defined(BOOST_NO_STD_LOCALE)
-            typedef stl_buf_unlocker<std::stringstream, CharT > local_stringbuffer_t;
+            typedef std::ostringstream                      out_stream_t;
+            typedef stl_buf_unlocker<std::stringbuf, char>  unlocked_but_t;
 #else
-            typedef stl_buf_unlocker<std::basic_stringbuf<CharT, Traits>, CharT > local_stringbuffer_t;
+            typedef std::basic_ostringstream<CharT, Traits>       out_stream_t;
+            typedef stl_buf_unlocker<std::basic_stringbuf<CharT, Traits>, CharT> unlocked_but_t;
 #endif
             typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::if_c<
                 RequiresStringbuffer,
-                local_stringbuffer_t,
-                do_not_construct_stringbuffer_t
-            >::type deduced_stringbuffer_t;
+                out_stream_t,
+                do_not_construct_out_stream_t
+            >::type deduced_out_stream_t;
 
             // A string representation of Source is written to [start, finish).
             CharT* start;
             CharT* finish;
-            deduced_stringbuffer_t stringbuffer;
+            deduced_out_stream_t out_stream;
 
         public:
             lexical_stream_limited_src(CharT* sta, CharT* fin)
@@ -1232,10 +1260,16 @@ namespace boost
             template<typename InputStreamable>
             bool shl_input_streamable(InputStreamable& input)
             {
-                std::basic_ostream<CharT> stream(&stringbuffer);
-                bool const result = !(stream << input).fail();
-                start = stringbuffer.pbase();
-                finish = stringbuffer.pptr();
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
+                // If you have compilation error at this point, than your STL library
+                // unsupports such conversions. Try updating it.
+                BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));
+#endif
+                bool const result = !(out_stream << input).fail();
+                const unlocked_but_t* const p
+                        = static_cast<unlocked_but_t*>(out_stream.rdbuf()) ;
+                start = p->pbase();
+                finish = p->pptr();
                 return result;
             }
 
@@ -1346,6 +1380,7 @@ namespace boost
                 return true;
             }
 
+#if !defined(__SUNPRO_CC)
             template<class Alloc>
             bool operator<<(::boost::container::basic_string<CharT,Traits,Alloc> const& str)
             {
@@ -1353,7 +1388,7 @@ namespace boost
                 finish = start + str.length();
                 return true;
             }
-
+#endif // !defined(__SUNPRO_CC)
             bool operator<<(bool value)
             {
                 CharT const czero = lcast_char_constants<CharT>::zero;
@@ -1499,9 +1534,22 @@ namespace boost
                 if(is_pointer<InputStreamable>::value)
                     return false;
 
-                local_streambuffer_t bb;
-                bb.setg(start, start, finish);
-                std::basic_istream<CharT> stream(&bb);
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
+                // If you have compilation error at this point, than your STL library
+                // unsupports such conversions. Try updating it.
+                BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));
+#endif
+
+#if defined(BOOST_NO_STRINGSTREAM)
+                std::istrstream stream(start, finish - start);
+#elif defined(BOOST_NO_STD_LOCALE)
+                std::istringstream stream;
+#else
+                std::basic_istringstream<CharT, Traits> stream;
+#endif
+                static_cast<unlocked_but_t*>(stream.rdbuf())
+                        ->setg(start, start, finish);
+
                 stream.unsetf(std::ios::skipws);
                 lcast_set_precision(stream, static_cast<InputStreamable*>(0));
 #if (defined _MSC_VER)
@@ -1570,9 +1618,10 @@ namespace boost
 #else
             template<class Alloc>
             bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
-
+#if !defined(__SUNPRO_CC)
             template<class Alloc>
             bool operator>>(::boost::container::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
+#endif // !defined(__SUNPRO_CC)
 #endif
             /*
              * case "-0" || "0" || "+0" :   output = false; return true;
@@ -1708,13 +1757,13 @@ namespace boost
         {
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
-
+#if !defined(__SUNPRO_CC)
         template<typename CharT, typename Traits, typename Alloc>
         struct is_stdstring< ::boost::container::basic_string<CharT, Traits, Alloc> >
         {
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
-
+#endif // !defined(__SUNPRO_CC)
         template<typename T>
         struct is_char_or_wchar
         {
@@ -1814,7 +1863,7 @@ namespace boost
         {
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
-
+#if !defined(__SUNPRO_CC)
         template<typename CharT, typename Traits, typename Alloc>
         struct is_char_array_to_stdstring< ::boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
         {
@@ -1826,6 +1875,7 @@ namespace boost
         {
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
+#endif // !defined(__SUNPRO_CC)
 
 #if (defined _MSC_VER)
 # pragma warning( push )
@@ -1908,52 +1958,52 @@ namespace boost
             }
         };
 
-        class precision_loss_error : public boost::numeric::bad_numeric_cast
+        template<class Source, class Target >
+        struct detect_precision_loss
         {
-         public:
-            virtual const char * what() const throw()
-             {  return "bad numeric conversion: precision loss error"; }
-        };
+         typedef boost::numeric::Trunc<Source> Rounder;
+         typedef Source source_type ;
 
-        template<class S >
-        struct throw_on_precision_loss
-        {
-         typedef boost::numeric::Trunc<S> Rounder;
-         typedef S source_type ;
-
-         typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;
+         typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+            is_arithmetic<Source>, Source, Source const&
+          >::type argument_type ;
 
          static source_type nearbyint ( argument_type s )
          {
-            source_type orig_div_round = s / Rounder::nearbyint(s);
+            const source_type orig_div_round = s / Rounder::nearbyint(s);
+            const source_type eps = std::numeric_limits<source_type>::epsilon();
+
+            if ((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps)
+                BOOST_LCAST_THROW_BAD_CAST(Source, Target);
 
-            if ( (orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > std::numeric_limits<source_type>::epsilon() )
-               BOOST_THROW_EXCEPTION( precision_loss_error() );
             return s ;
          }
 
          typedef typename Rounder::round_style round_style;
         } ;
 
+        template<class Source, class Target >
+        struct nothrow_overflow_handler
+        {
+          void operator() ( boost::numeric::range_check_result r )
+          {
+            if (r != boost::numeric::cInRange)
+                BOOST_LCAST_THROW_BAD_CAST(Source, Target);
+          }
+        } ;
+
         template<typename Target, typename Source>
         struct lexical_cast_dynamic_num_not_ignoring_minus
         {
             static inline Target lexical_cast_impl(const Source &arg)
             {
-                try{
-                    typedef boost::numeric::converter<
-                            Target,
-                            Source,
-                            boost::numeric::conversion_traits<Target,Source>,
-                            boost::numeric::def_overflow_handler,
-                            throw_on_precision_loss<Source>
-                    > Converter ;
-
-                    return Converter::convert(arg);
-                } catch( ::boost::numeric::bad_numeric_cast const& ) {
-                    BOOST_LCAST_THROW_BAD_CAST(Source, Target);
-                }
-                BOOST_UNREACHABLE_RETURN(static_cast<Target>(0));
+                return boost::numeric::converter<
+                        Target,
+                        Source,
+                        boost::numeric::conversion_traits<Target,Source>,
+                        nothrow_overflow_handler<Source, Target>,
+                        detect_precision_loss<Source, Target>
+                >::convert(arg);
             }
         };
 
@@ -1962,25 +2012,17 @@ namespace boost
         {
             static inline Target lexical_cast_impl(const Source &arg)
             {
-                try{
-                    typedef boost::numeric::converter<
-                            Target,
-                            Source,
-                            boost::numeric::conversion_traits<Target,Source>,
-                            boost::numeric::def_overflow_handler,
-                            throw_on_precision_loss<Source>
-                    > Converter ;
+                typedef boost::numeric::converter<
+                        Target,
+                        Source,
+                        boost::numeric::conversion_traits<Target,Source>,
+                        nothrow_overflow_handler<Source, Target>,
+                        detect_precision_loss<Source, Target>
+                > converter_t;
 
-                    bool has_minus = ( arg < 0);
-                    if ( has_minus ) {
-                        return static_cast<Target>(-Converter::convert(-arg));
-                    } else {
-                        return Converter::convert(arg);
-                    }
-                } catch( ::boost::numeric::bad_numeric_cast const& ) {
-                    BOOST_LCAST_THROW_BAD_CAST(Source, Target);
-                }
-                BOOST_UNREACHABLE_RETURN(static_cast<Target>(0));
+                return (
+                    arg < 0 ? -converter_t::convert(-arg) : converter_t::convert(arg)
+                );
             }
         };
 
diff --git a/perf/Jamfile.v2 b/perf/Jamfile.v2
new file mode 100644
index 0000000..78176be
--- /dev/null
+++ b/perf/Jamfile.v2
@@ -0,0 +1,29 @@
+#==============================================================================
+#   Copyright (c) 2012 Antony Polukhin
+#
+#   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)
+#==============================================================================
+
+# performance tests
+import testing ;
+import path ;
+
+path-constant TEST_DIR : . ;
+
+project performance/test
+    : source-location ./
+    : requirements 
+#      <library>/boost/chrono//boost_chrono 
+#      <library>/boost/system//boost_system
+      <link>static
+      <target-os>freebsd:<linkflags>"-lrt" 
+      <target-os>linux:<linkflags>"-lrt"
+      <toolset>gcc:<cxxflags>-fvisibility=hidden
+      <toolset>intel-linux:<cxxflags>-fvisibility=hidden
+      <toolset>sun:<cxxflags>-xldscope=hidden
+    : default-build release
+ ;
+ 
+run performance_test.cpp : $(TEST_DIR) ;
+      
diff --git a/perf/performance_test.cpp b/perf/performance_test.cpp
new file mode 100644
index 0000000..ff1eb1d
--- /dev/null
+++ b/perf/performance_test.cpp
@@ -0,0 +1,309 @@
+//  (C) Copyright Antony Polukhin 2012.
+//  Use, modification and distribution are subject to 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)
+
+//  See http://www.boost.org/libs/config for most recent version.
+
+//
+// Testing lexical_cast<> performance
+//
+
+#define BOOST_ERROR_CODE_HEADER_ONLY
+#define BOOST_CHRONO_HEADER_ONLY
+
+#include <boost/lexical_cast.hpp>
+#include <boost/chrono.hpp>
+#include <fstream>
+#include <boost/container/string.hpp>
+
+// File to output data
+std::fstream fout;
+
+template <class OutT, class InT>
+static inline void test_lexical(const InT& in_val) {
+    OutT out_val = boost::lexical_cast<OutT>(in_val);
+    (void)out_val;
+}
+
+template <class OutT, class InT>
+static inline void test_ss_constr(const InT& in_val) {
+    OutT out_val;
+    std::stringstream ss;
+    ss << in_val;
+    if (ss.fail()) throw std::logic_error("descr");
+    ss >> out_val;
+    if (ss.fail()) throw std::logic_error("descr");
+}
+
+template <class OutT, class StringStreamT, class InT>
+static inline void test_ss_noconstr(StringStreamT& ss, const InT& in_val) {
+    OutT out_val;
+    ss << in_val; // ss is an instance of std::stringstream
+    if (ss.fail()) throw std::logic_error("descr");
+    ss >> out_val;
+    if (ss.fail()) throw std::logic_error("descr");
+    /* reseting std::stringstream to use it again */
+    ss.str(std::string());
+    ss.clear();
+}
+
+struct structure_sprintf {
+    template <class OutT, class BufferT, class InT>
+    static inline void test(BufferT* buffer, const InT& in_val, const char* const conv) {
+        sprintf(buffer, conv, in_val);
+        OutT out_val(buffer);
+    }
+
+    template <class OutT, class BufferT>
+    static inline void test(BufferT* buffer, const std::string& in_val, const char* const conv) {
+        sprintf(buffer, conv, in_val.c_str());
+        OutT out_val(buffer);
+    }
+};
+
+struct structure_sscanf {
+    template <class OutT, class BufferT, class InT>
+    static inline void test(BufferT* /*buffer*/, const InT& in_val, const char* const conv) {
+        OutT out_val;
+        sscanf(reinterpret_cast<const char*>(in_val), conv, &out_val);
+    }
+
+    template <class OutT, class BufferT>
+    static inline void test(BufferT* /*buffer*/, const std::string& in_val, const char* const conv) {
+        OutT out_val;
+        sscanf(in_val.c_str(), conv, &out_val);
+    }
+};
+
+struct structure_fake {
+    template <class OutT, class BufferT, class InT>
+    static inline void test(BufferT* /*buffer*/, const InT& /*in_val*/, const char* const /*conv*/) {}
+};
+
+static const int fake_test_value = 9999;
+
+template <class T>
+static inline void min_fancy_output(T v1, T v2, T v3, T v4) {
+    const char beg_mark[] = "!!! *";
+    const char end_mark[] = "* !!!";
+    const char no_mark[] = "";
+
+    unsigned int res = 4;
+    if (v1 < v2 && v1 < v3 && v1 < v4) res = 1;
+    if (v2 < v1 && v2 < v3 && v2 < v4) res = 2;
+    if (v3 < v1 && v3 < v2 && v3 < v4) res = 3;
+
+    fout << "[ "
+         << (res == 1 ? beg_mark : no_mark)
+         ;
+
+    if (v1) fout << v1;
+    else fout << "<1";
+
+    fout << (res == 1 ? end_mark : no_mark)
+         << " ][ "
+         << (res == 2 ? beg_mark : no_mark)
+         ;
+
+       if (v2) fout << v2;
+       else fout << "<1";
+
+       fout << (res == 2 ? end_mark : no_mark)
+         << " ][ "
+         << (res == 3 ? beg_mark : no_mark)
+         ;
+
+       if (v3) fout << v3;
+       else fout << "<1";
+
+       fout << (res == 3 ? end_mark : no_mark)
+         << " ][ "
+         << (res == 4 ? beg_mark : no_mark)
+         ;
+
+       if (!v4) fout << "<1";
+       else if (v4 == fake_test_value) fout << "---";
+       else fout << v4;
+
+       fout
+         << (res == 4 ? end_mark : no_mark)
+         << " ]";
+}
+
+template <unsigned int IetartionsCountV, class ToT, class SprintfT, class FromT>
+static inline void perf_test_impl(const FromT& in_val, const char* const conv) {
+
+    typedef boost::chrono::steady_clock test_clock;
+    test_clock::time_point start;
+    typedef boost::chrono::milliseconds duration_t;
+    duration_t lexical_cast_time, ss_constr_time, ss_noconstr_time, printf_time;
+
+    start = test_clock::now();
+    for (unsigned int i = 0; i < IetartionsCountV; ++i) {
+        test_lexical<ToT>(in_val);
+        test_lexical<ToT>(in_val);
+        test_lexical<ToT>(in_val);
+        test_lexical<ToT>(in_val);
+    }
+    lexical_cast_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
+
+
+    start = test_clock::now();
+    for (unsigned int i = 0; i < IetartionsCountV; ++i) {
+        test_ss_constr<ToT>(in_val);
+        test_ss_constr<ToT>(in_val);
+        test_ss_constr<ToT>(in_val);
+        test_ss_constr<ToT>(in_val);
+    }
+    ss_constr_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
+
+    std::stringstream ss;
+    start = test_clock::now();
+    for (unsigned int i = 0; i < IetartionsCountV; ++i) {
+        test_ss_noconstr<ToT>(ss, in_val);
+        test_ss_noconstr<ToT>(ss, in_val);
+        test_ss_noconstr<ToT>(ss, in_val);
+        test_ss_noconstr<ToT>(ss, in_val);
+    }
+    ss_noconstr_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
+
+
+    char buffer[128];
+    start = test_clock::now();
+    for (unsigned int i = 0; i < IetartionsCountV; ++i) {
+        SprintfT::template test<ToT>(buffer, in_val, conv);
+        SprintfT::template test<ToT>(buffer, in_val, conv);
+        SprintfT::template test<ToT>(buffer, in_val, conv);
+        SprintfT::template test<ToT>(buffer, in_val, conv);
+    }
+    printf_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
+
+    min_fancy_output(
+                lexical_cast_time.count(),
+                ss_constr_time.count(),
+                ss_noconstr_time.count(),
+                boost::is_same<SprintfT, structure_fake>::value ? fake_test_value : printf_time.count()
+    );
+}
+
+template <class ToT, class SprintfT, class FromT>
+static inline void perf_test(const std::string& test_name, const FromT& in_val, const char* const conv) {
+    const unsigned int ITERATIONSCOUNT = 100000;
+    fout << "  [[ " << test_name << " ]";
+
+    perf_test_impl<ITERATIONSCOUNT/4, ToT, SprintfT>(in_val, conv);
+
+    fout << "]\n";
+}
+
+
+template <class ConverterT>
+void string_like_test_set(const std::string& from) {
+    typedef structure_sscanf ssc_t;
+    ConverterT conv;
+
+    perf_test<char, ssc_t>(from + "->char",               conv("c"), "%c");
+    perf_test<signed char, ssc_t>(from + "->signed char", conv("c"), "%hhd");
+    perf_test<unsigned char, ssc_t>(from + "->unsigned char", conv("c"), "%hhu");
+
+    perf_test<int, ssc_t>(from + "->int",             conv("100"), "%d");
+    perf_test<short, ssc_t>(from + "->short",         conv("100"), "%hd");
+    perf_test<long int, ssc_t>(from + "->long int",   conv("100"), "%ld");
+    perf_test<boost::long_long_type, ssc_t>(from + "->long long", conv("100"), "%lld");
+
+    perf_test<unsigned int, ssc_t>(from + "->unsigned int",             conv("100"), "%u");
+    perf_test<unsigned short, ssc_t>(from + "->unsigned short",         conv("100"), "%hu");
+    perf_test<unsigned long int, ssc_t>(from + "->unsigned long int",   conv("100"), "%lu");
+    perf_test<boost::ulong_long_type, ssc_t>(from + "->unsigned long long", conv("100"), "%llu");
+
+    // perf_test<bool, ssc_t>(from + "->bool", conv("1"), "%");
+
+    perf_test<float, ssc_t>(from + "->float",             conv("1.123"), "%f");
+    perf_test<double, ssc_t>(from + "->double",           conv("1.123"), "%lf");
+    perf_test<long double, ssc_t>(from + "->long double", conv("1.123"), "%Lf");
+
+
+    perf_test<std::string, structure_fake>(from + "->string", conv("string"), "%Lf");
+    perf_test<boost::container::string, structure_fake>(from + "->container::string"
+                                                        , conv("string"), "%Lf");
+
+}
+
+struct to_string_conv {
+    std::string operator()(const char* const c) const {
+        return c;
+    }
+};
+
+struct to_char_conv {
+    const char*  operator()(const char* const c) const {
+        return c;
+    }
+};
+
+struct to_uchar_conv {
+    const unsigned char*  operator()(const char* const c) const {
+        return reinterpret_cast<const unsigned char*>(c);
+    }
+};
+
+
+struct to_schar_conv {
+    const signed char*  operator()(const char* const c) const {
+        return reinterpret_cast<const signed char*>(c);
+    }
+};
+
+int main(int argc, char** argv) {
+    BOOST_ASSERT(argc >= 2);
+    std::string output_path(argv[1]);
+    output_path += "/results.txt";
+    fout.open(output_path.c_str(), std::fstream::in | std::fstream::out | std::fstream::app);
+    BOOST_ASSERT(fout);
+
+    fout << "[section " << BOOST_COMPILER << "]\n"
+        << "[table:id Performance Table ( "<< BOOST_COMPILER << ")\n"
+        << "[[From->To] [lexical_cast] [std::stringstream with construction] "
+        << "[std::stringstream without construction][scanf/printf]]\n";
+
+
+    // From std::string to ...
+    string_like_test_set<to_string_conv>("string");
+
+    // From ... to std::string
+    perf_test<std::string, structure_sprintf>("string->char",                'c', "%c");
+    perf_test<std::string, structure_sprintf>("string->signed char",     static_cast<signed char>('c'), "%hhd");
+    perf_test<std::string, structure_sprintf>("string->unsigned char", static_cast<unsigned char>('c'), "%hhu");
+
+    perf_test<std::string, structure_sprintf>("int->string",                 100, "%d");
+    perf_test<std::string, structure_sprintf>("short->string",               static_cast<short>(100), "%hd");
+    perf_test<std::string, structure_sprintf>("long int->string",            100l, "%ld");
+    perf_test<std::string, structure_sprintf>("long long->string",           100ll, "%lld");
+
+    perf_test<std::string, structure_sprintf>("unsigned int->string",        static_cast<unsigned short>(100u), "%u");
+    perf_test<std::string, structure_sprintf>("unsigned short->string",      100u, "%hu");
+    perf_test<std::string, structure_sprintf>("unsigned long int->string",   100ul, "%lu");
+    perf_test<std::string, structure_sprintf>("unsigned long long->string",  static_cast<boost::ulong_long_type>(100), "%llu");
+
+    // perf_test<bool, structure_sscanf>("bool->string", std::string("1"), "%");
+
+    perf_test<std::string, structure_sprintf>("float->string",       1.123f, "%f");
+    perf_test<std::string, structure_sprintf>("double->string",      1.123, "%lf");
+    perf_test<std::string, structure_sprintf>("long double->string", 1.123L, "%Lf");
+
+
+    string_like_test_set<to_char_conv>("char*");
+    string_like_test_set<to_uchar_conv>("unsigned char*");
+    string_like_test_set<to_schar_conv>("signed char*");
+
+    perf_test<int, structure_fake>("int->int", 100, "");
+    perf_test<double, structure_fake>("float->double", 100.0f, "");
+    perf_test<signed char, structure_fake>("char->signed char", 'c', "");
+
+    fout << "]\n"
+        << "[endsect]\n\n";
+    return 0;
+}
+
+
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index c311420..019c9e7 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -38,5 +38,12 @@ test-suite conversion
     [ run lexical_cast_pointers_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
     [ compile lexical_cast_typedefed_wchar_test.cpp : <toolset>msvc:<nowchar>on ]
     [ run lexical_cast_typedefed_wchar_test_runtime.cpp ../../test/build//boost_unit_test_framework/<link>static : : : <toolset>msvc:<nowchar>on ]
-  ;
-      
+    [ run lexical_cast_no_locale_test.cpp ../../test/build//boost_unit_test_framework/<link>static : : : <define>BOOST_NO_STD_LOCALE <define>BOOST_LEXICAL_CAST_ASSUME_C_LOCALE ]
+    [ run lexical_cast_no_exceptions_test.cpp ../../test/build//boost_unit_test_framework/<link>static : : : <define>BOOST_NO_EXCEPTIONS 
+      <toolset>gcc-4.3:<cflags>-fno-exceptions
+      <toolset>gcc-4.4:<cflags>-fno-exceptions
+      <toolset>gcc-4.5:<cflags>-fno-exceptions
+      <toolset>gcc-4.6:<cflags>-fno-exceptions
+    ]
+  ;   
+
diff --git a/test/lexical_cast_containers_test.cpp b/test/lexical_cast_containers_test.cpp
index 5f98ac8..0c6315b 100644
--- a/test/lexical_cast_containers_test.cpp
+++ b/test/lexical_cast_containers_test.cpp
@@ -13,6 +13,7 @@
 #include <boost/container/string.hpp>
 
 void testing_boost_containers_basic_string();
+void testing_boost_containers_string_std_string();
 
 using namespace boost;
 
@@ -21,6 +22,7 @@ boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
     unit_test::test_suite *suite =
         BOOST_TEST_SUITE("Testing boost::lexical_cast with boost::container::string");
     suite->add(BOOST_TEST_CASE(testing_boost_containers_basic_string));
+    suite->add(BOOST_TEST_CASE(testing_boost_containers_string_std_string));
 
     return suite;
 }
@@ -35,4 +37,24 @@ void testing_boost_containers_basic_string()
     BOOST_CHECK(1000 == lexical_cast<int>(str));
 }
 
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
 
+void testing_boost_containers_string_std_string()
+{
+    std::string std_str("std_str");
+    boost::container::string boost_str("boost_str");
+    BOOST_CHECK(boost::lexical_cast<std::string>(boost_str) == "boost_str");
+    BOOST_CHECK(boost::lexical_cast<boost::container::string>(std_str) == "std_str");
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    std::wstring std_wstr(L"std_wstr");
+    boost::container::wstring boost_wstr(L"boost_wstr");
+
+    BOOST_CHECK(boost::lexical_cast<std::wstring>(boost_wstr) == L"boost_wstr");
+    BOOST_CHECK(boost::lexical_cast<boost::container::wstring>(std_wstr) == L"std_wstr");
+
+#endif
+
+}
diff --git a/test/lexical_cast_empty_input_test.cpp b/test/lexical_cast_empty_input_test.cpp
index 5a5881b..df05981 100755
--- a/test/lexical_cast_empty_input_test.cpp
+++ b/test/lexical_cast_empty_input_test.cpp
@@ -138,6 +138,19 @@ void test_empty_vector()
     BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
 }
 
+
+struct my_string {
+    friend std::ostream &operator<<(std::ostream& sout, my_string const&/* st*/) {
+            return sout << "";
+    }
+};
+
+void test_empty_zero_terminated_string()
+{
+    my_string st;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(st), std::string());;
+}
+
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
     unit_test::test_suite *suite =
@@ -146,6 +159,7 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
     suite->add(BOOST_TEST_CASE(&test_empty_string));
     suite->add(BOOST_TEST_CASE(&test_empty_user_class));
     suite->add(BOOST_TEST_CASE(&test_empty_vector));
+    suite->add(BOOST_TEST_CASE(&test_empty_zero_terminated_string));
 
     return suite;
 }
diff --git a/test/lexical_cast_inf_nan_test.cpp b/test/lexical_cast_inf_nan_test.cpp
index bb4331a..af1caa0 100755
--- a/test/lexical_cast_inf_nan_test.cpp
+++ b/test/lexical_cast_inf_nan_test.cpp
@@ -85,6 +85,12 @@ void test_inf_nan_templated()
     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+infinity") ) );
     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INFINITY") ) );
 
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("iNfiNity") ) );
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INfinity") ) );
+
+    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-inFINITY") ) );
+    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
+
     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan") ) );
     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN") ) );
 
@@ -94,6 +100,15 @@ void test_inf_nan_templated()
     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+nan") ) );
     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+NAN") ) );
 
+    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nAn") ) );
+    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NaN") ) );
+
+    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-nAn") ) );
+    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-NaN") ) );
+
+    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+Nan") ) );
+    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+nAN") ) );
+
     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan()") ) );
     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN(some string)") ) );
     BOOST_CHECK_THROW( lexical_cast<test_t>("NAN(some string"), bad_lexical_cast );
@@ -127,6 +142,12 @@ void test_inf_nan_templated()
     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+infinity") ) );
     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INFINITY") ) );
 
+    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-infINIty") ) );
+    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INFiniTY") ) );
+
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+inFINIty") ) );
+    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INfinITY") ) );
+
     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan") ) );
     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN") ) );
 
diff --git a/test/lexical_cast_no_exceptions_test.cpp b/test/lexical_cast_no_exceptions_test.cpp
new file mode 100755
index 0000000..8431c3a
--- /dev/null
+++ b/test/lexical_cast_no_exceptions_test.cpp
@@ -0,0 +1,95 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2012.
+//
+//  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).
+
+#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>
+#include <boost/range/iterator_range.hpp>
+
+#ifndef BOOST_NO_EXCEPTIONS
+#error "This test must be compiled with -DBOOST_NO_EXCEPTIONS"
+#endif 
+
+bool g_was_exception = false;
+
+namespace boost {
+
+void throw_exception(std::exception const & ) {
+	g_was_exception = true;
+}
+
+}
+
+using namespace boost;
+
+
+struct Escape
+{
+    Escape(){}
+    Escape(const std::string& s)
+        : str_(s)
+    {}
+
+    std::string str_;
+};
+
+inline std::ostream& operator<< (std::ostream& o, const Escape& rhs)
+{
+    return o << rhs.str_;
+}
+
+inline std::istream& operator>> (std::istream& i, Escape& rhs)
+{
+    return i >> rhs.str_;
+}
+
+void test_exceptions_off()
+{
+    Escape v("");
+            
+    g_was_exception = false;        
+    lexical_cast<char>(v);
+    BOOST_CHECK(g_was_exception);
+    
+    g_was_exception = false;
+    lexical_cast<unsigned char>(v);
+    BOOST_CHECK(g_was_exception);
+    
+    v = lexical_cast<Escape>(100);
+    BOOST_CHECK_EQUAL(lexical_cast<int>(v), 100);
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(v), 100u);
+    
+    v = lexical_cast<Escape>(0.0);
+    BOOST_CHECK_EQUAL(lexical_cast<double>(v), 0.0);
+
+    BOOST_CHECK_EQUAL(lexical_cast<short>(100), 100);
+    BOOST_CHECK_EQUAL(lexical_cast<float>(0.0), 0.0);
+    
+    g_was_exception = false;
+    lexical_cast<short>(700000);
+    BOOST_CHECK(g_was_exception);
+}
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast. Testing with BOOST_NO_EXCEPTIONS");
+    suite->add(BOOST_TEST_CASE(&test_exceptions_off));
+
+    return suite;
+}
+
diff --git a/test/lexical_cast_no_locale_test.cpp b/test/lexical_cast_no_locale_test.cpp
new file mode 100755
index 0000000..f3defb3
--- /dev/null
+++ b/test/lexical_cast_no_locale_test.cpp
@@ -0,0 +1,166 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2012.
+//
+//  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).
+
+#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>
+#include <boost/range/iterator_range.hpp>
+
+using namespace boost;
+
+// Testing compilation and some basic usage with BOOST_NO_STD_LOCALE
+// Tests are mainly copyied from lexical_cast_empty_input_test.cpp (something 
+// new added to test_empty_3)
+
+#ifndef BOOST_NO_STD_LOCALE
+#error "This test must be compiled with -DBOOST_NO_STD_LOCALE"
+#endif 
+
+
+template <class T>
+void do_test_on_empty_input(T& v)
+{
+    BOOST_CHECK_THROW(lexical_cast<int>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<float>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
+#if defined(BOOST_HAS_LONG_LONG)
+    BOOST_CHECK_THROW(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
+#elif defined(BOOST_HAS_MS_INT64)
+    BOOST_CHECK_THROW(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<__int64>(v), bad_lexical_cast);
+#endif
+}
+
+void test_empty_1()
+{
+    boost::iterator_range<char*> v;
+    do_test_on_empty_input(v);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(v), std::string());
+    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+
+    boost::iterator_range<const char*> cv;
+    do_test_on_empty_input(cv);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(cv), std::string());
+    BOOST_CHECK_THROW(lexical_cast<char>(cv), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(cv), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(cv), bad_lexical_cast);
+
+    const boost::iterator_range<const char*> ccv;
+    do_test_on_empty_input(ccv);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(ccv), std::string());
+    BOOST_CHECK_THROW(lexical_cast<char>(ccv), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(ccv), bad_lexical_cast);
+}
+
+void test_empty_2()
+{
+    std::string v;
+    do_test_on_empty_input(v);
+    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+}
+
+struct Escape
+{
+    Escape(){}
+    Escape(const std::string& s)
+        : str_(s)
+    {}
+
+    std::string str_;
+};
+
+inline std::ostream& operator<< (std::ostream& o, const Escape& rhs)
+{
+    return o << rhs.str_;
+}
+
+inline std::istream& operator>> (std::istream& i, Escape& rhs)
+{
+    return i >> rhs.str_;
+}
+
+void test_empty_3()
+{
+    Escape v("");
+    do_test_on_empty_input(v);
+            
+    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+    
+    v = lexical_cast<Escape>(100);
+    BOOST_CHECK_EQUAL(lexical_cast<int>(v), 100);
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(v), 100u);
+    
+    v = lexical_cast<Escape>(0.0);
+    BOOST_CHECK_EQUAL(lexical_cast<double>(v), 0.0);
+}
+
+namespace std {
+inline std::ostream & operator<<(std::ostream & out, const std::vector<long> & v)
+{
+    std::ostream_iterator<long> it(out);
+    std::copy(v.begin(), v.end(), it);
+    assert(out);
+    return out;
+}
+}
+
+void test_empty_4()
+{
+    std::vector<long> v;
+    do_test_on_empty_input(v);
+    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+}
+
+
+struct my_string {
+    friend std::ostream &operator<<(std::ostream& sout, my_string const&/* st*/) {
+            return sout << "";
+    }
+};
+
+void test_empty_5()
+{
+    my_string st;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(st), std::string());;
+}
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast. Testing with BOOST_NO_STD_LOCALE");
+    suite->add(BOOST_TEST_CASE(&test_empty_1));
+    suite->add(BOOST_TEST_CASE(&test_empty_2));
+    suite->add(BOOST_TEST_CASE(&test_empty_3));
+    suite->add(BOOST_TEST_CASE(&test_empty_4));
+    suite->add(BOOST_TEST_CASE(&test_empty_5));
+
+    return suite;
+}
+
diff --git a/test/lexical_cast_typedefed_wchar_test.cpp b/test/lexical_cast_typedefed_wchar_test.cpp
index 752c3e5..2dc0098 100755
--- a/test/lexical_cast_typedefed_wchar_test.cpp
+++ b/test/lexical_cast_typedefed_wchar_test.cpp
@@ -13,12 +13,27 @@
 #include <boost/static_assert.hpp>
 #include <boost/lexical_cast.hpp>
 
+#include <boost/date_time/gregorian/gregorian.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+void parseDate()
+{
+  std::locale locale;
+  boost::date_time::format_date_parser<boost::gregorian::date, wchar_t> parser(L"", locale);
+  boost::date_time::special_values_parser<boost::gregorian::date, wchar_t> svp;
+
+  boost::gregorian::date date = parser.parse_date(L"", L"", svp);
+  (void)date;
+}
+
+
 int main()
 {
 #ifdef BOOST_MSVC
     BOOST_STATIC_ASSERT((boost::is_same<wchar_t, unsigned short>::value));
 #endif
 
+    parseDate();
     return ::boost::lexical_cast<int>(L"1000") == 1000;
 }